LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/RipcordSoftware[P]lazyflatset/test/lazyflatset/./../../lazyflatset.hpp
// Function: rs::LazyFlatSet<unsigned int, std::less<unsigned int>, std::equal_to<unsigned int>, rs::LazyFlatSetQuickSort<unsigned int, std::less<unsigned int>>, std::allocator<unsigned int>, false>::insert(unsigned int const&, rs::LazyFlatSet<unsigned int, std::less<unsigned int>, std::equal_to<unsigned int>, rs::LazyFlatSetQuickSort<unsigned int, std::less<unsigned int>>, std::allocator<unsigned int>, false>::insert_hint)
void insert(const value_type& k, insert_hint hint = insert_hint::no_hint) {
        if (hint == insert_hint::no_hint) {
            auto iter = lower_bound_equals(coll_, k);
            if (iter != coll_.end()) {
                *iter = k;
            } else {
                iter = lower_bound_equals(nursery_, k);
                if (iter != nursery_.end()) {
                    *iter = k;
                } else {
                    iter = search_unsorted(unsorted_, k);
                    if (iter != unsorted_.end()) {
                        *iter = k;
                    } else {
                        if (unsorted_.size() == maxUnsortedEntries_) {
                            flushUnsorted();
                        }

                        unsorted_.push_back(k);
                    }
                }
            }
        } else {
            if (unsorted_.size() == maxUnsortedEntries_) {
                flushUnsorted();
            }

            unsorted_.push_back(k);
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
je 0x406b
movq 0x48(%r14), %rax
subq 0x40(%r14), %rax
sarq $0x2, %rax
movl 0x8(%r14), %ecx
cmpq %rcx, %rax
jne 0x4053
movq %r14, %rdi
callq 0x4aec
movq 0x48(%r14), %rsi
cmpq 0x50(%r14), %rsi
je 0x40ba
movl (%rbx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x48(%r14)
jmp 0x40b2
leaq 0x10(%r14), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4a9a
cmpq 0x18(%r14), %rax
jne 0x40ae
leaq 0x28(%r14), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4a9a
cmpq 0x30(%r14), %rax
jne 0x40ae
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rsi
movq %rbx, %rdx
callq 0x4b65
movq 0x48(%r14), %rcx
cmpq %rcx, %rax
je 0x40d0
movl (%rbx), %ecx
movl %ecx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x40, %r14
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x441e
subq 0x40(%r14), %rcx
sarq $0x2, %rcx
movl 0x8(%r14), %eax
cmpq %rax, %rcx
je 0x404b
jmp 0x4053
// File: /workspace/github_cpp_makefile_star2_O1/RipcordSoftware[P]lazyflatset/test/lazyflatset/./../../lazyflatset.hpp
// Function: rs::LazyFlatSet<unsigned int, std::less<unsigned int>, std::equal_to<unsigned int>, rs::LazyFlatSetQuickSort<unsigned int, std::less<unsigned int>>, std::allocator<unsigned int>, false>::merge(std::vector<unsigned int, std::allocator<unsigned int>>&, std::vector<unsigned int, std::allocator<unsigned int>>&) const
void merge(base_collection& source, base_collection& target) const {
        if (source.size() > 0) {
            Less less;
            if (target.size() == 0 || less(target.back(), source.front())) {
                target.insert(target.end(), source.cbegin(), source.cend());
            } else if (less(source.back(), target.front())) {
                target.insert(target.begin(), source.cbegin(), source.cend());
            } else {
                target.insert(target.end(), source.cbegin(), source.cend());
                std::inplace_merge(target.begin(), target.end() - source.size(), target.end(), less);
            }
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq (%rsi), %rdx
movq 0x8(%rsi), %rcx
cmpq %rdx, %rcx
je 0x4c68
movq %rsi, %r14
movq (%rbx), %rsi
movq 0x8(%rbx), %rdi
movq %rdi, %rax
subq %rsi, %rax
je 0x4c56
movl -0x4(%rdi), %edi
cmpl (%rdx), %edi
jae 0x4c70
addq %rax, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5038
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl -0x4(%rcx), %edi
cmpl (%rsi), %edi
jb 0x4c59
addq %rax, %rsi
movq %rbx, %rdi
callq 0x5038
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
movq (%r14), %rsi
subq 0x8(%r14), %rsi
addq %rdx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5224
nop
// File: /workspace/github_cpp_makefile_star2_O1/HQarroum[P]thread-pool/examples/bulk_insertion/main.cpp
// Function: main
int main() {
 thread::pool::pool_t pool(std::thread::hardware_concurrency() + 1);
 
 // Filling our array with `iterations` amount of functions,
 // bound to the number `42`.
 std::fill_n(callables, iterations, std::bind(static_void_function, 42));
 // Scheduling the execution in bulk.
 auto result = pool.schedule_bulk(callables, iterations);
 // Log whether the insertion was successful.
 std::cout << "The insertion has " << (result ? "succeeded" : "failed") << std::endl;
 assert(result == true);
 return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x2b0, %rsp            # imm = 0x2B0
callq 0x21d0
leal 0x1(%rax), %esi
leaq 0x18(%rsp), %rdi
callq 0x2592
leaq -0x68(%rip), %rax       # 0x241c
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movl $0x2a, 0x8(%rbx)
xorl %r14d, %r14d
leaq 0x6ce3(%rip), %r15      # 0x9180
leaq (%r15,%r14), %rdi
movq %rbx, %rsi
callq 0x38e2
addq $0x20, %r14
cmpq $0xc80, %r14            # imm = 0xC80
jne 0x249d
leaq 0x6cc3(%rip), %rsi      # 0x9180
leaq 0x18(%rsp), %rdi
movl $0x64, %edx
callq 0x265a
movl %eax, %ebx
movq 0x6afb(%rip), %rdi      # 0x8fd0
leaq 0x2b38(%rip), %rsi      # 0x5014
movl $0x12, %edx
callq 0x21a0
leaq 0x2b3a(%rip), %rax      # 0x5027
leaq 0x2b3d(%rip), %rsi      # 0x5031
testb %bl, %bl
cmovneq %rax, %rsi
movzbl %bl, %eax
leaq (%rax,%rax,2), %rdx
addq $0x6, %rdx
movq 0x6ac4(%rip), %r14      # 0x8fd0
movq %r14, %rdi
callq 0x21a0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq 0x6a9e(%rip), %rdi      # 0x8fd0
callq 0x2030
movq %rax, %rdi
callq 0x2110
testb %bl, %bl
je 0x255c
leaq 0x18(%rsp), %rdi
callq 0x26b6
xorl %eax, %eax
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2ad5(%rip), %rdi      # 0x5038
leaq 0x2add(%rip), %rsi      # 0x5047
leaq 0x2adf(%rip), %rcx      # 0x5050
movl $0x22, %edx
callq 0x2100
jmp 0x257d
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x26b6
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/FabienBounoir[P]JustePrix-CLI/justePrix.cpp
// Function: JustePrix::JustePrix()
JustePrix::JustePrix():prixMystere(0), prixMin(1), prixMax(100), nbCoups(0)
{
    joueur = new Joueur();
    historique = new Historique();
    meilleurScore = new MeilleurScore();
    srand(time(NULL));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movaps 0x3a15(%rip), %xmm0     # 0x6010
movups %xmm0, (%rdi)
movl $0x20, %edi
callq 0x21e0
movq %rax, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3cc3(%rip), %rdx      # 0x62de
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x2ec4
movq %rsp, %rsi
movq %r14, %rdi
callq 0x43a0
movq %r14, 0x18(%rbx)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x264b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
movl $0x30, %edi
callq 0x21e0
movq %rax, %r14
movq %rax, %rdi
callq 0x4490
movq %r14, 0x20(%rbx)
movl $0x38, %edi
callq 0x21e0
movq %rax, %r14
movq %rax, %rdi
callq 0x4bcc
movq %r14, 0x28(%rbx)
xorl %edi, %edi
callq 0x21b0
movl %eax, %edi
callq 0x21c0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x38, %esi
jmp 0x26cc
movq %rax, %rbx
movl $0x30, %esi
jmp 0x26cc
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x26c7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
jmp 0x26c7
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/FabienBounoir[P]JustePrix-CLI/justePrix.cpp
// Function: JustePrix::compterNbCoups(int)
void JustePrix::compterNbCoups(int prix)
{
    if(historique->enregistrerAncienCoups(prix))
    {
        if(prix > getPrixMax())
        {
            ihm->AfficherPrixSupBorne(prix, this->getPrixMax());
        }
        else if(prix < getPrixMin())
        {
            ihm->AfficherPrixInfBorne(prix, this->getPrixMin());
        }
        else
        {
            ++nbCoups;
        }       
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0x4546
testb %al, %al
je 0x27ca
movl 0x8(%r14), %edx
cmpl %ebx, %edx
jge 0x27ac
movq 0x10(%r14), %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3728
movl 0x4(%r14), %edx
cmpl %ebx, %edx
jle 0x27c6
movq 0x10(%r14), %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x37e0
incl 0xc(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/FabienBounoir[P]JustePrix-CLI/justePrix.cpp
// Function: JustePrix::verifierPrix(int, int)
bool JustePrix::verifierPrix(int prix, int prixMystere)
{
    #ifdef CHEAT
        cout << endl;
        cout << "\033[1;34mCHEAT [prix = " <<  getPrixMystere( ) << "]\033[0m" << endl;
    #endif
    
    this->compterNbCoups(prix);

    if(prix < prixMystere)
    {
        ihm->afficherPrixMystereSuperieur();
        return true;
    }
    else if(prix > prixMystere)
    {
        ihm->afficherPrixMystereInferieur();
        return true;
    }
    else
    {
        ihm->afficherVictoire(nbCoups, joueur->getNom());
        return false;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x277c
cmpl %ebx, %ebp
jge 0x27f5
movq 0x10(%r14), %rdi
callq 0x356e
jmp 0x2803
movq 0x10(%r14), %rbx
jle 0x2807
movq %rbx, %rdi
callq 0x352a
movb $0x1, %al
jmp 0x2844
movl 0xc(%r14), %ebp
movq 0x18(%r14), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x43d6
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x35b2
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2842
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x286b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/FabienBounoir[P]JustePrix-CLI/justePrix.cpp
// Function: JustePrix::ChoisirDifficulte()
void JustePrix::ChoisirDifficulte()
{
    char choix;
    do{
        choix = ihm->demanderDifficulte(joueur->getNom());
        if(choix == 'd' || choix == 'D')
        {
            this->setPrixMax(1000);
            meilleurScore->choisirFichierDifficulte(this->getPrixMax());
            this->creerPrixMystere();
        }
        else if(choix == 'm' || choix == 'M')
        {
            this->setPrixMax(500);
            meilleurScore->choisirFichierDifficulte(this->getPrixMax());
            this->creerPrixMystere();
        }
        else if(choix == 'f' || choix == 'F')
        {
            this->setPrixMax(100);
            meilleurScore->choisirFichierDifficulte(this->getPrixMax());
            this->creerPrixMystere();
        }
        else
        {
            cerr << "Désolé, cette difficulté n'existe pas" <<endl;
        }
    }
    while(choix != 'd' && choix != 'D' && choix != 'm' && choix != 'M' && choix != 'f' && choix != 'F');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
leaq 0x8(%rsp), %r14
movq 0x76ea(%rip), %r15      # 0x9ff0
movq 0x10(%rbx), %r13
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x43d6
movq %r13, %rdi
movq %r14, %rsi
callq 0x3898
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x293a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movl %ebp, %eax
andb $-0x21, %al
cmpb $0x4d, %al
je 0x2973
movzbl %al, %eax
cmpl $0x46, %eax
je 0x2961
cmpl $0x44, %eax
jne 0x2998
movl $0x3e8, 0x8(%rbx)       # imm = 0x3E8
movq 0x28(%rbx), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
jmp 0x2983
movl $0x64, 0x8(%rbx)
movq 0x28(%rbx), %rdi
movl $0x64, %esi
jmp 0x2983
movl $0x1f4, 0x8(%rbx)       # imm = 0x1F4
movq 0x28(%rbx), %rdi
movl $0x1f4, %esi            # imm = 0x1F4
callq 0x4c34
callq 0x2060
cltd
idivl 0x8(%rbx)
addl 0x4(%rbx), %edx
movl %edx, (%rbx)
jmp 0x29d3
movl $0x28, %edx
movq %r15, %rdi
leaq 0x3679(%rip), %rsi      # 0x6020
callq 0x2210
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movzbl %bpl, %eax
addl $-0x44, %eax
cmpl $0x29, %eax
ja 0x2906
movabsq $0x20500000205, %rcx    # imm = 0x20500000205
btq %rax, %rcx
jae 0x2906
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2a20
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/FabienBounoir[P]JustePrix-CLI/justePrix.cpp
// Function: JustePrix::jouerNouvellePartie()
void JustePrix::jouerNouvellePartie()
{
    this->setNbCoups(0);
    historique->initialiserAncienCoups();
    ihm->afficherIntroduction(this->getPrixMin());
    this->ChoisirDifficulte();
    ihm->afficherBornes(this->getPrixMin(), this->getPrixMax());
    meilleurScore->recupererScore();
    this->jouer(); 
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x0, 0xc(%rdi)
movq 0x20(%rdi), %rdi
callq 0x45ae
movq 0x10(%rbx), %rdi
movl 0x4(%rbx), %esi
callq 0x2f58
movq %rbx, %rdi
callq 0x28e4
movq 0x10(%rbx), %rdi
movl 0x4(%rbx), %esi
movl 0x8(%rbx), %edx
callq 0x3672
movq 0x28(%rbx), %rdi
callq 0x4e56
movq %rbx, %rdi
popq %rbx
jmp 0x2ce6
nop
// File: /workspace/github_cpp_makefile_star2_O1/FabienBounoir[P]JustePrix-CLI/justePrix.cpp
// Function: JustePrix::demarrer()
void JustePrix::demarrer()
{
    this->setNbCoups(0);
    ihm->afficherIntroduction(this->getPrixMin());
    this->recupererNom();
    this->ChoisirDifficulte();
    ihm->afficherBornes(this->getPrixMin(), this->getPrixMax());
    meilleurScore->recupererScore();
    this->jouer();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x0, 0xc(%rdi)
movq 0x10(%rdi), %rdi
movl 0x4(%rbx), %esi
callq 0x2f58
movq %rbx, %rdi
callq 0x2874
movq %rbx, %rdi
callq 0x28e4
movq 0x10(%rbx), %rdi
movl 0x4(%rbx), %esi
movl 0x8(%rbx), %edx
callq 0x3672
movq 0x28(%rbx), %rdi
callq 0x4e56
movq %rbx, %rdi
popq %rbx
jmp 0x2ce6
// File: /workspace/github_cpp_makefile_star2_O1/FabienBounoir[P]JustePrix-CLI/justePrix.cpp
// Function: JustePrix::jouer()
void JustePrix::jouer()
{
    int prix = 0;
    time_t debutChrono = time(NULL);
    do
    {
        prix = ihm->demanderPrix(joueur->getNom());
    }
    while(this->verifierPrix(prix, prixMystere));
    int chronometre = (int)time(NULL) - debutChrono;
    this->calculerTemps(chronometre);
    historique->ajouter(this->getNbCoups(), joueur->getNom());
    meilleurScore->sauvegarderScore(this->getNbCoups(), joueur->getNom());
    this->ChoisirMenu();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x21b0
movq %rax, %r14
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r15
movq 0x10(%rbx), %r12
movq 0x18(%rbx), %rsi
movq %r15, %rdi
callq 0x43d6
movq %r12, %rdi
movq %r15, %rsi
callq 0x33e2
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2d3f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movl (%rbx), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x27d2
testb %al, %al
jne 0x2d0b
xorl %edi, %edi
callq 0x21b0
subl %r14d, %eax
movslq %eax, %rcx
imulq $-0x6e5d4c3b, %rcx, %rsi # imm = 0x91A2B3C5
shrq $0x20, %rsi
addl %ecx, %esi
movl %esi, %eax
shrl $0x1f, %eax
sarl $0xb, %esi
addl %eax, %esi
imulq $-0x77777777, %rcx, %rdx # imm = 0x88888889
shrq $0x20, %rdx
addl %ecx, %edx
movl %edx, %eax
shrl $0x1f, %eax
sarl $0x5, %edx
addl %eax, %edx
imull $0x3c, %edx, %eax
subl %eax, %ecx
movq 0x10(%rbx), %rdi
callq 0x4290
movq 0x20(%rbx), %r14
movl 0xc(%rbx), %ebp
movq 0x18(%rbx), %rsi
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x43d6
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x44c2
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2dd8
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x21f0
movq 0x28(%rbx), %r14
movl 0xc(%rbx), %ebp
movq 0x18(%rbx), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x43d6
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x50e2
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e18
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2a28
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %r13
jmp 0x2e41
movq %rax, %rbx
leaq 0x58(%rsp), %r13
movq -0x10(%r13), %rdi
jmp 0x2e4f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2e60
movq (%r13), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/FabienBounoir[P]JustePrix-CLI/ihm.cpp
// Function: Ihm::demanderNom[abi:cxx11]()
string Ihm::demanderNom()
{
    string nom;
    cout << "Entrez votre nom : \033[1;31m"<< endl;
    cin >> nom;
    cout << "\033[0m";
    return nom;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x6c74(%rip), %r14      # 0x9fc8
leaq 0x312d(%rip), %rsi      # 0x6488
movl $0x1a, %edx
movq %r14, %rdi
callq 0x2210
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq 0x6c42(%rip), %rdi      # 0x9fc8
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x6c3e(%rip), %rdi      # 0x9fd8
movq %rbx, %rsi
callq 0x2230
movq 0x6c1f(%rip), %rdi      # 0x9fc8
leaq 0x33b0(%rip), %rsi      # 0x6760
movl $0x4, %edx
callq 0x2210
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x33d9
movq (%r15), %rsi
incq %rsi
callq 0x21f0
movq %r14, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/FabienBounoir[P]JustePrix-CLI/ihm.cpp
// Function: Ihm::demanderPrix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Ihm::demanderPrix(string nom)
{
    int prix = 0;
    cout <<endl;
    cout << nom << ", Entrez un prix : "<< endl;
    cin >> prix;
    while(cin.fail())
    {
        cout << "Entrez un prix : "<< endl;
        cin.clear();
        cin.ignore(256,'\n');
        cin >> prix;
    }
    return prix;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
leaq 0x4(%rsp), %r15
movl $0x0, (%r15)
movq 0x6bc8(%rip), %rbx      # 0x9fc8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x2210
movq %rax, %r14
leaq 0x3063(%rip), %rsi      # 0x64a3
movl $0x13, %edx
movq %rax, %rdi
callq 0x2210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x6b5d(%rip), %r14      # 0x9fd8
movq %r14, %rdi
movq %r15, %rsi
callq 0x20e0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
je 0x3519
leaq 0x3005(%rip), %r15      # 0x64a5
leaq 0x4(%rsp), %r12
movl $0x11, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2210
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
xorl %esi, %esi
callq 0x22d0
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
movl $0xa, %edx
callq 0x20f0
movq %r14, %rdi
movq %r12, %rsi
callq 0x20e0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
jne 0x34a5
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/FabienBounoir[P]JustePrix-CLI/ihm.cpp
// Function: Ihm::demanderDifficulte(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
char Ihm::demanderDifficulte(string nom)
{
    char Difficulte = ' ';
    cout << endl;
    cout << nom <<", Choisissez votre difficulté :"<< endl;
    cout << "\033[1;31m[F]\033[0macile (1 à 100)"<< endl;
    cout << "\033[1;31m[M]\033[0moyen (1 à 500)"<< endl;
    cout << "\033[1;31m[D]\033[0mifficile (1 à 1000)"<< endl;
    cout << endl;
    cout << "Entrez une difficulté : \033[1;31m";
    cin >> Difficulte;
    cout << "\033[0m";
    return Difficulte;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
leaq 0xf(%rsp), %rbx
movb $0x20, (%rbx)
movq 0x6715(%rip), %r14      # 0x9fc8
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x2210
movq %rax, %r15
leaq 0x2ce9(%rip), %rsi      # 0x65dc
movl $0x20, %edx
movq %rax, %rdi
callq 0x2210
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x2ccf(%rip), %rsi      # 0x65fd
movl $0x1e, %edx
movq %r14, %rdi
callq 0x2210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x2cb3(%rip), %rsi      # 0x661c
movl $0x1d, %edx
movq %r14, %rdi
callq 0x2210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x2c96(%rip), %rsi      # 0x663a
movl $0x22, %edx
movq %r14, %rdi
callq 0x2210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x2c57(%rip), %rsi      # 0x665d
movl $0x20, %edx
movq %r14, %rdi
callq 0x2210
movq 0x65be(%rip), %rdi      # 0x9fd8
movq %rbx, %rsi
callq 0x2240
leaq 0x2d37(%rip), %rsi      # 0x6760
movl $0x4, %edx
movq %r14, %rdi
callq 0x2210
movb (%rbx), %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/FabienBounoir[P]JustePrix-CLI/ihm.cpp
// Function: Ihm::afficherMenu()
char Ihm::afficherMenu()
{
    char ChoixMenu = ' ';
    sleep(1);
    cout << endl;
    cout << "\033[1;31m[R]\033[0mejouer"<< endl;
    cout << "\033[1;31m[M]\033[0meilleurs Scores"<< endl;
    cout << "\033[1;31m[H]\033[0mistorique Partie"<< endl;
    cout << "\033[1;31m[Q]\033[0muitter"<< endl;
    cout << "Entrer votre choix : \033[1;31m";
    cin >> ChoixMenu;
    cout << "\033[0m";
    return ChoixMenu;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x7(%rsp), %rbx
movb $0x20, (%rbx)
movl $0x1, %edi
callq 0x2150
movq 0x6569(%rip), %r14      # 0x9fc8
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x2bf1(%rip), %rsi      # 0x667e
movl $0x14, %edx
movq %r14, %rdi
callq 0x2210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x2bcb(%rip), %rsi      # 0x6693
movl $0x1d, %edx
movq %r14, %rdi
callq 0x2210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x2bae(%rip), %rsi      # 0x66b1
movl $0x1e, %edx
movq %r14, %rdi
callq 0x2210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x2b92(%rip), %rsi      # 0x66d0
movl $0x14, %edx
movq %r14, %rdi
callq 0x2210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x2b6c(%rip), %rsi      # 0x66e5
movl $0x1c, %edx
movq %r14, %rdi
callq 0x2210
movq 0x644b(%rip), %rdi      # 0x9fd8
movq %rbx, %rsi
callq 0x2240
leaq 0x2bc4(%rip), %rsi      # 0x6760
movl $0x4, %edx
movq %r14, %rdi
callq 0x2210
movb (%rbx), %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/FabienBounoir[P]JustePrix-CLI/ihm.cpp
// Function: Ihm::afficherHistorique(std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>)
void Ihm::afficherHistorique(vector<pair<int,string> > scoreHistorique)
{
    system("clear");
    cout << "Historique de vos partie :" << endl;
    cout << "\033[1;36mJoueur : \033[0m"<< scoreHistorique[0].second << endl;
    for(unsigned int i=0;i < scoreHistorique.size(); i++)
    {
        cout << "\033[1;36m   score : \033[0m"<<scoreHistorique[i].first << endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x242f(%rip), %rdi      # 0x6096
callq 0x2190
movq 0x6355(%rip), %r14      # 0x9fc8
leaq 0x2aa4(%rip), %rsi      # 0x671e
movl $0x1a, %edx
movq %r14, %rdi
callq 0x2210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x2a84(%rip), %rsi      # 0x6739
movl $0x14, %edx
movq %r14, %rdi
callq 0x2210
movq (%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x2210
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x8(%rbx), %rax
cmpq (%rbx), %rax
je 0x3d91
movl $0x1, %ebp
xorl %r12d, %r12d
movq 0x62ad(%rip), %r14      # 0x9fc8
leaq 0x2a2c(%rip), %r15      # 0x674e
movabsq $-0x3333333333333333, %r13 # imm = 0xCCCCCCCCCCCCCCCD
movl $0x16, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2210
movq (%rbx), %rax
leaq (%r12,%r12,4), %rcx
movl (%rax,%rcx,8), %esi
movq %r14, %rdi
callq 0x22e0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movl %ebp, %r12d
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
imulq %r13, %rax
incl %ebp
cmpq %r12, %rax
ja 0x3d2c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/FabienBounoir[P]JustePrix-CLI/ihm.cpp
// Function: Ihm::afficherPositionScore(int)
void Ihm::afficherPositionScore(int classement)
{
    cout << endl;

    if(classement <= 1)
    {
        cout << "Vous êtes classé \033[1;31m" << classement << "er\033[0m dans les meilleurs scores" << endl;   
    }
    else
    {
        cout << "Vous êtes classé \033[1;31m" << classement << "ème\033[0m dans les meilleurs scores" << endl;    
    }
    
    cout << endl;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq 0x5df9(%rip), %rbx      # 0x9fc8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x2592(%rip), %rsi      # 0x678f
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x2210
movq %rbx, %rdi
movl %ebp, %esi
callq 0x22e0
movq %rax, %r14
cmpl $0x1, %ebp
jg 0x422a
leaq 0x2587(%rip), %rsi      # 0x67aa
movl $0x20, %edx
jmp 0x4236
leaq 0x259a(%rip), %rsi      # 0x67cb
movl $0x22, %edx
movq %r14, %rdi
callq 0x2210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/FabienBounoir[P]JustePrix-CLI/historique.cpp
// Function: Historique::enregistrerAncienCoups(int)
bool Historique::enregistrerAncienCoups(int prix)
{
    if(find(this->ancienCoups.begin(), this->ancienCoups.end(), prix ) != this->ancienCoups.end())
    {
        return false;
    }
    else
    {
        this->ancienCoups.push_back(prix);
        return true;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rdx
movl %esi, (%rdx)
movq 0x18(%rdi), %rdi
movq 0x20(%rbx), %rsi
callq 0x49f7
movq %rax, %r14
movq 0x20(%rbx), %r15
cmpq %r15, %rax
jne 0x459d
cmpq 0x28(%rbx), %r15
je 0x4589
movl 0xc(%rsp), %eax
movl %eax, (%r15)
leaq 0x4(%r15), %rax
movq %rax, 0x20(%rbx)
jmp 0x459d
addq $0x18, %rbx
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4a90
cmpq %r15, %r14
sete %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/FabienBounoir[P]JustePrix-CLI/meilleurScore.cpp
// Function: MeilleurScore::choisirFichierDifficulte(int)
void MeilleurScore::choisirFichierDifficulte(int difficulte)
{
    switch(difficulte)
    {
        case 100:
            {
                this->nomFichier = "./scoreFacile.txt";
            }
            break;
         case 500:
            {
                this->nomFichier = "./scoreMoyen.txt";
            }
            break;
        case 1000:
            {
                this->nomFichier = "./scoreDifficile.txt";
            }
            break;

    }
}

// Assembly:
cmpl $0x3e8, %esi            # imm = 0x3E8
je 0x4c77
cmpl $0x1f4, %esi            # imm = 0x1F4
je 0x4c60
cmpl $0x64, %esi
jne 0x4c93
movq 0x20(%rdi), %rdx
addq $0x18, %rdi
leaq 0x1bf1(%rip), %rcx      # 0x6849
movl $0x11, %r8d
jmp 0x4c8c
movq 0x20(%rdi), %rdx
addq $0x18, %rdi
leaq 0x1bec(%rip), %rcx      # 0x685b
movl $0x10, %r8d
jmp 0x4c8c
movq 0x20(%rdi), %rdx
addq $0x18, %rdi
leaq 0x1be6(%rip), %rcx      # 0x686c
movl $0x14, %r8d
xorl %esi, %esi
jmp 0x2280
retq
// File: /workspace/github_cpp_makefile_star2_O1/FabienBounoir[P]JustePrix-CLI/meilleurScore.cpp
// Function: MeilleurScore::calculerPositionClassement(int)
int MeilleurScore::calculerPositionClassement(int score)
{
    string ligneFichierScore;
    ifstream fichierScore(this->getFichierDifficulte().c_str());
    int scoreFichier = 0;
    int classement = 0; 

    while(getline(fichierScore, ligneFichierScore)) 
    {
        stringstream convert(ligneFichierScore); 
        convert >> scoreFichier; 

        if(scoreFichier <= score)
        {
            ++classement;
        } 
    }
    return classement;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3b8, %rsp            # imm = 0x3B8
movl %esi, %ebx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x18(%rdi), %rsi
movq 0x20(%rdi), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x43fe
movq 0x28(%rsp), %rsi
leaq 0x1b0(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x2310
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x4d0a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x4(%rsp), %rax
movl $0x0, (%rax)
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
leaq 0x28(%rsp), %r12
movq 0x5280(%rip), %r15      # 0x9fa8
movq 0x1b0(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x2320
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x4d9f
movq %r12, %rdi
movq %r13, %rsi
movl $0x18, %edx
callq 0x22a0
movq %r12, %rdi
leaq 0x4(%rsp), %rsi
callq 0x20e0
xorl %eax, %eax
cmpl %ebx, 0x4(%rsp)
setle %al
addl %eax, %ebp
movq %r12, %rdi
movq %r15, %rsi
callq 0x2140
leaq 0xa8(%rsp), %rdi
callq 0x2090
jmp 0x4d28
leaq 0x1b0(%rsp), %rdi
callq 0x2050
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4dc8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movl %ebp, %eax
addq $0x3b8, %rsp            # imm = 0x3B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x4e32
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21f0
jmp 0x4e32
movq %rax, %rbx
jmp 0x4e32
movq %rax, %rbx
movq 0x51a1(%rip), %rsi      # 0x9fa8
leaq 0x28(%rsp), %rdi
callq 0x2140
leaq 0xa8(%rsp), %rdi
callq 0x2090
jmp 0x4e25
jmp 0x4e22
movq %rax, %rbx
leaq 0x1b0(%rsp), %rdi
callq 0x2050
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4e4e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/s-yata[P]louds-patricia/louds-patricia.cpp
// Function: louds::(anonymous namespace)::BitVector::add(unsigned long)
void add(uint64_t bit) {
    if (n_bits % 256 == 0) {
      words.resize((n_bits + 256) / 64);
    }
    set(n_bits, bit);
    ++n_bits;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rsi
testb %sil, %sil
jne 0x24b8
addq $0x100, %rsi            # imm = 0x100
shrq $0x6, %rsi
movq %rbx, %rdi
callq 0x3dac
movq 0x48(%rbx), %rax
movl $0x1, %ecx
shlxq %rax, %rcx, %rcx
testq %r14, %r14
je 0x24d8
shrq $0x6, %rax
movq (%rbx), %rdx
orq %rcx, (%rdx,%rax,8)
jmp 0x24e6
notq %rcx
shrq $0x6, %rax
movq (%rbx), %rdx
andq %rcx, (%rdx,%rax,8)
incq 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/s-yata[P]louds-patricia/louds-patricia.cpp
// Function: louds::(anonymous namespace)::BitVector::rank(unsigned long) const
uint64_t rank(uint64_t i) const {
    uint64_t word_id = i / 64;
    uint64_t bit_id = i % 64;
    uint64_t rank_id = word_id / 4;
    uint64_t rel_id = word_id % 4;
    uint64_t n = ranks[rank_id].abs();
    if (rel_id != 0) {
      n += ranks[rank_id].rels[rel_id - 1];
    }
    n += Popcnt(words[word_id] & ((1UL << bit_id) - 1));
    return n;
  }

// Assembly:
movq %rsi, %rax
shrq $0x6, %rax
movq %rsi, %rdx
shrq $0x8, %rdx
movq 0x18(%rdi), %r8
movl (%r8,%rdx,8), %r9d
shlq $0x8, %r9
movzbl 0x4(%r8,%rdx,8), %ecx
orq %r9, %rcx
movq %rax, %r9
andq $0x3, %r9
je 0x27f1
leaq (%r8,%rdx,8), %rdx
movzbl 0x4(%r9,%rdx), %edx
addq %rdx, %rcx
movq (%rdi), %rdx
andb $0x3f, %sil
bzhiq %rsi, (%rdx,%rax,8), %rax
popcntq %rax, %rax
addq %rcx, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/s-yata[P]louds-patricia/louds-patricia.cpp
// Function: louds::(anonymous namespace)::BitVector::select(unsigned long) const
uint64_t select(uint64_t i) const {
    const uint64_t block_id = i / 256;
    uint64_t begin = selects[block_id];
    uint64_t end = selects[block_id + 1] + 1UL;
    if (begin + 10 >= end) {
      while (i >= ranks[begin + 1].abs()) {
        ++begin;
      }
    } else {
      while (begin + 1 < end) {
        const uint64_t middle = (begin + end) / 2;
        if (i < ranks[middle].abs()) {
          end = middle;
        } else {
          begin = middle;
        }
      }
    }
    const uint64_t rank_id = begin;
    i -= ranks[rank_id].abs();

    uint64_t word_id = rank_id * 4;
    if (i < ranks[rank_id].rels[1]) {
      if (i >= ranks[rank_id].rels[0]) {
        word_id += 1;
        i -= ranks[rank_id].rels[0];
      }
    } else if (i < ranks[rank_id].rels[2]) {
      word_id += 2;
      i -= ranks[rank_id].rels[1];
    } else {
      word_id += 3;
      i -= ranks[rank_id].rels[2];
    }
    return (word_id * 64) + Ctz(_pdep_u64(1UL << i, words[word_id]));
  }

// Assembly:
movq %rsi, %rax
shrq $0x8, %rax
movq 0x30(%rdi), %rdx
movl (%rdx,%rax,4), %ecx
movl 0x4(%rdx,%rax,4), %edx
leaq 0xa(%rcx), %rax
cmpq %rdx, %rax
jbe 0x2848
movq 0x18(%rdi), %rdx
decq %rcx
movq %rcx, %rax
movl 0x10(%rdx,%rax,8), %ecx
shlq $0x8, %rcx
movzbl 0x14(%rdx,%rax,8), %r8d
orq %rcx, %r8
incq %rax
cmpq %rsi, %r8
jbe 0x282d
jmp 0x2889
cmpl %edx, %ecx
jae 0x2886
incq %rdx
movq 0x18(%rdi), %r8
leaq (%rcx,%rdx), %rax
shrq %rax
movl (%r8,%rax,8), %r9d
shlq $0x8, %r9
movzbl 0x4(%r8,%rax,8), %r10d
orq %r9, %r10
cmpq %rsi, %r10
ja 0x2875
movq %rax, %rcx
jmp 0x287b
movq %rax, %rdx
movq %rcx, %rax
leaq 0x1(%rax), %r9
cmpq %rdx, %r9
jb 0x2853
jmp 0x2889
movq %rcx, %rax
movq 0x18(%rdi), %r8
movl (%r8,%rax,8), %ecx
shlq $0x8, %rcx
movzbl 0x4(%r8,%rax,8), %edx
orq %rcx, %rdx
subq %rdx, %rsi
leaq (,%rax,4), %rcx
movzbl 0x6(%r8,%rax,8), %r9d
movq %rsi, %rdx
subq %r9, %rdx
jae 0x28cb
movzbl 0x5(%r8,%rax,8), %eax
movq %rsi, %rdx
subq %rax, %rdx
jb 0x28e0
orq $0x1, %rcx
jmp 0x28e3
movzbl 0x7(%r8,%rax,8), %eax
subq %rax, %rsi
jae 0x28dc
orq $0x2, %rcx
jmp 0x28e3
orq $0x3, %rcx
movq %rsi, %rdx
movl $0x1, %eax
shlxq %rdx, %rax, %rax
movq (%rdi), %rdx
pdepq (%rdx,%rcx,8), %rax, %rax
shlq $0x6, %rcx
tzcntq %rax, %rax
orq %rcx, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/smuething[P]dune-cxx11/15-allocate_shared.cc
// Function: main
int main()
{
  std::allocator<int> allocator;
  std::shared_ptr<int> p(std::allocate_shared<int>(allocator,4));
  assert(*p == 4);
  return 0;
}

// Assembly:
pushq %rax
movl $0x18, %edi
callq 0x1030
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x2b94(%rip), %rcx      # 0x3d20
movq %rcx, (%rax)
movl $0x4, 0x10(%rax)
movq %rax, %rdi
callq 0x11a2
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/Mengjintao[P]SWAPCounter/src/kmerGraph.cpp
// Function: kmerGraph::reverseComplement(unsigned long long, parameter*)
unsigned long long kmerGraph::reverseComplement(unsigned long long a, parameter *parameters)
{
        unsigned long long rev = 0;
        for(int i=0; i<parameters->hashLength; i++){
                rev <<= 2;
                rev |= (3-(a&3));
                a >>= 2;
        }
        return rev;
}

// Assembly:
movl 0xaf8(%rdx), %ecx
xorl %eax, %eax
testl %ecx, %ecx
jle 0x262d
movl %esi, %edx
andl $0x3, %edx
leaq (%rdx,%rax,4), %rax
xorq $0x3, %rax
shrq $0x2, %rsi
decl %ecx
jne 0x2618
retq
// File: /workspace/github_cpp_makefile_star2_O1/Mengjintao[P]SWAPCounter/src/kmerGraph.cpp
// Function: kmerGraph::stringToLongLong(char const*, int, int, parameter*)
unsigned long long kmerGraph::stringToLongLong(const char *buf, int start, int end, parameter *parameters)
{
        unsigned long long ret = 0;
        for(int i=start; i<end; i++){
                assert(buf[i]=='A'||buf[i]=='T'||buf[i]=='C'||buf[i]=='G');
		ret <<= 2;
                ret |= ((unsigned long long)parameters->nucleotideValue[(int)buf[i]]&3);
        }
        return ret;
}

// Assembly:
subl %esi, %edx
jle 0x2674
movslq %esi, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x80045, %r8d          # imm = 0x80045
xorl %eax, %eax
movzbl (%rdi,%rsi), %r9d
leal -0x41(%r9), %r10d
cmpl $0x13, %r10d
ja 0x2677
btl %r10d, %r8d
jae 0x2677
movsbq %r9b, %r9
movzbl 0xb38(%rcx,%r9), %r9d
andl $0x3, %r9d
leaq (%r9,%rax,4), %rax
incq %rsi
cmpl %esi, %edx
jne 0x2642
retq
xorl %eax, %eax
retq
pushq %rax
leaq 0x3991(%rip), %rdi      # 0x6010
leaq 0x39bd(%rip), %rsi      # 0x6043
leaq 0x39c8(%rip), %rcx      # 0x6055
movl $0x15, %edx
callq 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O1/Mengjintao[P]SWAPCounter/src/kmerGraph.cpp
// Function: kmerGraph::longLongToString[abi:cxx11](unsigned long long, parameter*)
string kmerGraph::longLongToString(unsigned long long a, parameter *parameters)
{
	string descriptor;
        descriptor.clear();
        for(int i=0;i<parameters->hashLength;i++)
        {
                descriptor += parameters->nucleotideArray[a%4];
                a = (a>>2);
        }
        reverse(descriptor.begin(), descriptor.end());
	return descriptor;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpl $0x0, 0xaf8(%rdx)
jle 0x26ed
movq %rdx, %r14
movq %rsi, %r15
xorl %ebp, %ebp
movl %r15d, %eax
andl $0x3, %eax
movsbl 0xbb8(%r14,%rax), %esi
movq %rbx, %rdi
callq 0x2200
shrq $0x2, %r15
incl %ebp
cmpl 0xaf8(%r14), %ebp
jl 0x26c7
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
setne %dl
addq %rax, %rcx
decq %rcx
cmpq %rax, %rcx
seta %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x272e
incq %rax
movb -0x1(%rax), %dl
movb (%rcx), %sil
movb %sil, -0x1(%rax)
movb %dl, (%rcx)
decq %rcx
leaq 0x1(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0x2713
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x274a
callq 0x2240
movq %r14, %rdi
callq 0x2460
// File: /workspace/github_cpp_makefile_star2_O1/Mengjintao[P]SWAPCounter/src/kmerGraph.cpp
// Function: kmerGraph::arcPos(unsigned long long&, unsigned long long&, char, char, int)
int kmerGraph::arcPos(unsigned long long &A, unsigned long long &B, char directA, char directB, int hashLength)
{
	int lastB;
	if(directB=='+')	lastB = B%4;
	else			lastB = 3-(B>>((hashLength-1)*2));
	
	if(directA=='-')	lastB += 4;
	assert(lastB>=0&&lastB<8);
	return lastB;
}

// Assembly:
movl %ecx, %esi
movq (%rdx), %rdx
cmpb $0x2b, %r8b
jne 0x2762
andl $0x3, %edx
jmp 0x2778
addl %r9d, %r9d
addb $-0x2, %r9b
movl %r9d, %ecx
shrq %cl, %rdx
movl $0x3, %eax
subl %edx, %eax
movl %eax, %edx
leal 0x4(%rdx), %eax
cmpb $0x2d, %sil
cmovnel %edx, %eax
cmpl $0x8, %eax
jae 0x2788
retq
pushq %rax
leaq 0x3920(%rip), %rdi      # 0x60b0
leaq 0x38ac(%rip), %rsi      # 0x6043
leaq 0x3924(%rip), %rcx      # 0x60c2
movl $0x30, %edx
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/Mengjintao[P]SWAPCounter/src/kmerGraph.cpp
// Function: kmerGraph::getProcsID(unsigned long long, int, MPIEnviroment*)
unsigned long long kmerGraph::getProcsID(unsigned long long kmerID, int hashLength, MPIEnviroment *MPIcontrol)
{
        unsigned long long revKmer = 0, tmpID = kmerID;
        for(int i=0;i<hashLength;i++)
        {
                revKmer = revKmer * 4;
                revKmer += ( 3 - tmpID%4 );
                tmpID = tmpID / 4;
        }

        if(revKmer>kmerID) revKmer = kmerID;

         unsigned int factor = 19;
         unsigned int numBytes = (hashLength + 3) / 4;

         unsigned long long sum = 0;
         for(unsigned i = 0; i < numBytes; i++){
                 sum = sum * factor + (revKmer & 0xFF);
                 revKmer >>= 8;
         }
         return sum % MPIcontrol->nprocs;
}

// Assembly:
xorl %eax, %eax
testl %edx, %edx
jle 0x27ca
movl %edx, %edi
movq %rsi, %r8
movl %r8d, %r9d
andl $0x3, %r9d
leaq (%r9,%rax,4), %rax
xorq $0x3, %rax
shrq $0x2, %r8
decl %edi
jne 0x27b3
leal 0x6(%rdx), %edi
cmpl $0x7, %edi
jae 0x27d6
xorl %eax, %eax
jmp 0x2805
addl $0x3, %edx
cmovsl %edi, %edx
sarl $0x2, %edx
cmpq %rsi, %rax
cmovbq %rax, %rsi
cmpl $0x1, %edx
adcl $0x0, %edx
xorl %eax, %eax
leaq (%rax,%rax,8), %rdi
leaq (%rax,%rdi,2), %rdi
movzbl %sil, %eax
addq %rdi, %rax
shrq $0x8, %rsi
decl %edx
jne 0x27ee
movslq 0x4(%rcx), %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/Mengjintao[P]SWAPCounter/src/kmerGraph.cpp
// Function: kmerGraph::printKmerCounting(parameter*, MPIEnviroment*)
void kmerGraph::printKmerCounting(parameter *parameters, MPIEnviroment *MPIcontrol)
{
        ofstream fs(parameters->kmerGraph);
        if(!fs.is_open())
        {
                cout<<"Error opening file"<<endl;
                exit(1);
        }

	int lineLen = parameters->hashLength+1+4*8+5;
	int totLen = kmolecules.size()*lineLen;
	
	char *buf = new char [totLen];
	int i=0;

	for(unordered_map<unsigned long long, unsigned long long>::iterator I=kmolecules.begin(); I!=kmolecules.end(); I++)
	{
		sprintf(buf+i*lineLen, "%s ", longLongToString(I->first, parameters).c_str());
		unsigned char *p = (unsigned char *) &I->second;
		int t=0;
		/*for(int j=0;j<8;j++)	
		{
			t += p[j];
			sprintf(buf+i*lineLen+parameters->hashLength+1+j*4, "%3d ", (int) p[j]);
		}*/
		sprintf(buf+i*lineLen+parameters->hashLength+1+4*8, "%4d\n", t);	
		i++;	
	}
	buf[totLen] = 0;
	MPIcontrol->File_write(parameters->kmerGraph, buf, totLen);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8f7(%rsi), %r12
leaq 0x48(%rsp), %rdi
movq %r12, %rsi
movl $0x10, %edx
callq 0x2290
leaq 0xb8(%rsp), %rdi
callq 0x2080
testb %al, %al
je 0x4005
movq %r12, 0x18(%rsp)
movq %r14, 0x20(%rsp)
movslq 0xaf8(%r15), %r12
addq $0x26, %r12
movl 0x18(%rbx), %eax
imull %r12d, %eax
cltq
testl %eax, %eax
movq $-0x1, %rdi
movq %rax, 0x10(%rsp)
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, 0x8(%rsp)
movq 0x10(%rbx), %rbp
testq %rbp, %rbp
je 0x3fa4
leaq 0x25f1(%rip), %rbx      # 0x652b
leaq 0x25ee(%rip), %r14      # 0x652f
movq 0x8(%rsp), %r13
movq 0x8(%rbp), %rsi
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq 0x2698
movq 0x28(%rsp), %rdx
movq %r13, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2070
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x3f7d
callq 0x2240
movslq 0xaf8(%r15), %rax
leaq (%rax,%r13), %rdi
addq $0x21, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2070
movq (%rbp), %rbp
addq %r12, %r13
testq %rbp, %rbp
jne 0x3f46
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdx
movb $0x0, (%rdx,%rcx)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x5928
movq 0x4fd8(%rip), %rax      # 0x8fa0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x50(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x48(%rsp,%rcx)
callq 0x21f0
leaq 0x140(%rsp), %rdi
callq 0x20a0
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x4fac(%rip), %rdi      # 0x8fb8
leaq 0x2505(%rip), %rsi      # 0x6518
movl $0x12, %edx
callq 0x22c0
movq 0x4f94(%rip), %rdi      # 0x8fb8
callq 0x2110
movl $0x1, %edi
callq 0x2300
jmp 0x4039
jmp 0x4039
jmp 0x4039
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x23e0
movq %rbx, %rdi
callq 0x2460
// File: /workspace/github_cpp_makefile_star2_O1/Mengjintao[P]SWAPCounter/src/bloomFilter.h
// Function: bloomFilter::bloomAdd(unsigned long long)
int bloomAdd(unsigned long long a)
	{
//		printf("bloomAdd: %llu\n", a);
//		fflush(stdout);	
		if(size==0)	return 0;
		unsigned long long minC = (1ull<<30);
		for(int i=0; i<funNum; i++)
		{
			unsigned long long pos = hashFun(a, i);		
			pos *= bits;
			unsigned long long sum=0;
			for(int j=0; j<bits; j++)
			{
				unsigned long long k = pos+j;
				sum = sum*2 + ((bitSet[k/64]>>(k%64))&1);
			}
			
			if(sum+1<(1ull<<bits))	sum++; 
			for(int j=0;j<bits;j++)
			{
				unsigned long long k = pos+j;
				bitSet[k/64] &= ~((unsigned long long) 1 << (k%64)); 
				bitSet[k/64] |= ( ((sum>>(bits-1-j))&1) << (k%64));
			}
			minC = min(minC, sum);
		}
		return (int) minC;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, -0x8(%rsp)
cmpq $0x0, 0x8(%rdi)
je 0x4423
movslq 0x14(%rdi), %rsi
testq %rsi, %rsi
jle 0x4428
movq 0x18(%rdi), %rax
movq %rax, -0x10(%rsp)
movl 0x10(%rdi), %r9d
movslq %r9d, %rbx
movq (%rdi), %r14
movl $0x40000000, %r8d       # imm = 0x40000000
xorl %r15d, %r15d
movq -0x10(%rsp), %rax
movq (%rax,%r15,8), %rcx
movq 0x8(%rdi), %r12
movl $0x8, %ebp
xorl %edx, %edx
movq -0x8(%rsp), %r13
imulq %rcx, %rdx
movl %r13d, %eax
addq %rdx, %rax
xorl %edx, %edx
divq %r12
testq %r13, %r13
je 0x4380
shrq $0x8, %r13
decl %ebp
jne 0x4364
imulq %rbx, %rdx
testl %ebx, %ebx
jle 0x43b8
movq %r9, %rax
xorl %ecx, %ecx
xorl %r12d, %r12d
leaq (%rdx,%rcx), %r13
movq %r13, %rbp
shrq $0x6, %rbp
movq (%r14,%rbp,8), %rbp
xorl %r11d, %r11d
btq %r13, %rbp
setb %r11b
leaq (%r11,%r12,2), %r12
incq %rcx
decq %rax
jne 0x4390
jmp 0x43bb
xorl %r12d, %r12d
leaq 0x1(%r12), %rax
movq %rax, %r13
movl %r9d, %ecx
shrq %cl, %r13
testq %r13, %r13
cmovneq %r12, %rax
testl %r9d, %r9d
jle 0x440e
movq %r9, %r12
xorl %r13d, %r13d
leaq (%rdx,%r13), %rcx
movq %rcx, %r11
shrq $0x6, %r11
movq (%r14,%r11,8), %rbp
btrq %rcx, %rbp
decq %r12
xorl %r10d, %r10d
btq %r12, %rax
setb %r10b
shlq %cl, %r10
orq %rbp, %r10
movq %r10, (%r14,%r11,8)
incq %r13
testq %r12, %r12
jne 0x43db
cmpq %r8, %rax
cmovbq %rax, %r8
incq %r15
cmpq %rsi, %r15
jne 0x434b
jmp 0x442e
xorl %r8d, %r8d
jmp 0x442e
movl $0x40000000, %r8d       # imm = 0x40000000
movl %r8d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq