LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/R3Utils/../../pkgs/R3Shapes/R3Kdtree.cpp
// Function: gaps::R3Kdtree<gaps::R3SegmentationPoint*>::FindAll(gaps::R3Plane const&, double, double, gaps::RNArray<gaps::R3SegmentationPoint*>&) const
int R3Kdtree<PtrType>::
FindAll(const R3Plane& query_plane, 
  RNScalar min_distance, RNScalar max_distance, 
  RNArray<PtrType>& points) const
{
  // Check root
  if (!root) return 0;

  // Search nodes recursively
  FindAll<R3Plane>(root, bbox, 
    query_plane,
    min_distance, max_distance, 
    points);

  // Return number of points
  return points.NEntries();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x50(%rax)
jne 0x47a19
movl $0x0, 0x34(%rsp)
jmp 0x47a4d
movq (%rsp), %rdx
movq 0x50(%rdx), %rsi
movq 0x20(%rsp), %rcx
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq 0x8(%rsp), %r8
movq %rdx, %rdi
callq 0x49130
movq 0x8(%rsp), %rdi
callq 0x1ecf0
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: RipcordSoftware[P]lazyflatset/test/lazyflatset/main.cpp
// Function: test(std::function<void (__gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>)>, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>, bool)
void test(TestFunction func, SourceIterator begin, SourceIterator end, bool eol = false) {
    auto start = std::chrono::steady_clock::now();
    func(begin, end);
    auto duration = std::chrono::steady_clock::now() - start;
    auto durationMS = std::chrono::duration_cast<std::chrono::milliseconds>(duration);
    
    std::cout << durationMS.count();
    
    if (eol) {
        std::cout << std::endl;
    } else {
        std::cout << ", ";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movb %cl, %al
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
callq 0x2170
movq -0x58(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x4a40
callq 0x2170
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4a90
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4ae0
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4b10
movq %rax, %rsi
movq 0x13645(%rip), %rdi     # 0x15fd8
callq 0x21d0
testb $0x1, -0x19(%rbp)
je 0x29b3
movq 0x13633(%rip), %rdi     # 0x15fd8
movq 0x1361c(%rip), %rsi     # 0x15fc8
callq 0x2150
jmp 0x29c6
movq 0x1361e(%rip), %rdi     # 0x15fd8
leaq 0xc750(%rip), %rsi      # 0xf111
callq 0x2120
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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>::flushUnsorted() const
void flushUnsorted() const {
        const auto unsortedSize = unsorted_.size();
        if (unsortedSize > 0) {
            if ((nursery_.size() + unsortedSize) > maxNurseryEntries_) {
                flushNursery();
            }

            sort(unsorted_);
            merge(unsorted_, nursery_);
            unsorted_.clear();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x40, %rdi
callq 0x7200
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0xa1f2
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x7200
movq -0x18(%rbp), %rcx
addq -0x10(%rbp), %rax
movl 0xc(%rcx), %ecx
cmpq %rcx, %rax
jbe 0xa1be
movq -0x18(%rbp), %rdi
callq 0xa8f0
movq -0x18(%rbp), %rdi
movq %rdi, %rsi
addq $0x40, %rsi
callq 0xa940
movq -0x18(%rbp), %rdi
movq %rdi, %rsi
addq $0x40, %rsi
movq %rdi, %rdx
addq $0x28, %rdx
callq 0xa990
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0xabd0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wujf[P]dnsfwd/udpfwd.cpp
// Function: UdpForwarder::parse_dns(char const*, char*, unsigned long)
void parse_dns(const char* in, char* out, size_t limit) {
    const char* iptr = in;
    char* optr = out;
    while (*iptr) {
        size_t len = *iptr;
        ++iptr;
        memcpy(optr, iptr, len);
        iptr += len;
        optr += len;
        *optr = '.';
        ++optr;
    }

    --optr;
    *optr = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x24c3
movq -0x20(%rbp), %rax
movsbq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x2130
movq -0x30(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb $0x2e, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2464
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: wujf[P]dnsfwd/udpfwd.cpp
// Function: UdpForwarder::init_ss()
int init_ss() {
    int ss_sock = socket(AF_INET, SOCK_STREAM, 0);
    ::sockaddr_in ss_addr;
    ss_addr.sin_family = AF_INET;
    ss_addr.sin_port = htons(kSocksServerPort);
    ss_addr.sin_addr.s_addr = ::inet_addr("127.0.0.1");

    if (::connect(ss_sock, reinterpret_cast<sockaddr*>(&ss_addr), sizeof(ss_addr)) < 0) {
        ::perror("connect to ss server error");
        return -1;
    }

    return ss_sock;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2090
movl %eax, -0x8(%rbp)
movw $0x2, -0x18(%rbp)
movl $0x2378, %edi           # imm = 0x2378
callq 0x2050
movw %ax, -0x16(%rbp)
leaq 0x2aed(%rip), %rdi      # 0x5004
callq 0x2190
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %edi
leaq -0x18(%rbp), %rsi
movl $0x10, %edx
callq 0x2140
cmpl $0x0, %eax
jge 0x254a
leaq 0x2ad2(%rip), %rdi      # 0x500e
callq 0x2150
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2550
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: wujf[P]dnsfwd/udpfwd.cpp
// Function: main
int main(int argc, char* argv[]) {
    u_short port = 1953;
    if (argc > 1)
        port = atoi(argv[1]);

    return UdpForwarder::run(port);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw $0x7a1, -0x12(%rbp)     # imm = 0x7A1
cmpl $0x1, -0x8(%rbp)
jle 0x2cc3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2250
movw %ax, -0x12(%rbp)
movzwl -0x12(%rbp), %edi
callq 0x2670
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x2e0, %rsp            # imm = 0x2E0
movl $0x0, -0x4(%rbp)
callq 0x21b0
incl %eax
movl %eax, %esi
leaq -0x2a0(%rbp), %rdi
callq 0x2910
movl $0x2a, -0x2b4(%rbp)
leaq -0x78(%rip), %rsi       # 0x2440
leaq -0x2b0(%rbp), %rdi
leaq -0x2b4(%rbp), %rdx
callq 0x2a80
jmp 0x24cd
leaq 0x15c9c(%rip), %rdi     # 0x18170
movl $0x64, %esi
leaq -0x2b0(%rbp), %rdx
callq 0x2a20
jmp 0x24e7
leaq 0x15c82(%rip), %rsi     # 0x18170
leaq -0x2a0(%rbp), %rdi
movl $0x64, %edx
callq 0x2ac0
movb %al, -0x2c5(%rbp)
movq 0x15ac4(%rip), %rdi     # 0x17fd0
leaq 0xedf9(%rip), %rsi      # 0x1130c
callq 0x2150
movq %rax, -0x2d0(%rbp)
jmp 0x2521
movq -0x2d0(%rbp), %rdi
movb -0x2c5(%rbp), %cl
leaq 0xedea(%rip), %rax      # 0x1131f
leaq 0xeded(%rip), %rsi      # 0x11329
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x2150
movq %rax, -0x2d8(%rbp)
jmp 0x2551
movq -0x2d8(%rbp), %rdi
movq 0x15a41(%rip), %rsi     # 0x17fa0
callq 0x2180
jmp 0x2566
movb -0x2c5(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x2578
jmp 0x25b7
leaq 0xedb1(%rip), %rdi      # 0x11330
leaq 0xedb9(%rip), %rsi      # 0x1133f
movl $0x22, %edx
leaq 0xedb6(%rip), %rcx      # 0x11348
callq 0x20f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2c0(%rbp)
movl %eax, -0x2c4(%rbp)
leaq -0x2a0(%rbp), %rdi
callq 0x2b10
jmp 0x25d6
movl $0x0, -0x4(%rbp)
leaq -0x2a0(%rbp), %rdi
callq 0x2b10
movl -0x4(%rbp), %eax
addq $0x2e0, %rsp            # imm = 0x2E0
popq %rbp
retq
movq -0x2c0(%rbp), %rdi
callq 0x2230
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x0, (%rax)
movl $0x1, 0x4(%rax)
movl $0x64, 0x8(%rax)
movl $0x0, 0xc(%rax)
movl $0x20, %edi
callq 0x3250
movq %rax, -0x50(%rbp)
movb $0x1, -0x3d(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x33f0
movq -0x48(%rbp), %rdx
leaq 0x6b39(%rip), %rsi      # 0xa2c2
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0x3794
movq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5bf0
jmp 0x37a3
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rcx
movb $0x0, -0x3d(%rbp)
movq %rcx, 0x18(%rax)
leaq -0x28(%rbp), %rdi
callq 0x3130
leaq -0x29(%rbp), %rdi
callq 0x3290
movl $0x30, %edi
callq 0x3250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x5c80
jmp 0x37e0
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, 0x20(%rax)
movl $0x38, %edi
callq 0x3250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
callq 0x7c80
jmp 0x3807
movq -0x58(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, 0x28(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x3210
movl %eax, %edi
callq 0x3220
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x384c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3130
leaq -0x29(%rbp), %rdi
callq 0x3290
testb $0x1, -0x3d(%rbp)
jne 0x385d
jmp 0x386b
movq -0x50(%rbp), %rdi
movl $0x20, %esi
callq 0x3260
jmp 0x38a3
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x30, %esi
callq 0x3260
jmp 0x38a3
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x38, %esi
callq 0x3260
movq -0x38(%rbp), %rdi
callq 0x33e0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x20(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x5d80
testb $0x1, %al
jne 0x3a9c
jmp 0x3b2b
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0x39a0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jle 0x3adb
movq -0x18(%rbp), %rdi
movq 0x10(%rdi), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
callq 0x39a0
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %esi
movl %eax, %edx
callq 0x5000
jmp 0x3b29
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0x3980
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x3b1a
movq -0x18(%rbp), %rdi
movq 0x10(%rdi), %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x30(%rbp)
callq 0x3980
movq -0x38(%rbp), %rdi
movl -0x30(%rbp), %esi
movl %eax, %edx
callq 0x5090
jmp 0x3b27
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0x3b29
jmp 0x3b2b
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl -0x14(%rbp), %esi
callq 0x3a70
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x3b7d
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4ea0
movb $0x1, -0x1(%rbp)
jmp 0x3bf3
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x3b98
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4e60
movb $0x1, -0x1(%rbp)
jmp 0x3bf3
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x68(%rbp)
movl 0xc(%rax), %ecx
movl %ecx, -0x5c(%rbp)
movq 0x18(%rax), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x5c30
movq -0x68(%rbp), %rdi
movl -0x5c(%rbp), %esi
movq -0x58(%rbp), %rdx
callq 0x4ee0
jmp 0x3bcd
leaq -0x38(%rbp), %rdi
callq 0x3130
movb $0x0, -0x1(%rbp)
jmp 0x3bf3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3130
jmp 0x3bfe
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x33e0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
xorl %esi, %esi
callq 0x39e0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x5e20
movq -0x10(%rbp), %rdi
movq 0x10(%rdi), %rax
movq %rax, -0x28(%rbp)
callq 0x3980
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x4a50
movq -0x10(%rbp), %rdi
callq 0x3c80
movq -0x10(%rbp), %rdi
movq 0x10(%rdi), %rax
movq %rax, -0x20(%rbp)
callq 0x3980
movq -0x10(%rbp), %rdi
movl %eax, -0x14(%rbp)
callq 0x39a0
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl %eax, %edx
callq 0x4f70
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x7fa0
movq -0x10(%rbp), %rdi
callq 0x4270
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: FabienBounoir[P]JustePrix-CLI/justePrix.cpp
// Function: JustePrix::calculerTemps(int)
void JustePrix::calculerTemps(int chronometre)
{
    int heure = chronometre / 3600;
    int minute = chronometre / 60;
    int seconde = chronometre % 60;
    ihm->afficherChronometre(heure, minute, seconde);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl $0xe10, %ecx            # imm = 0xE10
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movq -0x20(%rbp), %rax
movl %edx, -0x18(%rbp)
movq 0x10(%rax), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x5aa0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
xorl %esi, %esi
callq 0x39e0
movq -0x10(%rbp), %rdi
movq 0x10(%rdi), %rax
movq %rax, -0x28(%rbp)
callq 0x3980
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x4a50
movq -0x10(%rbp), %rdi
callq 0x3c10
movq -0x10(%rbp), %rdi
callq 0x3c80
movq -0x10(%rbp), %rdi
movq 0x10(%rdi), %rax
movq %rax, -0x20(%rbp)
callq 0x3980
movq -0x10(%rbp), %rdi
movl %eax, -0x14(%rbp)
callq 0x39a0
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl %eax, %edx
callq 0x4f70
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x7fa0
movq -0x10(%rbp), %rdi
callq 0x4270
addq $0x30, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movl $0x0, -0xc(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x3210
movq %rax, -0x18(%rbp)
movq -0x90(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xa8(%rbp)
movq 0x18(%rax), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x5c30
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x4d60
movl %eax, -0x94(%rbp)
jmp 0x42df
movl -0x94(%rbp), %eax
movl %eax, -0xc(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3130
movq -0x90(%rbp), %rdi
movl -0xc(%rbp), %esi
movl (%rdi), %edx
callq 0x3b40
testb $0x1, %al
jne 0x429e
xorl %eax, %eax
movl %eax, %edi
callq 0x3210
movq -0x90(%rbp), %rdi
movl -0x18(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %esi
callq 0x4180
movq -0x90(%rbp), %rdi
movq 0x20(%rdi), %rax
movq %rax, -0xc0(%rbp)
callq 0x3960
movl %eax, %ecx
movq -0x90(%rbp), %rax
movl %ecx, -0xb4(%rbp)
movq 0x18(%rax), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x5c30
movq -0xc0(%rbp), %rdi
movl -0xb4(%rbp), %esi
movq -0xb0(%rbp), %rdx
callq 0x5ce0
jmp 0x437b
leaq -0x68(%rbp), %rdi
callq 0x3130
movq -0x90(%rbp), %rdi
movq 0x28(%rdi), %rax
movq %rax, -0xd8(%rbp)
callq 0x3960
movl %eax, %ecx
movq -0x90(%rbp), %rax
movl %ecx, -0xcc(%rbp)
movq 0x18(%rax), %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x5c30
movq -0xd8(%rbp), %rdi
movl -0xcc(%rbp), %esi
movq -0xc8(%rbp), %rdx
callq 0x8210
jmp 0x43dc
leaq -0x88(%rbp), %rdi
callq 0x3130
movq -0x90(%rbp), %rdi
callq 0x3e60
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3130
jmp 0x4443
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3130
jmp 0x4443
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x3130
movq -0x40(%rbp), %rdi
callq 0x33e0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3340
movq 0xa2fd(%rip), %rdi      # 0xefc8
leaq 0x579a(%rip), %rsi      # 0xa46c
callq 0x3240
movq %rax, -0x30(%rbp)
jmp 0x4cdd
movq -0x30(%rbp), %rdi
movq 0xa2d0(%rip), %rsi      # 0xefb8
callq 0x3270
jmp 0x4cef
movq -0x40(%rbp), %rsi
movq 0xa2de(%rip), %rdi      # 0xefd8
callq 0x3310
jmp 0x4d01
movq 0xa2c0(%rip), %rdi      # 0xefc8
leaq 0x5a35(%rip), %rsi      # 0xa744
callq 0x3240
jmp 0x4d16
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x4d42
jmp 0x4d39
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3130
jmp 0x4d4c
movq -0x40(%rbp), %rdi
callq 0x3130
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq 0xa246(%rip), %rdi      # 0xefc8
movq 0xa22f(%rip), %rsi      # 0xefb8
callq 0x3270
movq -0x20(%rbp), %rsi
movq 0xa22f(%rip), %rdi      # 0xefc8
callq 0x3200
movq %rax, %rdi
leaq 0x56df(%rip), %rsi      # 0xa487
callq 0x3240
movq %rax, %rdi
movq 0xa201(%rip), %rsi      # 0xefb8
callq 0x3270
movq 0xa215(%rip), %rdi      # 0xefd8
leaq -0x14(%rbp), %rsi
callq 0x3120
movq 0xa205(%rip), %rax      # 0xefd8
movq (%rax), %rax
movq 0xa1fb(%rip), %rdi      # 0xefd8
addq -0x18(%rax), %rdi
callq 0x3030
testb $0x1, %al
jne 0x4dec
jmp 0x4e55
movq 0xa1d5(%rip), %rdi      # 0xefc8
leaq 0x568f(%rip), %rsi      # 0xa489
callq 0x3240
movq %rax, %rdi
movq 0xa1af(%rip), %rsi      # 0xefb8
callq 0x3270
movq 0xa1c3(%rip), %rax      # 0xefd8
movq (%rax), %rax
movq 0xa1b9(%rip), %rdi      # 0xefd8
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x33c0
movq 0xa1a7(%rip), %rdi      # 0xefd8
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x3140
movq 0xa191(%rip), %rdi      # 0xefd8
leaq -0x14(%rbp), %rsi
callq 0x3120
jmp 0x4dcc
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x20, -0x11(%rbp)
movq 0x9e89(%rip), %rdi      # 0xefc8
movq 0x9e72(%rip), %rsi      # 0xefb8
callq 0x3270
movq -0x20(%rbp), %rsi
movq 0x9e72(%rip), %rdi      # 0xefc8
callq 0x3200
movq %rax, %rdi
leaq 0x545b(%rip), %rsi      # 0xa5c0
callq 0x3240
movq %rax, %rdi
movq 0x9e44(%rip), %rsi      # 0xefb8
callq 0x3270
movq 0x9e48(%rip), %rdi      # 0xefc8
leaq 0x545a(%rip), %rsi      # 0xa5e1
callq 0x3240
movq %rax, %rdi
movq 0x9e22(%rip), %rsi      # 0xefb8
callq 0x3270
movq 0x9e26(%rip), %rdi      # 0xefc8
leaq 0x5457(%rip), %rsi      # 0xa600
callq 0x3240
movq %rax, %rdi
movq 0x9e00(%rip), %rsi      # 0xefb8
callq 0x3270
movq 0x9e04(%rip), %rdi      # 0xefc8
leaq 0x5453(%rip), %rsi      # 0xa61e
callq 0x3240
movq %rax, %rdi
movq 0x9dde(%rip), %rsi      # 0xefb8
callq 0x3270
movq 0x9de2(%rip), %rdi      # 0xefc8
movq 0x9dcb(%rip), %rsi      # 0xefb8
callq 0x3270
movq 0x9dcf(%rip), %rdi      # 0xefc8
leaq 0x5441(%rip), %rsi      # 0xa641
callq 0x3240
movq 0x9dcc(%rip), %rdi      # 0xefd8
leaq -0x11(%rbp), %rsi
callq 0x3320
movq 0x9dac(%rip), %rdi      # 0xefc8
leaq 0x5521(%rip), %rsi      # 0xa744
callq 0x3240
movb -0x11(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb $0x20, -0x9(%rbp)
movl $0x1, %edi
callq 0x31a0
movq 0x9d67(%rip), %rdi      # 0xefc8
movq 0x9d50(%rip), %rsi      # 0xefb8
callq 0x3270
movq 0x9d54(%rip), %rdi      # 0xefc8
leaq 0x53e7(%rip), %rsi      # 0xa662
callq 0x3240
movq %rax, %rdi
movq 0x9d2e(%rip), %rsi      # 0xefb8
callq 0x3270
movq 0x9d32(%rip), %rdi      # 0xefc8
leaq 0x53da(%rip), %rsi      # 0xa677
callq 0x3240
movq %rax, %rdi
movq 0x9d0c(%rip), %rsi      # 0xefb8
callq 0x3270
movq 0x9d10(%rip), %rdi      # 0xefc8
leaq 0x53d6(%rip), %rsi      # 0xa695
callq 0x3240
movq %rax, %rdi
movq 0x9cea(%rip), %rsi      # 0xefb8
callq 0x3270
movq 0x9cee(%rip), %rdi      # 0xefc8
leaq 0x53d3(%rip), %rsi      # 0xa6b4
callq 0x3240
movq %rax, %rdi
movq 0x9cc8(%rip), %rsi      # 0xefb8
callq 0x3270
movq 0x9ccc(%rip), %rdi      # 0xefc8
leaq 0x53c6(%rip), %rsi      # 0xa6c9
callq 0x3240
movq 0x9cc9(%rip), %rdi      # 0xefd8
leaq -0x9(%rbp), %rsi
callq 0x3320
movq 0x9ca9(%rip), %rdi      # 0xefc8
leaq 0x541e(%rip), %rsi      # 0xa744
callq 0x3240
movb -0x9(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x4caf(%rip), %rdi      # 0xa07a
callq 0x31e0
movq 0x9bf1(%rip), %rdi      # 0xefc8
leaq 0x5324(%rip), %rsi      # 0xa702
callq 0x3240
movq %rax, %rdi
movq 0x9bcb(%rip), %rsi      # 0xefb8
callq 0x3270
movq 0x9bcf(%rip), %rdi      # 0xefc8
leaq 0x531d(%rip), %rsi      # 0xa71d
callq 0x3240
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x5b60
movq -0x20(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x3200
movq %rax, %rdi
movq 0x9b88(%rip), %rsi      # 0xefb8
callq 0x3270
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x30(%rbp)
callq 0x5b80
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x54a2
movq 0x9b69(%rip), %rdi      # 0xefc8
leaq 0x52cc(%rip), %rsi      # 0xa732
callq 0x3240
movq -0x28(%rbp), %rdi
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x5b60
movq -0x38(%rbp), %rdi
movl (%rax), %esi
callq 0x33d0
movq %rax, %rdi
movq 0x9b26(%rip), %rsi      # 0xefb8
callq 0x3270
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x543c
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x95d2(%rip), %rdi      # 0xefc8
movq 0x95bb(%rip), %rsi      # 0xefb8
callq 0x3270
cmpl $0x1, -0xc(%rbp)
jg 0x5a46
movq 0x95b9(%rip), %rdi      # 0xefc8
leaq 0x4d5d(%rip), %rsi      # 0xa773
callq 0x3240
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x33d0
movq %rax, %rdi
leaq 0x4d5e(%rip), %rsi      # 0xa78e
callq 0x3240
movq %rax, %rdi
movq 0x9579(%rip), %rsi      # 0xefb8
callq 0x3270
jmp 0x5a82
movq 0x957b(%rip), %rdi      # 0xefc8
leaq 0x4d1f(%rip), %rsi      # 0xa773
callq 0x3240
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x33d0
movq %rax, %rdi
leaq 0x4d41(%rip), %rsi      # 0xa7af
callq 0x3240
movq %rax, %rdi
movq 0x953b(%rip), %rsi      # 0xefb8
callq 0x3270
movq 0x953f(%rip), %rdi      # 0xefc8
movq 0x9528(%rip), %rsi      # 0xefb8
callq 0x3270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x18, %rdi
callq 0x60d0
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x18, %rdi
callq 0x6100
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x6080
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
callq 0x6100
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6040
testb $0x1, %al
jne 0x5dee
jmp 0x5df4
movb $0x0, -0x1(%rbp)
jmp 0x5e09
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
leaq -0x14(%rbp), %rsi
callq 0x6130
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x64, %eax
je 0x7d4c
jmp 0x7d34
movl -0x10(%rbp), %eax
subl $0x1f4, %eax            # imm = 0x1F4
je 0x7d62
jmp 0x7d40
movl -0x10(%rbp), %eax
subl $0x3e8, %eax            # imm = 0x3E8
je 0x7d78
jmp 0x7d8c
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
leaq 0x2ae3(%rip), %rsi      # 0xa83e
callq 0x3330
jmp 0x7d8c
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
leaq 0x2adf(%rip), %rsi      # 0xa850
callq 0x3330
jmp 0x7d8c
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
leaq 0x2ada(%rip), %rsi      # 0xa861
callq 0x3330
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x400(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3340
movq -0x400(%rbp), %rsi
leaq -0x258(%rbp), %rdi
callq 0x7ce0
jmp 0x7ddb
leaq -0x258(%rbp), %rdi
callq 0x30d0
movq %rax, %rsi
leaq -0x238(%rbp), %rdi
movl $0x8, %edx
callq 0x3410
jmp 0x7dfd
leaq -0x258(%rbp), %rdi
callq 0x3130
movl $0x0, -0x268(%rbp)
movl $0x0, -0x26c(%rbp)
leaq -0x238(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3070
movq %rax, -0x408(%rbp)
jmp 0x7e36
movq -0x408(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3300
movb %al, -0x409(%rbp)
jmp 0x7e54
movb -0x409(%rbp), %al
testb $0x1, %al
jne 0x7e63
jmp 0x7f42
movl $0x10, %edi
movl $0x8, %esi
callq 0x8590
movl %eax, -0x410(%rbp)
jmp 0x7e7a
movl -0x410(%rbp), %edx
leaq -0x3f8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3390
jmp 0x7e92
leaq -0x3f8(%rbp), %rdi
leaq -0x268(%rbp), %rsi
callq 0x3120
jmp 0x7ea7
movl -0x268(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x7f31
movl -0x26c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x26c(%rbp)
jmp 0x7f31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x260(%rbp)
movl %eax, -0x264(%rbp)
jmp 0x7f7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x260(%rbp)
movl %eax, -0x264(%rbp)
leaq -0x258(%rbp), %rdi
callq 0x3130
jmp 0x7f7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x260(%rbp)
movl %eax, -0x264(%rbp)
jmp 0x7f72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x260(%rbp)
movl %eax, -0x264(%rbp)
leaq -0x3f8(%rbp), %rdi
callq 0x3190
jmp 0x7f72
leaq -0x3f8(%rbp), %rdi
callq 0x3190
jmp 0x7e1d
movl -0x26c(%rbp), %eax
movl %eax, -0x414(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x3080
leaq -0x30(%rbp), %rdi
callq 0x3130
movl -0x414(%rbp), %eax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
leaq -0x238(%rbp), %rdi
callq 0x3080
leaq -0x30(%rbp), %rdi
callq 0x3130
movq -0x260(%rbp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: FabienBounoir[P]JustePrix-CLI/meilleurScore.cpp
// Function: MeilleurScore::recupererScore()
void MeilleurScore::recupererScore()  
{
    string ligneFichierScore;
    ifstream fichierScore(this->getFichierDifficulte().c_str());
    int score = 0;

    while(getline(fichierScore, ligneFichierScore)) 
    {
        string recuperationScore = ligneFichierScore;
        stringstream convert(recuperationScore); 
        convert >> score;

        this->donneeFichier.push_back(make_pair(score, ligneFichierScore));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x450, %rsp            # imm = 0x450
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x438(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3340
movq -0x438(%rbp), %rsi
leaq -0x250(%rbp), %rdi
callq 0x7ce0
jmp 0x7fd8
leaq -0x250(%rbp), %rdi
callq 0x30d0
movq %rax, %rsi
leaq -0x230(%rbp), %rdi
movl $0x8, %edx
callq 0x3410
jmp 0x7ffa
leaq -0x250(%rbp), %rdi
callq 0x3130
movl $0x0, -0x260(%rbp)
leaq -0x230(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3070
movq %rax, -0x440(%rbp)
jmp 0x8029
movq -0x440(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3300
movb %al, -0x441(%rbp)
jmp 0x8047
movb -0x441(%rbp), %al
testb $0x1, %al
jne 0x8056
jmp 0x81c2
leaq -0x280(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x30e0
jmp 0x8068
movl $0x10, %edi
movl $0x8, %esi
callq 0x8590
movl %eax, -0x448(%rbp)
jmp 0x807f
movl -0x448(%rbp), %edx
leaq -0x408(%rbp), %rdi
leaq -0x280(%rbp), %rsi
callq 0x3390
jmp 0x809a
leaq -0x408(%rbp), %rdi
leaq -0x260(%rbp), %rsi
callq 0x3120
jmp 0x80af
movq -0x438(%rbp), %rax
movq %rax, -0x450(%rbp)
leaq -0x430(%rbp), %rdi
leaq -0x260(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x5f10
jmp 0x80d6
movq -0x450(%rbp), %rdi
leaq -0x430(%rbp), %rsi
callq 0x5ee0
jmp 0x80eb
leaq -0x430(%rbp), %rdi
callq 0x4920
leaq -0x408(%rbp), %rdi
callq 0x3190
leaq -0x280(%rbp), %rdi
callq 0x3130
jmp 0x8010
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x258(%rbp)
movl %eax, -0x25c(%rbp)
jmp 0x81ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x258(%rbp)
movl %eax, -0x25c(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x3130
jmp 0x81ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x258(%rbp)
movl %eax, -0x25c(%rbp)
jmp 0x81e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x258(%rbp)
movl %eax, -0x25c(%rbp)
jmp 0x81b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x258(%rbp)
movl %eax, -0x25c(%rbp)
jmp 0x81a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x258(%rbp)
movl %eax, -0x25c(%rbp)
leaq -0x430(%rbp), %rdi
callq 0x4920
leaq -0x408(%rbp), %rdi
callq 0x3190
leaq -0x280(%rbp), %rdi
callq 0x3130
jmp 0x81e0
leaq -0x230(%rbp), %rdi
callq 0x3080
leaq -0x28(%rbp), %rdi
callq 0x3130
addq $0x450, %rsp            # imm = 0x450
popq %rbp
retq
leaq -0x230(%rbp), %rdi
callq 0x3080
leaq -0x28(%rbp), %rdi
callq 0x3130
movq -0x258(%rbp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: s-yata[P]louds-patricia/louds-patricia.cpp
// Function: louds::(anonymous namespace)::Trie::Trie()
Trie() : levels(2), last_key(), n_keys(0), n_nodes(1) {
    levels[0].louds.add(0);
    levels[0].louds.add(1);
    levels[1].louds.add(1);
    levels[0].outs.add(0);
    levels[0].labels.push_back(' ');
  }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %rax, 0x20(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x27a0
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rdx
movl $0x2, %esi
callq 0x27b0
jmp 0x256d
leaq 0x4f(%rsp), %rdi
callq 0x2830
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movq %rdi, 0x10(%rsp)
callq 0x21c0
movq 0x20(%rsp), %rdi
movq $0x0, 0x38(%rdi)
movq $0x1, 0x40(%rdi)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, 0x18(%rsp)
callq 0x2840
movq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x2860
jmp 0x25bc
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2840
movq %rax, %rdi
movl $0x1, %esi
callq 0x2860
jmp 0x25d9
movq 0x20(%rsp), %rdi
movl $0x1, %esi
movq %rsi, 0x8(%rsp)
callq 0x2840
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2860
jmp 0x25fc
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movq %rsi, (%rsp)
callq 0x2840
movq (%rsp), %rsi
movq %rax, %rdi
addq $0x50, %rdi
callq 0x2860
jmp 0x2620
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2840
movq %rax, %rdi
addq $0xa0, %rdi
movb $0x20, 0x3b(%rsp)
leaq 0x3b(%rsp), %rsi
callq 0x78a0
jmp 0x2649
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x4f(%rsp), %rdi
callq 0x2830
jmp 0x268a
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x2110
movq 0x28(%rsp), %rdi
callq 0x28d0
movq 0x40(%rsp), %rdi
callq 0x2230
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rax), %rax
andq $0xff, %rax
cmpq $0x0, %rax
jne 0x289f
movq (%rsp), %rdi
movq 0x48(%rdi), %rsi
addq $0x100, %rsi            # imm = 0x100
shrq $0x6, %rsi
callq 0x7920
movq (%rsp), %rdi
movq 0x48(%rdi), %rsi
movq 0x8(%rsp), %rdx
callq 0x3070
movq (%rsp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: s-yata[P]louds-patricia/louds-patricia.cpp
// Function: louds::(anonymous namespace)::BitVector::set(unsigned long, unsigned long)
void set(uint64_t i, uint64_t bit) {
    if (bit) {
      words[i / 64] |= (1UL << (i % 64));
    } else {
      words[i / 64] &= ~(1UL << (i % 64));
    }
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x30cb
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rcx
andq $0x3f, %rcx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rsi
shrq $0x6, %rsi
callq 0x8470
movq 0x10(%rsp), %rcx
orq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x3103
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rcx
andq $0x3f, %rcx
movl $0x1, %eax
shlq %cl, %rax
xorq $-0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rsi
shrq $0x6, %rsi
callq 0x8470
movq 0x8(%rsp), %rcx
andq (%rax), %rcx
movq %rcx, (%rax)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x38(%rsp), %rax
shrq $0x6, %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
andq $0x3f, %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
shrq $0x2, %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
andq $0x3, %rax
movq %rax, 0x18(%rsp)
addq $0x18, %rdi
movq 0x20(%rsp), %rsi
callq 0x5c00
movq %rax, %rdi
callq 0x5c20
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x433e
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x20(%rsp), %rsi
callq 0x5c00
movq 0x18(%rsp), %rcx
subq $0x1, %rcx
movzbl 0x5(%rax,%rcx), %eax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x9700
movq (%rax), %rdi
movq 0x28(%rsp), %rcx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
andq %rax, %rdi
callq 0x5c40
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: s-yata[P]louds-patricia/louds-patricia.cpp
// Function: louds::PatriciaImpl::size() const
uint64_t size() const {
    uint64_t size = 0;
    size += louds_.size();
    size += outs_.size();
    size += links_.size();
    size += labels_.size();
    size += tail_bits_.size();
    size += tail_bytes_.size();
    return size;
  }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq $0x0, 0x8(%rsp)
addq $0x48, %rdi
callq 0x69a0
movq (%rsp), %rdi
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x98, %rdi
callq 0x69a0
movq (%rsp), %rdi
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0xe8, %rdi
callq 0x69a0
movq (%rsp), %rdi
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x138, %rdi            # imm = 0x138
callq 0x89f0
movq (%rsp), %rdi
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x150, %rdi            # imm = 0x150
callq 0x69a0
movq (%rsp), %rdi
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x1a0, %rdi            # imm = 0x1A0
callq 0x89f0
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x5(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1270
movq -0x38(%rbp), %rsi
movl $0x4, -0x1c(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rdx
callq 0x1290
jmp 0x11f6
leaq -0x18(%rbp), %rdi
callq 0x12d0
cmpl $0x4, (%rax)
jne 0x1206
jmp 0x123c
leaq 0xdf7(%rip), %rdi       # 0x2004
leaq 0xdf8(%rip), %rsi       # 0x200c
movl $0x8, %edx
leaq 0xe02(%rip), %rcx       # 0x2022
callq 0x1060
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x5(%rbp), %rdi
callq 0x1320
jmp 0x125e
movl $0x0, -0x4(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1300
leaq -0x5(%rbp), %rdi
callq 0x1320
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x10b0
nopw (%rax,%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
movl -0x24(%rsp), %eax
movq -0x18(%rsp), %rcx
cmpl 0xaf8(%rcx), %eax
jge 0x8f95
movq -0x20(%rsp), %rax
shlq $0x2, %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rcx
andq $0x3, %rcx
movl $0x3, %eax
subq %rcx, %rax
orq -0x20(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
shrq $0x2, %rax
movq %rax, -0x10(%rsp)
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x8f40
movq -0x20(%rsp), %rax
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x90ae
movq 0x20(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x41, %ecx
movb %al, 0x3(%rsp)
je 0x9038
movq 0x20(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x54, %ecx
movb %al, 0x3(%rsp)
je 0x9038
movq 0x20(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x43, %ecx
movb %al, 0x3(%rsp)
je 0x9038
movq 0x20(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x47, %eax
sete %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
testb $0x1, %al
jne 0x9042
jmp 0x9044
jmp 0x9063
leaq 0xcfd5(%rip), %rdi      # 0x16020
leaq 0xd001(%rip), %rsi      # 0x16053
movl $0x15, %edx
leaq 0xd007(%rip), %rcx      # 0x16065
callq 0x83d0
movq 0x8(%rsp), %rax
shlq $0x2, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movslq 0x4(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movsbq 0xb38(%rax,%rcx), %rax
andq $0x3, %rax
orq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x8fc7
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)