LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x3c3a
movq (%r14), %r15
leaq (%r15,%rax), %r12
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x3cea
movq %r15, %rdi
movq %r12, %rsi
callq 0x3dc8
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x3c73
movq (%rbx), %r15
leaq (%r15,%rax), %r12
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x3cea
movq %r15, %rdi
movq %r12, %rsi
callq 0x3dc8
movq 0x8(%rbx), %rcx
jmp 0x3c75
xorl %ecx, %ecx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq (%r14), %rdi
movq 0x8(%r14), %rsi
addq %rdi, %rsi
movq (%rbx), %rdx
addq %rdx, %rcx
leaq -0x40(%rbp), %r8
callq 0x4032
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rbx
cmpq %r15, %rdi
je 0x3cbb
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2220
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x3ce2
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2220
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
movq (%rsi), %rsi
leaq -0x250(%rbp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x2350
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq -0x1d8(%rbp), %rdi
callq 0x2080
movl $0x1, %r15d
testb %al, %al
je 0x4232
leaq 0x40(%rbx), %r15
leaq -0x48(%rbp), %r12
movq -0x250(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2360
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x420e
cmpq $0x5, -0x40(%rbp)
jne 0x4253
movq %r15, %rdi
movq %r12, %rsi
callq 0x4712
movq %rax, %rdi
movq %r15, %rsi
callq 0x2050
incq 0x50(%rbx)
jmp 0x41b7
leaq -0x250(%rbp), %rdi
callq 0x2070
movq -0x48(%rbp), %rdi
xorl %r15d, %r15d
cmpq %r13, %rdi
je 0x4232
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x250(%rbp), %rdi
callq 0x2090
movl %r15d, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x216b(%rip), %rdi      # 0x63c5
leaq 0x2180(%rip), %rsi      # 0x63e1
leaq 0x2185(%rip), %rcx      # 0x63ed
movl $0x23, %edx
callq 0x2130
jmp 0x4274
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x428c
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x250(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/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
testl %edx, %edx
jle 0x43a7
movq (%r14), %r14
decl %edx
jne 0x43a0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x390c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15d
movq %rdi, %r12
movq 0x50(%rdi), %rax
movq %rax, -0x30(%rbp)
movq 0x4bd7(%rip), %rbx      # 0x8fd0
leaq 0x2017(%rip), %rsi      # 0x6417
movl $0x29, %edx
movq %rbx, %rdi
callq 0x2260
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq 0x40(%r12), %rbx
addq $0x40, %r12
cmpq %r12, %rbx
sete %al
testl %r15d, %r15d
setle %cl
orb %al, %cl
jne 0x44a5
movl $0x1, %r13d
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq 0x4b6e(%rip), %rdi      # 0x8fd0
callq 0x2260
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq (%rbx), %rbx
cmpq %r12, %rbx
je 0x44a5
leal 0x1(%r13), %eax
cmpl %r15d, %r13d
movl %eax, %r13d
jl 0x4453
addl %r15d, %r15d
movq -0x30(%rbp), %r14
cmpl %r14d, %r15d
jge 0x459c
leaq 0x1ce0(%rip), %r15      # 0x619c
movl $0x3, %edx
movq 0x4b08(%rip), %rbx      # 0x8fd0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2260
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq 0x1f40(%rip), %rsi      # 0x6441
movl $0x4, %edx
movq %rbx, %rdi
callq 0x2260
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2140
movq %rax, %r14
leaq 0x1f23(%rip), %rsi      # 0x6446
movl $0xa, %edx
movq %rax, %rdi
callq 0x2260
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movl $0x3, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2260
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2150
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4a0c(%rip), %r14      # 0x8fd0
leaq 0x1e86(%rip), %rsi      # 0x6451
movl $0x19, %edx
movq %r14, %rdi
callq 0x2260
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %r14, %rdi
callq 0x2260
movq %rax, %r14
leaq 0x1e79(%rip), %rsi      # 0x646b
movl $0x13, %edx
movq %rax, %rdi
callq 0x2260
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq 0x28(%rbx), %r13
cmpq 0x30(%rbx), %r13
je 0x46a1
movq 0x4999(%rip), %r14      # 0x8fd0
leaq 0x1e41(%rip), %r15      # 0x647f
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r14, %rdi
callq 0x2260
movq %rax, %r12
movl $0x4, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2260
movl 0x20(%r13), %esi
movq %r12, %rdi
callq 0x2310
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
addq $0x28, %r13
cmpq 0x30(%rbx), %r13
jne 0x463e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
addq $0x40, %r14
movq 0x4567(%rip), %r12      # 0x8fd0
leaq -0x38(%rbp), %r13
movq 0x456c(%rip), %rdi      # 0x8fe0
movq %rbx, %rsi
callq 0x22a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x4b1a
movq (%r14), %r15
movq %rbx, -0x38(%rbp)
cmpq %r14, %r15
je 0x4ab3
movq %r13, %rdi
movq %r15, %rsi
callq 0x4be4
testb %al, %al
jne 0x4aae
movq (%r15), %r15
jmp 0x4a95
cmpq %r14, %r15
jne 0x4b08
movl $0x2e, %edx
movq %r12, %rdi
leaq 0x19ef(%rip), %rsi      # 0x64b1
callq 0x2260
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movl $0x18, %edx
movq %r12, %rdi
leaq 0x19e2(%rip), %rsi      # 0x64e0
callq 0x2260
jmp 0x4a6d
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x44af(%rip), %rdi      # 0x8fd0
leaq 0x19d1(%rip), %rsi      # 0x64f9
movl $0x14, %edx
callq 0x2260
movq 0x4497(%rip), %rdi      # 0x8fd0
callq 0x20e0
xorl %edi, %edi
callq 0x2280
jmp 0x4b47
movq %rax, %r14
movq (%rbx), %rdi
movq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0x4b61
movq (%rax), %rsi
incq %rsi
callq 0x2220
movq %r14, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x444f(%rip), %r15      # 0x8fd0
leaq 0x191b(%rip), %rsi      # 0x64a3
movl $0xd, %edx
movq %r15, %rdi
callq 0x2260
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4a30
leaq 0x1629(%rip), %rsi      # 0x61d0
movl $0x1, %edx
movq %r15, %rdi
callq 0x2260
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x4bdc
movq (%rbx), %rsi
incq %rsi
callq 0x2220
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
leaq 0x40(%rdi), %rbx
movq 0x40(%rdi), %r14
cmpq %rbx, %r14
je 0x4c80
leaq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x4d1c
movq (%r14), %r12
testb %al, %al
je 0x4c75
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e5a
movq %r12, %r14
cmpq %rbx, %r12
jne 0x4c57
movq (%rbx), %r14
movq 0x30(%r15), %rax
addq $-0x28, %rax
movq %rax, -0x28(%rbp)
cmpq %rbx, %r14
je 0x4cac
leaq -0x28(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4e9a
testb %al, %al
jne 0x4cac
movq (%r14), %r14
cmpq %rbx, %r14
jne 0x4c95
cmpq %rbx, %r14
je 0x4cbc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e5a
cmpq %rbx, (%rbx)
je 0x4cce
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x42fb(%rip), %rbx      # 0x8fd0
leaq 0x1842(%rip), %rsi      # 0x651e
movq %rbx, %rdi
callq 0x2200
movq %rax, %rdi
callq 0x20e0
leaq 0x185c(%rip), %rsi      # 0x654f
movq %rbx, %rdi
callq 0x2200
leaq 0x1881(%rip), %rsi      # 0x6583
movq %rbx, %rdi
callq 0x2200
movq %rax, %rdi
callq 0x20e0
movl $0x1, %edi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/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 0x437e
movq %r14, %rdi
callq 0x4374
leaq 0x40(%r14), %r13
movq 0x40(%r14), %rbx
cmpq %r13, %rbx
je 0x4f9e
movq %rax, %r15
cvtsi2sd %r15d, %xmm0
mulsd 0x1662(%rip), %xmm0     # 0x65a8
movsd %xmm0, -0x40(%rbp)
xorpd %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x20a0
cltd
idivl %r15d
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
movsd -0x40(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x4f96
leaq 0x10(%rbx), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x4fda
ucomisd -0x38(%rbp), %xmm0
jbe 0x4f96
movq -0x30(%rbp), %rdi
movq %r12, %rsi
movsd %xmm0, -0x38(%rbp)
callq 0x2100
movq (%rbx), %rbx
cmpq %r13, %rbx
jne 0x4f54
movq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4fb3
movq %rax, %r14
movq -0x30(%rbp), %rcx
movq (%rcx), %rdi
addq $0x10, %rcx
cmpq %rcx, %rdi
je 0x4fd1
movq (%rcx), %rsi
incq %rsi
callq 0x2220
movq %r14, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x88, %rsp
movq %rdi, %rbx
leaq 0x40(%rdi), %rax
movq 0x40(%rdi), %r13
movq %rax, -0x30(%rbp)
cmpq %rax, %r13
je 0x50ad
movq %rsi, %r14
leaq -0x70(%rbp), %r15
leaq -0x50(%rbp), %r12
leaq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x390c
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x10(%r13), %rsi
movq 0x18(%r13), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x390c
movq %r15, %rdi
movq %r12, %rsi
callq 0x3bf2
cltq
movsd -0xb0(%rbp,%rax,8), %xmm0
addsd 0x154c(%rip), %xmm0     # 0x65b0
movsd %xmm0, -0xb0(%rbp,%rax,8)
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5086
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x509f
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2220
movq (%r13), %r13
cmpq -0x30(%rbp), %r13
jne 0x5011
xorpd %xmm0, %xmm0
xorl %r14d, %r14d
movsd %xmm0, -0x30(%rbp)
movsd -0xb0(%rbp,%r14,8), %xmm0
movsd 0x50(%rbx), %xmm2
unpcklps 0x1501(%rip), %xmm2     # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
subpd 0x1509(%rip), %xmm2     # 0x65e0
movapd %xmm2, %xmm1
unpckhpd %xmm2, %xmm1            # xmm1 = xmm1[1],xmm2[1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x78(%rbp)
callq 0x2190
divsd 0x14bf(%rip), %xmm0     # 0x65b8
mulsd -0x78(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
incq %r14
cmpq $0x6, %r14
jne 0x50b4
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x514d
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x514d
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x5166
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2220
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
leaq -0x78(%rbp), %rdi
callq 0x4346
leaq -0x58(%rbp), %rdi
movq %r15, %rsi
callq 0x4346
movq (%r15), %rax
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq *0x8(%rax)
leaq -0x78(%rbp), %rsi
movq %rbx, %rdi
callq 0x57c0
leaq -0x38(%rbp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x2290
movq (%r15), %rdi
leaq -0x28(%rbp), %r15
cmpq %r15, %rdi
je 0x5210
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2220
movq (%r14), %rax
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq *0x8(%rax)
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x57c0
leaq -0x38(%rbp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2290
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x524c
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5265
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x527e
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x2220
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
jne 0x52a9
jmp 0x52ba
jmp 0x52b7
movq %rax, %r14
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52ba
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x52ba
movq %rax, %r14
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52d8
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x52d8
movq %rax, %r14
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52f6
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x52f6
movq %rax, %r14
movq %rbx, %rdi
callq 0x35fc
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movq %rsp, %rsi
movq %rdx, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rax, %rdi
callq 0x4222
testq %rax, %rax
je 0x2755
movq %rax, %r14
movq 0x10(%rax), %rax
movq 0x18(%r14), %rcx
cmpq %rax, %rcx
je 0x2755
xorl %r15d, %r15d
xorl %r12d, %r12d
leaq (%rax,%r15), %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x272f
movq (%rdx), %rdx
movq %rdx, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x273f
movq %rbx, %rdi
callq 0x427e
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
incq %r12
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
addq $0x8, %r15
cmpq %rdx, %r12
jb 0x2711
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2774
callq 0x2260
movq %r14, %rdi
callq 0x23e0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x4d94
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x69b9(%rip), %rdi      # 0x9288
callq 0x43b4
leaq 0x69dd(%rip), %rdi      # 0x92b8
movq %rsp, %rsi
callq 0x4222
testq %rax, %rax
je 0x28f9
leaq 0x69c9(%rip), %rdi      # 0x92b8
movq %rsp, %rsi
callq 0x44c6
jmp 0x2932
leaq 0x69b8(%rip), %rdi      # 0x92b8
movq %rsp, %rsi
callq 0x44c6
movq (%rax), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
testq %rdi, %rdi
je 0x2923
callq 0x2260
leaq 0x698e(%rip), %rdi      # 0x92b8
movq %rsp, %rsi
callq 0x44c6
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x2951
addq $0x8, %rax
movq 0x8(%rsp), %rcx
movq %rcx, (%rsi)
addq $0x8, %rsi
movq %rsi, (%rax)
jmp 0x295e
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
callq 0x427e
movq 0x8(%rbx), %rdx
leaq 0x3706(%rip), %rcx      # 0x606f
movl $0x5, %r8d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2390
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x298a
jmp 0x298a
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x299a
callq 0x2260
movq %r14, %rdi
callq 0x23e0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
movq %rdi, %rbx
addsd 0x365a(%rip), %xmm0     # 0x6008
movsd 0x365a(%rip), %xmm2     # 0x6010
divsd %xmm2, %xmm0
addsd %xmm2, %xmm1
divsd 0x3652(%rip), %xmm1     # 0x6018
callq 0x2899
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
addsd 0x3234(%rip), %xmm0     # 0x6008
movq %rdi, %rbx
movsd 0x3231(%rip), %xmm3     # 0x6010
divsd %xmm3, %xmm0
addsd %xmm3, %xmm1
divsd 0x3229(%rip), %xmm1     # 0x6018
divsd 0x3231(%rip), %xmm2     # 0x6028
callq 0x29d0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
movq %rdi, %rbx
movsd 0x2dea(%rip), %xmm4     # 0x6008
addsd %xmm4, %xmm0
movsd 0x2de6(%rip), %xmm5     # 0x6010
divsd %xmm5, %xmm0
addsd %xmm5, %xmm1
movsd 0x2dde(%rip), %xmm6     # 0x6018
divsd %xmm6, %xmm1
addsd %xmm4, %xmm2
divsd %xmm5, %xmm2
addsd %xmm5, %xmm3
divsd %xmm6, %xmm3
callq 0x2e01
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
leaq 0x6045(%rip), %rdi      # 0x92b8
movq %rax, %rsi
callq 0x4222
testq %rax, %rax
je 0x32b3
movq %rax, %r14
movq %rax, %rsi
addq $0x8, %rsi
leaq 0x5ff7(%rip), %r15      # 0x9288
movq %r15, %rdi
callq 0x4846
movq %r15, %rdi
movq %rax, %rsi
callq 0x48c8
leaq 0x600d(%rip), %rdi      # 0x92b8
movq %r14, %rsi
callq 0x4968
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2dae(%rip), %rsi      # 0x606f
leaq 0x2dac(%rip), %rdx      # 0x6074
movq %rbx, %rdi
callq 0x47b0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mgronhol[P]Ullur/libhash.cpp
// Function: compute_hash(double, double)
uint64_t compute_hash( double x, double y ){
	uint64_t out = 0;
	double cx, cy, d;
	cx = cy = 0.5;
	d = 0.25;
	
	x = x - floor( x );
	y = y - floor( y );
	
	for( size_t i = 0 ; i < 32 ; ++i ){
		uint64_t p = 0;
		
		if( x >= cx ){
			p |= 1;
			cx += d;
			}
		else {
			cx -= d;
			}
		
		if( y <= cy ){
			p |= 2;
			cy -= d;
			}
		else{
			cy += d;
			}
		
		//std::cout << p << " ";
		
		d /= 2.0;
		out |= p;
		if( i < 32 - 1 ){
			out <<= 2;
			}
		}
	//std::cout << std::endl;
	return out;
	}

// Assembly:
subq $0x18, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
callq 0x23c0
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x23c0
movsd 0x8(%rsp), %xmm9
movsd 0x10(%rsp), %xmm8
subsd %xmm0, %xmm8
movsd 0x1251(%rip), %xmm0     # 0x6030
movsd 0x13b1(%rip), %xmm1     # 0x6198
movl $0x20, %ecx
xorl %edx, %edx
movapd 0x124a(%rip), %xmm2     # 0x6040
movapd %xmm0, %xmm3
movapd %xmm0, %xmm4
xorl %esi, %esi
ucomisd %xmm4, %xmm9
setae %al
movapd %xmm1, %xmm5
xorpd %xmm2, %xmm5
movapd %xmm1, %xmm6
jae 0x4e1a
movapd %xmm5, %xmm6
addsd %xmm6, %xmm4
movb %al, %sil
leaq 0x2(%rsi), %rax
ucomisd %xmm8, %xmm3
movapd %xmm8, %xmm6
cmpnlesd %xmm3, %xmm6
movapd %xmm6, %xmm7
andpd %xmm1, %xmm7
andnpd %xmm5, %xmm6
orpd %xmm7, %xmm6
cmovbq %rsi, %rax
addsd %xmm6, %xmm3
mulsd %xmm0, %xmm1
orq %rdx, %rax
leaq (,%rax,4), %rdx
cmpq $0x1, %rcx
cmoveq %rax, %rdx
decq %rcx
jne 0x4dfe
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mgronhol[P]Ullur/libhash.cpp
// Function: mask_hash(unsigned long, unsigned long)
std::pair<uint64_t,uint64_t> mask_hash( uint64_t H, size_t N ){
	uint64_t  mask = 0;
	for( size_t i = 0 ; i < 32  ; ++i ){
		if( i < N ){
			mask |= 0x03;
			}
		if( i < 31 ){
			mask  <<= 0x02;
			}
		}
	
	return std::make_pair( H & mask, (H & mask) | (~mask) );
	
	}

// Assembly:
xorl %eax, %eax
xorl %ecx, %ecx
movq %rcx, %rdx
orq $0x3, %rdx
cmpq %rsi, %rax
cmovaeq %rcx, %rdx
leaq (,%rdx,4), %rcx
cmpq $0x1f, %rax
cmoveq %rdx, %rcx
incq %rax
cmpq $0x20, %rax
jne 0x4e71
movq %rdx, %rax
andq %rdi, %rax
notq %rdx
orq %rdi, %rdx
retq
// File: /workspace/github_cpp_makefile_star2_O3/mgronhol[P]Ullur/libhash.cpp
// Function: compute_position(unsigned long)
std::pair<double, double> compute_position( uint64_t H ){
	double cx, cy, d;

	cx = 0.5;
	cy = 0.5;
	d = 0.25;
	
	for( uint64_t i = 0 ; i < 32 ; ++i ){
		uint64_t p = 2*(31 - i);
		uint64_t value = (H >> p) & 0x3;
		int x,y;
		x = value & 1;
		y = (value & 2) >> 1;
		
		cx += (2*x-1)*d;
		cy -= (2*y-1)*d;
		
		
		
		d *= 0.5;
		}
	//std::cout << std::endl;
	return std::make_pair( cx, cy );
	}

// Assembly:
movapd 0x1303(%rip), %xmm0     # 0x61b0
movsd 0x12e3(%rip), %xmm1     # 0x6198
movl $0x3e, %ecx
movapd 0x117e(%rip), %xmm2     # 0x6040
movsd 0x1166(%rip), %xmm3     # 0x6030
movq %rdi, %rax
shrq %cl, %rax
movl %eax, %edx
andl $0x2, %edx
andl $0x1, %eax
leal -0x1(,%rax,2), %eax
xorps %xmm4, %xmm4
cvtsi2sd %eax, %xmm4
decl %edx
xorps %xmm5, %xmm5
cvtsi2sd %edx, %xmm5
xorpd %xmm2, %xmm5
unpcklpd %xmm5, %xmm4            # xmm4 = xmm4[0],xmm5[0]
movapd %xmm1, %xmm5
unpcklpd %xmm1, %xmm5            # xmm5 = xmm5[0],xmm1[0]
mulpd %xmm4, %xmm5
addpd %xmm5, %xmm0
mulsd %xmm3, %xmm1
addq $-0x2, %rcx
cmpq $-0x2, %rcx
jne 0x4eca
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
retq
// File: /workspace/github_cpp_makefile_star2_O3/mgronhol[P]Ullur/libhash.cpp
// Function: get_near_indices(unsigned long, unsigned long)
std::vector< std::pair<uint64_t, uint64_t> > get_near_indices( uint64_t level, uint64_t H ){
	std::vector< std::pair<uint64_t, uint64_t> > out;
	
	double dz = 1.0/( 1 << level );
	
	std::pair<double, double> pos = compute_position( H );
	
	uint64_t h;
	
	for( int p = -1 ; p < 2 ; ++p ){
		for( int q = -1 ; q < 2 ; ++q ){
			double x, y;
			x = pos.first + dz * p;
			y = pos.second + dz * q;
			
			h = compute_hash( x, y );
			
			out.push_back( mask_hash( h, level ) );
			
			
			}
		}
	
	
	return out;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x1, %eax
movl %r14d, %ecx
shll %cl, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd 0x1247(%rip), %xmm1     # 0x61a0
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq %rdx, %rdi
callq 0x4ea5
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x18(%rsp)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x28(%rsp), %r15
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
mulsd 0x8(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
xorps %xmm1, %xmm1
cvtsi2sd %r12d, %xmm1
mulsd 0x8(%rsp), %xmm1
addsd 0x18(%rsp), %xmm1
xorl %eax, %eax
xorl %ecx, %ecx
movq %rcx, %r13
orq $0x3, %r13
cmpq %r14, %rax
cmovaeq %rcx, %r13
leaq (,%r13,4), %rcx
cmpq $0x1f, %rax
cmoveq %r13, %rcx
incq %rax
cmpq $0x20, %rax
jne 0x4fb8
movsd 0x20(%rsp), %xmm0
callq 0x4d94
movq %r13, %rcx
andq %rax, %rcx
notq %r13
orq %rax, %r13
movq %rcx, 0x28(%rsp)
movq %r13, 0x30(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x501b
movupd 0x28(%rsp), %xmm0
movupd %xmm0, (%rsi)
addq $0x10, 0x8(%rbx)
jmp 0x5026
movq %rbx, %rdi
movq %r15, %rdx
callq 0x529a
incl %r12d
cmpl $0x2, %r12d
jne 0x4fa0
incl %ebp
cmpl $0x2, %ebp
jne 0x4f81
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5060
callq 0x2260
movq %r14, %rdi
callq 0x23e0
// File: /workspace/github_cpp_makefile_star2_O3/mgronhol[P]Ullur/libhash.cpp
// Function: extract_points(std::set<unsigned long, std::less<unsigned long>, std::allocator<unsigned long>>&, std::vector<std::pair<unsigned long, unsigned long>, std::allocator<std::pair<unsigned long, unsigned long>>>&)
std::vector< uint64_t > extract_points( std::set<uint64_t> & points, std::vector< std::pair<uint64_t, uint64_t> > &areas ){
	std::vector<uint64_t> out;
	
	for( size_t i = 0 ; i < areas.size() ; ++i ){
		std::set<uint64_t>::iterator start, stop, it;
			start = points.lower_bound( areas[i].first );
			stop = points.upper_bound( areas[i].second );
		
			for( it = start ; it != stop ; it++ ){
				out.push_back( *it );
				}
				}
	
	return out;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rax
movq %rdx, (%rsp)
movq 0x8(%rdx), %rcx
cmpq %rax, %rcx
je 0x5175
movq %rsi, %r15
leaq 0x8(%rsi), %r14
xorl %ebp, %ebp
movq 0x10(%r15), %rdx
testq %rdx, %rdx
je 0x515f
movq %rbp, %rsi
shlq $0x4, %rsi
addq %rax, %rsi
movq (%rsi), %rdi
movq %rdx, %r8
movq %r14, %r12
xorl %r9d, %r9d
cmpq %rdi, 0x20(%r8)
setb %r9b
cmovaeq %r8, %r12
movq 0x10(%r8,%r9,8), %r8
testq %r8, %r8
jne 0x50e0
movq 0x8(%rsi), %rsi
movq %r14, %r13
xorl %edi, %edi
cmpq 0x20(%rdx), %rsi
setae %dil
cmovbq %rdx, %r13
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x5100
cmpq %r13, %r12
je 0x515f
leaq 0x20(%r12), %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x513c
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x5144
movq %rbx, %rdi
callq 0x427e
movq %r12, %rdi
callq 0x22f0
movq %rax, %r12
cmpq %r13, %rax
jne 0x511d
movq (%rsp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
incq %rbp
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x4, %rdx
cmpq %rdx, %rbp
jb 0x50c0
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
testq %rdi, %rdi
je 0x5197
callq 0x2260
movq %r14, %rdi
callq 0x23e0
// File: /workspace/github_cpp_makefile_star2_O3/mgronhol[P]Ullur/libhash.cpp
// Function: filter_points(std::vector<unsigned long, std::allocator<unsigned long>>&, std::unordered_map<unsigned long, unsigned long, std::hash<unsigned long>, std::equal_to<unsigned long>, std::allocator<std::pair<unsigned long const, unsigned long>>>&, std::pair<double, double>, double)
std::vector<uint64_t> filter_points( std::vector< uint64_t > &keys, std::unordered_map<uint64_t, uint64_t> &values, std::pair<double, double> point, double radius ){
	std::vector<uint64_t> out;
	std::pair<double, double> pos;
	
	radius = radius*radius;
	for( size_t i = 0 ; i < keys.size() ; ++i ){
		pos = compute_position( keys[i] );
		if( get_squared_distance( pos, point ) <= radius ){
			out.push_back( values[ keys[i] ] );
			}
		}
	
	
	return out;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm2, (%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r12
cmpq %r12, 0x8(%rsi)
je 0x5270
movq %rdx, %r14
movq %rsi, %r15
movsd (%rsp), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, (%rsp)
xorl %r13d, %r13d
xorl %ebp, %ebp
movq (%r12,%r13), %rdi
callq 0x4ea5
subsd 0x8(%rsp), %xmm0
subsd 0x10(%rsp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jb 0x5256
addq %r13, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x53d2
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x524b
movq (%rax), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x5256
movq %rbx, %rdi
movq %rax, %rdx
callq 0x427e
incq %rbp
movq (%r15), %r12
movq 0x8(%r15), %rax
subq %r12, %rax
sarq $0x3, %rax
addq $0x8, %r13
cmpq %rax, %rbp
jb 0x51f7
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5292
callq 0x2260
movq %r14, %rdi
callq 0x23e0
// File: /workspace/github_cpp_makefile_star2_O3/cooljacket[P]Dormitory-distribution/utils.cpp
// Function: str2int(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int str2int(const string& str) {
	stringstream ss(str);
	int num;
	ss >> num;
	return num;
}

// Assembly:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x18, %edx
callq 0x2300
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x2150
movl 0x4(%rsp), %ebx
movq 0xbd9f(%rip), %rsi      # 0xefb0
leaq 0x8(%rsp), %rdi
callq 0x21a0
leaq 0x88(%rsp), %rdi
callq 0x20c0
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq %rax, %rbx
movq 0xbd73(%rip), %rsi      # 0xefb0
leaq 0x8(%rsp), %rdi
callq 0x21a0
leaq 0x88(%rsp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O3/cooljacket[P]Dormitory-distribution/main.cpp
// Function: findNearestExclude(Student const&, std::vector<Student, std::allocator<Student>> const&, unsigned long)
size_t findNearestExclude(const Student& key, const vector<Student>& group, size_t exclude) {
	double d = 1e10;
	size_t ans = exclude;

	for (size_t i = 0; i < group.size(); ++i) {
		if (i != exclude && key.dist(group[i]) < d) {
			d = key.dist(group[i]);
			ans = i;
		}
	}

	return ans;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq (%rsi), %rsi
cmpq %rsi, 0x8(%r14)
je 0x3d89
movq %rdi, %r15
movsd 0x635a(%rip), %xmm0     # 0xa070
movsd %xmm0, 0x10(%rsp)
xorl %r13d, %r13d
movabsq $-0xf0f0f0f0f0f0f0f, %rbp # imm = 0xF0F0F0F0F0F0F0F1
xorl %r12d, %r12d
movq %rbx, 0x8(%rsp)
cmpq %r12, %rbx
je 0x3d69
addq %r13, %rsi
movq %r15, %rdi
callq 0x747c
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
movq (%r14), %rsi
jbe 0x3d69
addq %r13, %rsi
movq %r15, %rdi
callq 0x747c
movsd %xmm0, 0x10(%rsp)
movq (%r14), %rsi
movq %r12, 0x8(%rsp)
incq %r12
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
imulq %rbp, %rax
addq $0x88, %r13
cmpq %rax, %r12
jb 0x3d31
jmp 0x3d8e
movq %rbx, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/cooljacket[P]Dormitory-distribution/./KMeans.h
// Function: KMeans<Student>::train_inc()
void train_inc() {
		for (size_t iter = 0; iter < MaxIters; ++iter) {
			for (size_t e = 0; e < size; ++e) {
				for (size_t c = 0; c < K; ++c) {
					double distance = elements[e].dist(centroids[c]);
					if (distance < dist[e]) {
						dist[e] = distance;
						my_centroids[e] = c;
					}
				}
				if (my_centroids[e] != my_centroids_map[e]) {
					size_t oldC = my_centroids_map[e], newC = my_centroids[e];
					// printf("hehe, change c=%d, for e=%d, oldC=%d\n", int(newC), int(e), int(oldC));

					my_centroids_map[e] = newC;
					my_points_map[oldC].erase(e);
					my_points_map[newC].insert(e);
					update_centroid(oldC);
					update_centroid(newC);
				}
			}

			printf("Iteration [%d], SSE=%lf\n", int(iter), SSE());
		}
	}

// Assembly:
cmpq $0x0, 0x10(%rdi)
je 0x48ca
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x78(%rdi), %r14
leaq 0xa8(%rdi), %r15
xorl %r12d, %r12d
leaq 0x8(%rsp), %rbp
movq %r12, 0x20(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x8(%rbx)
je 0x4891
xorl %eax, %eax
cmpq $0x0, (%rbx)
je 0x47d3
xorl %r13d, %r13d
xorl %r12d, %r12d
movq 0x8(%rsp), %rax
movq %rax, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rax,8), %rdi
addq 0x18(%rbx), %rdi
movq 0x30(%rbx), %rsi
addq %r13, %rsi
callq 0x747c
movq 0x8(%rsp), %rax
movq 0x48(%rbx), %rcx
movsd (%rcx,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x47bf
movsd %xmm0, (%rcx,%rax,8)
movq 0x60(%rbx), %rcx
movq %r12, (%rcx,%rax,8)
incq %r12
addq $0x88, %r13
cmpq (%rbx), %r12
jb 0x477e
movq 0x8(%rsp), %rax
movq 0x60(%rbx), %rcx
movq (%rcx,%rax,8), %r12
movq %r14, %rdi
movq %rbp, %rsi
callq 0x5cd4
cmpq (%rax), %r12
je 0x487a
movq %r14, %rdi
movq %rbp, %rsi
callq 0x5cd4
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rax
movq 0x60(%rbx), %rcx
movq (%rcx,%rax,8), %r12
movq %r12, 0x10(%rsp)
movq %r14, %rdi
movq %rbp, %rsi
callq 0x5cd4
movq %r12, (%rax)
movq %r15, %rdi
leaq 0x18(%rsp), %rsi
callq 0x63fc
movq %rax, %r13
movq %rax, %rdi
movq %rbp, %rsi
callq 0x660a
movq %r13, %rdi
movq %rax, %rsi
callq 0x668c
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
callq 0x63fc
movq %rax, %rdi
movq %rbp, %rsi
callq 0x60d6
movq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x6462
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x6462
movq 0x8(%rsp), %rax
incq %rax
movq %rax, 0x8(%rsp)
cmpq 0x8(%rbx), %rax
jb 0x4772
movq %rbx, %rdi
callq 0x5d3a
leaq 0x5978(%rip), %rdi      # 0xa218
movq 0x20(%rsp), %r12
movl %r12d, %esi
movb $0x1, %al
callq 0x2050
incq %r12
cmpq 0x10(%rbx), %r12
jb 0x4757
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/cooljacket[P]Dormitory-distribution/./KMeans.h
// Function: KMeans<Student>::explain() const
void explain() const {
		for (size_t c = 0; c < K; ++c) {
			printf("In centroids [%d], there have:\n", int(c));
			for (size_t e = 0; e < size; ++e) {
				if (my_centroids[e] == c)
					elements[e].output(cout);
			}

			printf("-----------\n\n\n");
		}
	}

// Assembly:
cmpq $0x0, (%rdi)
je 0x495e
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5966(%rip), %r15      # 0xa251
movq 0xa6de(%rip), %r12      # 0xefd0
xorl %r13d, %r13d
leaq 0x5935(%rip), %rdi      # 0xa231
movl %r13d, %esi
xorl %eax, %eax
callq 0x2050
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x4940
xorl %ebp, %ebp
xorl %r14d, %r14d
movq 0x60(%rbx), %rcx
cmpq %r13, (%rcx,%r14,8)
jne 0x4931
movq 0x18(%rbx), %rdi
addq %rbp, %rdi
movq %r12, %rsi
callq 0x7170
movq 0x8(%rbx), %rax
incq %r14
addq $0x88, %rbp
cmpq %rax, %r14
jb 0x4914
movq %r15, %rdi
callq 0x22e0
incq %r13
cmpq (%rbx), %r13
jb 0x48f5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/cooljacket[P]Dormitory-distribution/./KMeans.h
// Function: KMeans<Student>::getSortedRepresentative()
vector<size_t> getSortedRepresentative() {
		vector<size_t> rep(K);
		for (size_t i = 0; i < K; ++i) {
			rep[i] = getBestPointInCluster(i);
		}
		sort(rep.begin(), rep.end());
		return rep;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
leaq 0xf(%rsp), %rdx
callq 0x5854
cmpq $0x0, (%r14)
je 0x499f
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x6732
movq (%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
cmpq (%r14), %r15
jb 0x4985
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x49d8
movq %r15, %rax
subq %r14, %rax
sarq $0x3, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x67dc
movq %r14, %rdi
movq %r15, %rsi
callq 0x68c5
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x49e7
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x49fe
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2230
movq %r14, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O3/cooljacket[P]Dormitory-distribution/./KMeans.h
// Function: KMeans<Student>::SSE()
double SSE() {
		double error = 0.0;

		for (size_t e = 0; e < size; ++e) {
			// double tmp = centroids[my_centroids[e]].dist(elements[e]);
			// error += tmp * tmp;
			error += centroids[my_centroids[e]].dist(elements[e]);;
		}

		return error;
	}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x5db0
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
xorl %r14d, %r14d
xorl %r15d, %r15d
movsd %xmm0, 0x8(%rsp)
movq 0x60(%rbx), %rax
movq (%rax,%r15,8), %rax
movq %rax, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rax,8), %rdi
addq 0x30(%rbx), %rdi
movq 0x18(%rbx), %rsi
addq %r14, %rsi
callq 0x747c
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
incq %r15
addq $0x88, %r14
cmpq 0x8(%rbx), %r15
jb 0x5d57
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/cooljacket[P]Dormitory-distribution/./KMeans.h
// Function: KMeans<Student>::update_centroid(unsigned long)
void update_centroid(size_t c) {
		set<size_t>& points = my_points_map[c];
		set<size_t>::iterator it = points.begin();
		centroids[c].clear();
		while (it != points.end()) {
			centroids[c] += elements[*it];
			++it;
		}
		if (points.size() > 1)
			centroids[c] /= points.size();
		// printf("heheheh size=%d, c=%d\n", int(points.size()), int(c));
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r12
movq %rsi, (%r12)
addq $0xa8, %rdi
movq %r12, %rsi
callq 0x63fc
movq %rax, %r14
movq 0x18(%rax), %r15
movq (%r12), %rax
movq %rax, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rax,8), %rdi
addq 0x30(%rbx), %rdi
callq 0x74c6
movq %r14, %r12
addq $0x8, %r12
cmpq %r12, %r15
je 0x64e9
movq 0x20(%r15), %rax
movq %rax, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rax,8), %rsi
addq 0x18(%rbx), %rsi
movq (%rsp), %rax
movq %rax, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rax,8), %rdi
addq 0x30(%rbx), %rdi
callq 0x74ee
movq %r15, %rdi
callq 0x2260
movq %rax, %r15
cmpq %r12, %rax
jne 0x64ae
movq 0x28(%r14), %rax
cmpq $0x2, %rax
jb 0x652c
movq %rax, %xmm1
punpckldq 0x3b50(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x3b58(%rip), %xmm1     # 0xa060
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq (%rsp), %rax
movq %rax, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rax,8), %rdi
addq 0x30(%rbx), %rdi
callq 0x7526
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/cooljacket[P]Dormitory-distribution/./KMeans.h
// Function: KMeans<Student>::getBestPointInCluster(unsigned long)
size_t getBestPointInCluster(size_t c) {
		set<size_t>& points = my_points_map[c];
		set<size_t>::iterator it = points.begin();

		double d = 1e10, tmpD;
		size_t ans = size;
		while (it != points.end()) {
			if ((tmpD = centroids[c].dist(elements[*it])) < d) {
				d = tmpD;
				ans = *it;
			}
			++it;
		}

		return ans;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rsi, (%rax)
addq $0xa8, %rdi
movq %rax, %rsi
callq 0x63fc
movq %rax, %r15
movq 0x18(%rax), %r12
movq 0x8(%rbx), %r14
addq $0x8, %r15
cmpq %r15, %r12
je 0x67cd
movsd 0x38fd(%rip), %xmm0     # 0xa070
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rax,8), %rdi
addq 0x30(%rbx), %rdi
movq 0x20(%r12), %rax
movq %rax, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rax,8), %rsi
addq 0x18(%rbx), %rsi
callq 0x747c
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x67bd
movq 0x20(%r12), %r14
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
callq 0x2260
movq %rax, %r12
cmpq %r15, %rax
jne 0x6779
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq