LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/huntzhan[P]SAM-PNG/solution.cc
// Function: CreateSAM(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
State *CreateSAM(const string &T) {
  auto start = new State;
  auto last = start;

  for (char c : T) {
    last = AddSymbolToSAM(start, last, c);
  }
  
  while (last != start) {
    last->set_accept(true);
    last = last->link();
  }

  return start;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x58, %edi
callq 0x20d0
movq %rax, %rbx
xorl %eax, %eax
movq %rax, (%rbx)
movl $0xffffffff, 0x8(%rbx)  # imm = 0xFFFFFFFF
movq %rax, 0x10(%rbx)
leaq 0x48(%rbx), %rax
movq %rax, 0x18(%rbx)
movq $0x1, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movl $0x3f800000, 0x38(%rbx) # imm = 0x3F800000
movups %xmm0, 0x40(%rbx)
movb $0x0, 0x50(%rbx)
movq 0x8(%r14), %r15
testq %r15, %r15
je 0x2721
movq (%r14), %r14
xorl %r12d, %r12d
movq %rbx, %rax
movsbl (%r14,%r12), %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x246c
incq %r12
cmpq %r12, %r15
jne 0x26fa
jmp 0x271c
movb $0x1, 0x50(%rax)
movq 0x10(%rax), %rax
cmpq %rbx, %rax
jne 0x2714
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/huntzhan[P]SAM-PNG/solution.cc
// Function: TopologySort(State*, std::unordered_set<State*, std::hash<State*>, std::equal_to<State*>, std::allocator<State*>>&, std::vector<State*, std::allocator<State*>>&)
void TopologySort(
    State *node,
    unordered_set<State *> &searched,
    vector<State *> &nodes) {

  if (searched.count(node) > 0) {
    return;
  }
  searched.insert(node);

  for (auto &tran : node->trans()) {
    auto child = tran.second;
    TopologySort(child, searched, nodes);
  }

  nodes.push_back(node);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rsp, %rsi
movq %rdi, (%rsi)
movq %r14, %rdi
callq 0x3be0
testq %rax, %rax
jne 0x27f9
leaq 0x10(%rsp), %r15
movq %r14, (%r15)
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3c3c
movq (%r12), %rax
leaq 0x18(%rax), %rsi
xorl %ecx, %ecx
movq %rcx, (%r15)
movq 0x20(%rax), %rdx
movq %rdx, 0x8(%r15)
movq %rcx, 0x10(%r15)
movq 0x30(%rax), %rdx
movq %rdx, 0x18(%r15)
movups 0x38(%rax), %xmm0
movups %xmm0, 0x20(%r15)
movq %rcx, 0x30(%r15)
leaq 0x8(%rsp), %rdx
movq %r15, (%rdx)
movq %r15, %rdi
callq 0x38f2
movq 0x10(%r15), %r15
testq %r15, %r15
je 0x27cc
movq 0x10(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2730
movq (%r15), %r15
jmp 0x27b3
leaq 0x10(%rsp), %rdi
callq 0x3a40
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x27ee
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x27f9
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x3eca
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3a40
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/huntzhan[P]SAM-PNG/solution.cc
// Function: main
int main() {
  string T;
  fin >> T;

  auto start = CreateSAM(T);

  unordered_set<State *> searched;
  vector<State *> nodes;

  TopologySort(start, searched, nodes);
  reverse(nodes.begin(), nodes.end());

  CreateDOTSource(nodes, T);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x78, %rsp
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x5094(%rip), %rdi      # 0x8160
leaq 0x20(%rsp), %rsi
callq 0x2140
leaq 0x20(%rsp), %rdi
callq 0x269a
leaq 0x70(%rsp), %rcx
movq %rcx, -0x30(%rcx)
movq $0x1, -0x28(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rcx)
movl $0x3f800000, -0x10(%rcx) # imm = 0x3F800000
movups %xmm0, -0x8(%rcx)
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
leaq 0x40(%rsp), %rsi
movq %rax, %rdi
callq 0x2730
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq %rcx, %rax
setne %dl
addq $-0x8, %rcx
cmpq %rax, %rcx
seta %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x3163
addq $0x8, %rax
movq -0x8(%rax), %rdx
movq (%rcx), %rsi
movq %rsi, -0x8(%rax)
movq %rdx, (%rcx)
addq $-0x8, %rcx
leaq 0x8(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0x3145
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x281a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3186
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x20e0
leaq 0x40(%rsp), %rdi
callq 0x3b70
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x31a7
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x20e0
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
retq
jmp 0x31b3
movq %rax, %rbx
jmp 0x31db
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x31d1
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x20e0
leaq 0x40(%rsp), %rdi
callq 0x3b70
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x31f2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x20e0
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/arturb-dev[P]CPP-Dynamic-Class-Loading/./dlclass.cpp
// Function: std::shared_ptr<Polygon> DLClass<Polygon>::make_obj<int>(int)
std::shared_ptr<T> DLClass<T>::make_obj(Args... args) {
    if(!shared->create || !shared->destroy) {
        if(!shared->open_module(module)) {
            return std::shared_ptr<T>(NULL);
        }
    }

//    auto create_args = ((T* (*)(Args...))create);    
    std::shared_ptr<shared_obj> my_shared = shared;
    return std::shared_ptr<T>(shared->create(args...),
                              [my_shared](T* p){ my_shared->destroy(p); });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq 0x20(%rsi), %r13
cmpq $0x0, (%r13)
je 0x2673
cmpq $0x0, 0x8(%r13)
jne 0x26bf
movl %edx, -0x2c(%rbp)
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %r14
movq %r14, %rdi
callq 0x28e0
movq %r13, %rdi
movq %r14, %rsi
callq 0x2a32
movl %eax, %r14d
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x26b2
callq 0x20e0
testb %r14b, %r14b
je 0x26e1
movq 0x20(%r12), %r13
movl -0x2c(%rbp), %edx
movq 0x28(%r12), %r14
movq %r13, %rax
testq %r14, %r14
je 0x26f3
movq 0x28f5(%rip), %rax      # 0x4fc8
cmpb $0x0, (%rax)
je 0x26e9
incl 0x8(%r14)
movq %r13, %rax
jmp 0x26f3
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x2745
lock
incl 0x8(%r14)
movq 0x20(%r12), %rax
movl %edx, %edi
callq *(%rax)
movq %r13, -0x40(%rbp)
movq %r14, -0x38(%rbp)
testq %r14, %r14
je 0x271b
movq 0x28bd(%rip), %rcx      # 0x4fc8
cmpb $0x0, (%rcx)
je 0x2716
incl 0x8(%r14)
jmp 0x271b
lock
incl 0x8(%r14)
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2bb4
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x2738
callq 0x27c8
testq %r14, %r14
je 0x2745
movq %r14, %rdi
callq 0x27c8
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x278d
callq 0x20e0
jmp 0x278d
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x2780
callq 0x27c8
jmp 0x2780
movq %rax, %rbx
testq %r14, %r14
je 0x278d
movq %r14, %rdi
callq 0x27c8
movq %rbx, %rdi
callq 0x2190
nop
// File: /workspace/github_cpp_makefile_star2_O3/arturb-dev[P]CPP-Dynamic-Class-Loading/./dlclass.cpp
// Function: DLClass<Polygon>::shared_obj::close_module()
void DLClass<T>::shared_obj::close_module() {
    if(dll_handle) {
        dlclose(dll_handle);
        dll_handle = NULL;
    }
    if(create) create = NULL;
    if(destroy) destroy = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x2a0f
callq 0x2090
movq $0x0, 0x10(%rbx)
cmpq $0x0, (%rbx)
je 0x2a1c
movq $0x0, (%rbx)
cmpq $0x0, 0x8(%rbx)
je 0x2a2b
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/arturb-dev[P]CPP-Dynamic-Class-Loading/./dlclass.cpp
// Function: DLClass<Polygon>::shared_obj::open_module(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool DLClass<T>::shared_obj::open_module(std::string module) {
    
    dll_handle = dlopen(module.c_str(), RTLD_LAZY);

    if(!dll_handle) {
        std::cerr << "Failed to open library: " << dlerror() << std::endl;
        return false;
    }

    // Reset errors
    dlerror();

    create = (typename T::create_t*) dlsym(dll_handle, "create");
    const char * err = dlerror();
    if(err) {
        std::cerr << "Failed to load create symbol: " << err << std::endl;
        close_module();
        return false;
    }
    
    destroy = (typename T::destroy_t*) dlsym(dll_handle, "destroy");
    err = dlerror();
    if(err) {
        std::cerr << "Failed to load destroy symbol: " << err << std::endl;
        close_module();
        return false;
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rdi
movl $0x1, %esi
callq 0x2120
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x2a92
callq 0x20d0
movq 0x10(%rbx), %rdi
leaq 0x658(%rip), %rsi       # 0x30bd
callq 0x20c0
movq %rax, (%rbx)
callq 0x20d0
testq %rax, %rax
je 0x2add
movq %rax, %r15
movq 0x256f(%rip), %r14      # 0x4ff0
leaq 0x63c(%rip), %rsi       # 0x30c4
movl $0x1e, %edx
jmp 0x2b15
movq 0x2557(%rip), %rbx      # 0x4ff0
leaq 0x604(%rip), %rsi       # 0x30a4
movl $0x18, %edx
movq %rbx, %rdi
callq 0x2110
callq 0x20d0
testq %rax, %rax
je 0x2b64
movq %rax, %r14
movq %rax, %rdi
callq 0x2060
movq 0x2523(%rip), %rdi      # 0x4ff0
movq %r14, %rsi
movq %rax, %rdx
callq 0x2110
jmp 0x2b7b
movq 0x10(%rbx), %rdi
leaq 0x5fb(%rip), %rsi       # 0x30e3
callq 0x20c0
movq %rax, 0x8(%rbx)
callq 0x20d0
testq %rax, %rax
je 0x2baf
movq %rax, %r15
movq 0x24e7(%rip), %r14      # 0x4ff0
leaq 0x5db(%rip), %rsi       # 0x30eb
movl $0x1f, %edx
movq %r14, %rdi
callq 0x2110
movq %r15, %rdi
callq 0x2060
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2110
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x29f0
jmp 0x2ba2
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2070
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
jmp 0x2ba4
nop
// File: /workspace/github_cpp_makefile_star2_O3/pc260533[P]ITC313-TP1/date.cpp
// Function: Date::normalise(Date)
Date Date::normalise(Date date) {
    std::vector<int> listeJourMois({31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31});
    if (((date.getAnnee() % 4 == 0) && (date.getAnnee() % 100 != 0)) || (date.getAnnee() % 400 == 0)) {
        listeJourMois.at(1) = 29;
    }
    if (date.getJour() > listeJourMois.at(date.getMois() - 1)) {
        date.setMois(date.getMois()+1);
        date.setJour(1);
    }
    if (date.getMois() > 12) {
        date.setAnnee(date.getAnnee()+1);
        date.setMois(1);
    }
    return date;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl %edx, %ebx
movq %rsi, %r14
movups 0x4dbe(%rip), %xmm0     # 0xa4a8
leaq 0x20(%rsp), %rsi
movaps %xmm0, 0x20(%rsi)
movups 0x4d9e(%rip), %xmm0     # 0xa498
movaps %xmm0, 0x10(%rsi)
movups 0x4d83(%rip), %xmm0     # 0xa488
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %rcx
movl $0xc, %edx
movq %r15, %rdi
callq 0x630c
testb $0x3, %bl
sete %al
imull $0xc28f5c29, %ebx, %ecx # imm = 0xC28F5C29
addl $0x51eb850, %ecx        # imm = 0x51EB850
rorl $0x2, %ecx
cmpl $0x28f5c29, %ecx        # imm = 0x28F5C29
setae %cl
movq (%r15), %rdi
movq 0x8(%r15), %rdx
subq %rdi, %rdx
sarq $0x2, %rdx
testb %cl, %al
jne 0x5772
movslq %ebx, %rax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x27, %rax
addl %ecx, %eax
imull $0x190, %eax, %eax      # imm = 0x190
movl %ebx, %ecx
subl %eax, %ecx
jne 0x577f
cmpq $0x2, %rdx
jb 0x57ec
movl $0x1d, 0x4(%rdi)
movabsq $-0x100000000, %rsi     # imm = 0xFFFFFFFF00000000
addq %r14, %rsi
sarq $0x20, %rsi
cmpq %rsi, %rdx
jbe 0x57f1
movq %r14, %rax
shrq $0x20, %rax
xorl %ecx, %ecx
cmpl %r14d, (%rdi,%rsi,4)
setl %cl
movl %r14d, %edx
movl $0x1, %esi
cmovgeq %rdx, %rsi
addl %eax, %ecx
xorl %ebp, %ebp
cmpl $0xd, %ecx
setge %bpl
movl $0x1, %r14d
cmovll %ecx, %r14d
addl %ebx, %ebp
shlq $0x20, %r14
orq %rsi, %r14
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2150
movq %r14, %rax
movl %ebp, %edx
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %esi
leaq 0x4a3f(%rip), %rdi      # 0xa237
xorl %eax, %eax
callq 0x21c0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x5819
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O3/pc260533[P]ITC313-TP1/date.cpp
// Function: Date::jourProchain()
void Date::jourProchain() {
    std::vector<int> listeJourDesMois({31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31});
    if (((this->annee % 4 == 0) && (this->annee % 100 != 0)) || (this->annee % 400 == 0)) {
        listeJourDesMois.at(1) = 29;
    }
    this->jour++;
    if (this->jour > listeJourDesMois.at(this->mois - 1)) {
        this->mois++;
        this->jour = 1;
    }
    if (this->mois > 12) {
        this->annee++;
        this->mois = 1;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movups 0x4c3d(%rip), %xmm0     # 0xa4a8
leaq 0x20(%rsp), %rsi
movaps %xmm0, 0x20(%rsi)
movups 0x4c1d(%rip), %xmm0     # 0xa498
movaps %xmm0, 0x10(%rsi)
movups 0x4c02(%rip), %xmm0     # 0xa488
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rcx
movl $0xc, %edx
movq %r14, %rdi
callq 0x630c
movl 0x8(%rbx), %ecx
testb $0x3, %cl
sete %al
imull $0xc28f5c29, %ecx, %esi # imm = 0xC28F5C29
addl $0x51eb850, %esi        # imm = 0x51EB850
movl %esi, %ecx
rorl $0x2, %ecx
cmpl $0x28f5c29, %ecx        # imm = 0x28F5C29
setae %cl
rorl $0x4, %esi
movq (%r14), %rdi
movq 0x8(%r14), %rdx
subq %rdi, %rdx
sarq $0x2, %rdx
cmpl $0xa3d70b, %esi         # imm = 0xA3D70B
jb 0x58e0
andb %cl, %al
je 0x58ed
cmpq $0x2, %rdx
jb 0x5939
movl $0x1d, 0x4(%rdi)
movl (%rbx), %ecx
movl 0x4(%rbx), %eax
leal 0x1(%rcx), %esi
movl %esi, (%rbx)
movslq %eax, %r8
leaq -0x1(%r8), %rsi
cmpq %rsi, %rdx
jbe 0x593e
cmpl -0x4(%rdi,%r8,4), %ecx
jl 0x5915
incl %eax
movl %eax, 0x4(%rbx)
movl $0x1, (%rbx)
cmpl $0xd, %eax
jl 0x5924
incl 0x8(%rbx)
movl $0x1, 0x4(%rbx)
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2150
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %esi
leaq 0x48f2(%rip), %rdi      # 0xa237
xorl %eax, %eax
callq 0x21c0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x5966
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/pc260533[P]ITC313-TP1/chambre.cpp
// Function: Chambre::getTypeDeChambreToString[abi:cxx11](TypeDeChambre)
std::string Chambre::getTypeDeChambreToString(TypeDeChambre typeDeChambre) {
    std::string res = "";
    switch (typeDeChambre) {
        case TypeDeChambre::Simple:
            res = "Simple";
            break;
        case TypeDeChambre::Double:
            res = "Double";
            break;
        case TypeDeChambre::Suite:
            res = "Suite";
            break;
    }
    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x39db(%rip), %rdx      # 0xa4fb
movq %rdx, %rsi
callq 0x492e
cmpl $0x3, %ebp
jae 0x6b56
movl %ebp, %eax
leaq 0x3a2a(%rip), %rdx      # 0xa560
movslq (%rdx,%rax,4), %rcx
addq %rdx, %rcx
leaq 0x3a2c(%rip), %rdx      # 0xa570
movq (%rdx,%rax,8), %r8
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x21e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x6b7a
movq (%r15), %rsi
incq %rsi
callq 0x2150
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/pc260533[P]ITC313-TP1/chambre.cpp
// Function: Chambre::getListeTypesDeChambre[abi:cxx11]()
std::vector<std::string> Chambre::getListeTypesDeChambre() {
    std::vector<std::string> listeTypesDeChambre;
    listeTypesDeChambre.push_back(this->getTypeDeChambreToString(TypeDeChambre::Simple));
    listeTypesDeChambre.push_back(this->getTypeDeChambreToString(TypeDeChambre::Double));
    listeTypesDeChambre.push_back(this->getTypeDeChambreToString(TypeDeChambre::Suite));
    return listeTypesDeChambre;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rsp, %rdi
xorl %edx, %edx
callq 0x6b06
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x772a
leaq 0x10(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x6be8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rsp, %rdi
movl $0x1, %edx
callq 0x6b06
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x772a
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6c16
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rsp, %rdi
movl $0x2, %edx
callq 0x6b06
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x772a
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6c44
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x6c55
jmp 0x6c85
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
jne 0x6c76
jmp 0x6c88
jmp 0x6c85
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6c88
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2150
jmp 0x6c88
movq %rax, %r14
movq %rbx, %rdi
callq 0x41fe
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/pc260533[P]ITC313-TP1/chambre.cpp
// Function: Chambre::getTypeDeChambreAvecString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
TypeDeChambre Chambre::getTypeDeChambreAvecString(std::string typeDeChambre) {
    TypeDeChambre res = TypeDeChambre::Simple;
    if (typeDeChambre == "Simple") {
        res = TypeDeChambre::Simple;
    }
    else if (typeDeChambre == "Double") {
        res = TypeDeChambre::Double;
    }
    else if (typeDeChambre == "Suite") {
        res = TypeDeChambre::Suite;
    }
    return res;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
leaq 0x3828(%rip), %rsi      # 0xa4cb
movq %rbx, %rdi
callq 0x2060
testl %eax, %eax
je 0x6cde
leaq 0x381c(%rip), %rsi      # 0xa4d2
movq %rbx, %rdi
callq 0x2060
testl %eax, %eax
je 0x6ce2
leaq 0x3810(%rip), %rsi      # 0xa4d9
movq %rbx, %rdi
callq 0x2060
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
addl %eax, %eax
jmp 0x6ce7
xorl %eax, %eax
jmp 0x6ce7
movl $0x1, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pc260533[P]ITC313-TP1/hotel.cpp
// Function: Hotel::reservePremiereChambreDeCeType(TypeDeChambre)
Chambre Hotel::reservePremiereChambreDeCeType(TypeDeChambre typeDeChambre) {
    Chambre res;
    bool quit = false;
    int i = 0;
    while (!quit) {
        if (i > this->listeChambresHotel.size()) {
            quit = true;
        }
        else {
            if ((!this->listeChambresHotel.at(i).getEstReserve()) && (this->listeChambresHotel.at(i).getTypeDeChambre() == typeDeChambre)) {
                this->listeChambresHotel.at(i).setEstReserve(true);
                res = this->listeChambresHotel.at(i);
                quit = true;
            }
        }
        i++;
    }
    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x6b82
movq 0x60(%r15), %rdi
movq 0x68(%r15), %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r13, %rdx
xorl %r12d, %r12d
xorl %r14d, %r14d
cmpq %r14, %rdx
jbe 0x7d34
addq %r12, %rdi
callq 0x6afc
testb %al, %al
jne 0x7cb0
movq 0x60(%r15), %rdi
movq 0x68(%r15), %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
imulq %r13, %rdx
cmpq %r14, %rdx
jbe 0x7d34
addq %r12, %rdi
callq 0x6ae8
cmpl %ebp, %eax
je 0x7cd5
leaq 0x1(%r14), %rax
movq 0x60(%r15), %rdi
movq 0x68(%r15), %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
imulq %r13, %rdx
addq $0x18, %r12
cmpq %r14, %rdx
movq %rax, %r14
ja 0x7c73
jmp 0x7d22
movq 0x60(%r15), %rdi
movq 0x68(%r15), %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
imulq %r13, %rdx
cmpq %r14, %rdx
jbe 0x7d34
addq %r12, %rdi
movl $0x1, %esi
callq 0x6b00
movq 0x60(%r15), %rax
movq 0x68(%r15), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %r13, %rdx
cmpq %r14, %rdx
jbe 0x7d34
movb 0x10(%rax,%r12), %cl
movb %cl, 0x10(%rbx)
movups (%rax,%r12), %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x24fc(%rip), %rdi      # 0xa237
movq %r14, %rsi
xorl %eax, %eax
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/pc260533[P]ITC313-TP1/reservation.cpp
// Function: Reservation::setPeriodeDeReservation(Date, Date)
bool Reservation::setPeriodeDeReservation(Date dateDebut, Date dateFin) {
    bool res = false;
    if (dateDebut.estAvantDate(dateFin)) {
        res = true;
        this->dateDebutReservation = dateDebut;
        this->dateFinReservation = dateFin;
    }
    this->calculMontantTotal();
    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r14d
movq %rcx, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movq %rsi, (%rdi)
movl %edx, 0x8(%rdi)
movq %rcx, %rsi
movl %r8d, %edx
callq 0x5988
movl %eax, %ebp
testb %al, %al
je 0x8a67
movl 0x10(%rsp), %eax
movl %eax, 0xc(%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x4(%rbx)
movq %r15, 0x10(%rbx)
movl %r14d, 0x18(%rbx)
leaq 0x98(%rbx), %rdi
callq 0x6af0
movsd %xmm0, (%rsp)
leaq 0x4(%rbx), %rdi
movq 0x10(%rbx), %rsi
movl 0x18(%rbx), %edx
callq 0x5a02
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd (%rsp), %xmm0
movsd %xmm0, 0x118(%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/roornelas[P]small-world/./search.hpp
// Function: searchRW(Graph*, std::pair<int, int>, std::pair<int, int>)
int searchRW (Graph* g, pair<int, int> start, pair<int, int> end) {
  int i1 = start.first;
  int j1 = start.second;
  int i2 = end.first;
  int j2 = end.second;

  int length = 0;

  Node* curr = g->find_node(i1, j1);
  Node* target = g->find_node(i2, j2);

  while (curr != target) {
    length++;
    int r = rand() % curr->friends.size();
    set<pair<int, int>>::iterator it(curr->friends.begin());
    advance(it, r);
    curr = g->find_node(*it);
  }
  return length;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %rax
movq 0x8(%rdi), %rcx
leaq (%rax,%rax,2), %rax
sarq $0x20, %rsi
movq (%rcx,%rax,8), %rax
movslq %edx, %rdi
leaq (%rdi,%rdi,2), %rdi
sarq $0x20, %rdx
movq (%rcx,%rdi,8), %rcx
movq (%rcx,%rdx,8), %r15
movq (%rax,%rsi,8), %r12
xorl %r14d, %r14d
cmpq %r15, %r12
je 0x28cc
callq 0x2060
cltq
xorl %edx, %edx
divq 0x30(%r12)
movq 0x20(%r12), %rax
movslq %edx, %r12
testl %r12d, %r12d
jle 0x289d
movq %rax, %rdi
callq 0x2190
decq %r12
jne 0x288e
jmp 0x28ac
je 0x28ac
movq %rax, %rdi
callq 0x20c0
incq %r12
jne 0x289f
incl %r14d
movq 0x20(%rax), %rax
movslq %eax, %rcx
movq 0x8(%rbx), %rdx
leaq (%rcx,%rcx,2), %rcx
sarq $0x20, %rax
movq (%rdx,%rcx,8), %rcx
movq (%rcx,%rax,8), %r12
jmp 0x286e
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/roornelas[P]small-world/./search.hpp
// Function: searchGreedy(Graph*, std::pair<int, int>, std::pair<int, int>)
int searchGreedy (Graph* g, pair<int, int> start, pair<int, int> end) {
  int i1 = start.first;
  int j1 = start.second;
  int i2 = end.first;
  int j2 = end.second;

  int length = 0;

  Node* curr = g->find_node(i1, j1);
  Node* target = g->find_node(i2, j2);

  while (curr != target) {
    length++;
    int mindist = std::numeric_limits<int>::max();
    Node* temp;
    for (pair<int, int> f : curr->friends) {
      int tempdist = Graph::lattice_distance(f, end);
      if (tempdist < mindist) {
        mindist = tempdist;
        temp = g->find_node(f.first, f.second);
      }
    }
    curr = temp;
  }
  return length;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movslq %esi, %rax
movq 0x8(%rdi), %r14
leaq (%rax,%rax,2), %rax
sarq $0x20, %rsi
movq (%r14,%rax,8), %rax
movq (%rax,%rsi,8), %r12
movslq %ebx, %rax
leaq (%rax,%rax,2), %rax
movq %rdx, %rcx
sarq $0x20, %rcx
movq (%r14,%rax,8), %rax
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq %rax, %r12
je 0x2998
movq %rbx, %r13
shrq $0x20, %r13
xorl %eax, %eax
movl %eax, 0xc(%rsp)
movq 0x20(%r12), %rax
movq %r12, %r15
addq $0x10, %r15
cmpq %r15, %rax
je 0x2989
movl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
movslq 0x20(%rax), %rcx
movslq 0x24(%rax), %rdx
movl %ebx, %esi
subl %ecx, %esi
movl %esi, %edi
negl %edi
cmovsl %esi, %edi
movl %r13d, %r8d
subl %edx, %r8d
movl %r8d, %esi
negl %esi
cmovsl %r8d, %esi
addl %edi, %esi
cmpl %ebp, %esi
jge 0x297c
leaq (%rcx,%rcx,2), %rcx
movq (%r14,%rcx,8), %rcx
movq (%rcx,%rdx,8), %r12
movl %esi, %ebp
movq %rax, %rdi
callq 0x2190
cmpq %r15, %rax
jne 0x2946
movl 0xc(%rsp), %eax
incl %eax
cmpq 0x10(%rsp), %r12
jne 0x292c
jmp 0x299a
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/roornelas[P]small-world/./graph.hpp
// Function: Graph::Graph(int)
Graph(int side_length): side_length(side_length) {
		matrix.resize(side_length, vector<Node*>(side_length, nullptr ));
		for (int i = 0; i < side_length; i++) {
			for (int j = 0; j < side_length; j++) {
				matrix[i][j] = new Node(i, j);
			}
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebp
movl %esi, (%rdi)
leaq 0x8(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movslq %esi, %r14
leaq 0x30(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movq %r14, %rsi
callq 0x3362
leaq 0x18(%rsp), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x3320
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2eb9
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
testl %ebp, %ebp
jle 0x2f31
movl %ebp, %r14d
xorl %r15d, %r15d
xorl %r13d, %r13d
leaq (,%r13,2), %rbp
addq %r13, %rbp
movq %r13, 0x10(%rsp)
xorl %ebx, %ebx
movl $0x38, %edi
callq 0x2150
movq %r13, (%rax)
movq %rax, %rcx
addq $0x10, %rcx
movl $0x0, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rcx, 0x28(%rax)
movq %r15, 0x30(%rax)
movq (%r12), %rcx
movq (%rcx,%rbp,8), %rcx
movq %rax, (%rcx,%rbx,8)
incq %rbx
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %r13
cmpq %rbx, %r14
jne 0x2ed8
movq 0x10(%rsp), %r13
incq %r13
cmpq %r14, %r13
jne 0x2ec6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2f61
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
jmp 0x2f61
jmp 0x2f5e
movq %rax, %r14
movq %r12, %rdi
callq 0x3490
movq %r14, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O3/roornelas[P]small-world/./graph.hpp
// Function: Graph::set_p(int)
void set_p(int p) {
		for (int i = 0; i < side_length; i++) {
			for (int j = 0; j < side_length; j++) {
				for (int k = -p; k <= p; k++) {
					for (int l = -p; l <= p; l++) {
						if (abs(k) + abs(l) <= p && i + k >= 0 && i + k < side_length && j + l >= 0 && j + l < side_length && (k != 0 || l != 0)) {
							add_edge(make_pair(make_pair(i, j), make_pair(i + k, j + l)));
						}
					}
				}
			}
		}
	}

// Assembly:
movl (%rdi), %eax
testl %eax, %eax
jle 0x309b
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebp
movl %esi, %ecx
negl %ecx
movl %ecx, 0xc(%rsp)
leal 0x1(,%rbp,2), %ecx
movl %ecx, 0x1c(%rsp)
movq $0x0, 0x10(%rsp)
movq %rdi, 0x20(%rsp)
testl %eax, %eax
jle 0x3074
xorl %ebx, %ebx
testl %ebp, %ebp
js 0x3065
movl 0xc(%rsp), %eax
movl %eax, %edx
movl %edx, %r15d
negl %r15d
cmovsl %edx, %r15d
movq 0x10(%rsp), %rax
leal (%rdx,%rax), %r13d
movl 0x1c(%rsp), %r12d
movl 0xc(%rsp), %r14d
movq %rdx, 0x28(%rsp)
movl %r14d, %eax
negl %eax
cmovsl %r14d, %eax
addl %r15d, %eax
cmpl %ebp, %eax
jg 0x304e
testl %r13d, %r13d
js 0x304e
movl (%rdi), %ecx
cmpl %ecx, %r13d
jge 0x304e
movl %r14d, %eax
orl %edx, %eax
je 0x304e
movl %ebx, %eax
addl %r14d, %eax
js 0x304e
cmpl %ecx, %eax
jge 0x304e
shlq $0x20, %rax
orq %r13, %rax
movq 0x8(%rdi), %rcx
movq 0x10(%rsp), %rdx
leaq (%rdx,%rdx,2), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rcx,%rbx,8), %rdi
movq %rax, 0x30(%rsp)
addq $0x8, %rdi
leaq 0x30(%rsp), %rsi
callq 0x3b92
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rdi
incl %r14d
decl %r12d
jne 0x2fe7
leal 0x1(%rdx), %eax
cmpl %ebp, %edx
movl %eax, %edx
jne 0x2fc5
movl (%rdi), %eax
incq %rbx
movslq %eax, %rcx
cmpq %rcx, %rbx
jl 0x2fb7
movq 0x10(%rsp), %rsi
incq %rsi
movslq %eax, %rcx
movq %rsi, 0x10(%rsp)
cmpq %rcx, %rsi
jl 0x2fad
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/roornelas[P]small-world/./graph.hpp
// Function: Graph::set_q_r(int, int)
void set_q_r(int q, int r) {
		srand(time(NULL));
		for (int i = 0; i < side_length; i++) {
			for (int j = 0; j < side_length; j++) {
				add_long_edges(make_pair(i, j), q, r);
			}
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
xorl %edi, %edi
callq 0x2130
movl %eax, %edi
callq 0x2140
movl (%r14), %eax
testl %eax, %eax
jle 0x310c
xorl %r15d, %r15d
movabsq $0x100000000, %r13      # imm = 0x100000000
testl %eax, %eax
movq %r15, (%rsp)
jle 0x30fd
xorl %r12d, %r12d
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x3cd2
incq %r12
movl (%r14), %eax
movslq %eax, %rcx
addq %r13, %r15
cmpq %rcx, %r12
jl 0x30db
jmp 0x3100
movslq %eax, %rcx
movq (%rsp), %r15
incq %r15
cmpq %rcx, %r15
jl 0x30d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/roornelas[P]small-world/./graph.hpp
// Function: Graph::~Graph()
~Graph() {
		for (int i = 0; i < side_length; i++) {
			for (int j = 0; j < side_length; j++) {
				if (matrix[i][j]) {
					delete(matrix[i][j]);
				}
			}
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
testl %eax, %eax
jle 0x317b
xorl %r15d, %r15d
testl %eax, %eax
jle 0x3170
leaq (%r15,%r15,2), %r12
xorl %r13d, %r13d
movq 0x8(%rbx), %rcx
movq (%rcx,%r12,8), %rcx
movq (%rcx,%r13,8), %r14
testq %r14, %r14
je 0x3165
leaq 0x8(%r14), %rdi
callq 0x40bc
movl $0x38, %esi
movq %r14, %rdi
callq 0x2160
movl (%rbx), %eax
incq %r13
movslq %eax, %rcx
cmpq %rcx, %r13
jl 0x313c
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0x3131
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3490
// File: /workspace/github_cpp_makefile_star2_O3/liujan[P]MPI_multi_thread_randomforest/Tree.cpp
// Function: Tree::readSample(std::vector<std::pair<int, std::vector<double, std::allocator<double>>>, std::allocator<std::pair<int, std::vector<double, std::allocator<double>>>>>)
bool Tree::readSample(vector<pair<int, vector<double> > > all_samples){
	if (all_samples.empty()){
		cout << "[Error] all sample is empty!" << endl;
		return false;
	}

	if (root == NULL)
		root = new Node();

	double p = 0.0;
	for (int i = 0; i < all_samples.size(); i++){
		p = rand() * 1.0 / RAND_MAX;
		if (p <= 0.6) {  //ÿ��������������60%��ѵ��
			root->samples.push_back(all_samples[i]);
			int type = all_samples[i].first;
			root->num[type - 1]++;
		}
	}
	root->sum = root->samples.size();

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rsi), %r12
movq 0x8(%rsi), %r13
cmpq %r13, %r12
je 0x2d44
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
movq %r12, %rax
movq %r13, %rcx
testq %r15, %r15
jne 0x2cb0
movl $0xa8, %edi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
callq 0x25dc
movq %r15, (%rbx)
movq (%r14), %rax
movq 0x8(%r14), %rcx
cmpq %rax, %rcx
je 0x2d2c
movq %r13, -0x30(%rbp)
movq %r12, -0x38(%rbp)
xorl %r15d, %r15d
movl $0x90, %r12d
xorl %r13d, %r13d
callq 0x2090
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x432b(%rip), %xmm0     # 0x7008
movsd 0x432b(%rip), %xmm1     # 0x7010
ucomisd %xmm0, %xmm1
movq (%r14), %rsi
jb 0x2d0a
movq (%rbx), %rdi
addq %r12, %rdi
addq %r15, %rsi
callq 0x3a90
movq (%r14), %rsi
movslq (%rsi,%r15), %rax
movq (%rbx), %rcx
incl 0x20(%rcx,%rax,4)
incq %r13
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x5, %rax
addq $0x20, %r15
cmpq %r13, %rax
ja 0x2cc9
movq (%rbx), %r15
movq -0x38(%rbp), %r12
movq -0x30(%rbp), %r13
movq 0x98(%r15), %rax
subq 0x90(%r15), %rax
shrq $0x5, %rax
movl %eax, 0x20(%r15)
jmp 0x2d86
movq 0x7285(%rip), %rbx      # 0x9fd0
leaq 0x430e(%rip), %rsi      # 0x7060
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x2240
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2150
cmpq %r13, %r12
setne %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0xa8, %esi
movq %r15, %rdi
callq 0x2200
movq %rbx, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O3/liujan[P]MPI_multi_thread_randomforest/Tree.cpp
// Function: getType(Node*)
int getType(Node *node){
	if (node == NULL)
		return 0;
	int max_value = -1000, index = 0;
	for (int i = 0; i < numOfTypes; i++){
		if (max_value <= node->num[i]){
			max_value = node->num[i];
			index = i + 1;
		}
	}
	return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x3741
movl $0xfffffc18, %ecx       # imm = 0xFFFFFC18
xorl %edx, %edx
xorl %eax, %eax
movl 0x24(%rdi,%rdx,4), %esi
incq %rdx
cmpl %esi, %ecx
cmovlel %esi, %ecx
cmovlel %edx, %eax
cmpq $0x1a, %rdx
jne 0x372a
jmp 0x3743
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/liujan[P]MPI_multi_thread_randomforest/Tree.cpp
// Function: Tree::predict(std::vector<double, std::allocator<double>>)
int Tree::predict(vector<double> features){
	if (root == NULL){
		cout << "[Error] empty tree" << endl;
		return 0;
	}
	Node *head = root;
	while (true) {
		if (head->left == NULL && head->right == NULL){
			return getType(head);
		}
		int attr = head->attribute;
		double value = head->value;
		if (features[attr] < value){
			if (head->left == NULL)
				return getType(head);
			else
				head = head->left;
		}
		else {
			if (head->right == NULL)
				return getType(head);
			else
				head = head->right;
		}
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x37be
movq %rax, %rcx
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x3780
movslq (%rcx), %rdx
movsd 0x8(%rcx), %xmm0
movq (%rsi), %rdi
ucomisd (%rdi,%rdx,8), %xmm0
ja 0x3754
movq 0x18(%rcx), %rax
testq %rax, %rax
jne 0x3754
jmp 0x3824
movq 0x18(%rcx), %rax
testq %rax, %rax
je 0x3804
movslq (%rcx), %rdx
movsd 0x8(%rcx), %xmm0
movq (%rsi), %rdi
ucomisd (%rdi,%rdx,8), %xmm0
jbe 0x3754
movl $0xfffffc18, %edx       # imm = 0xFFFFFC18
xorl %esi, %esi
xorl %eax, %eax
movl 0x24(%rcx,%rsi,4), %edi
incq %rsi
cmpl %edi, %edx
cmovlel %edi, %edx
cmovlel %esi, %eax
cmpq $0x1a, %rsi
jne 0x37a4
jmp 0x3842
movq 0x680b(%rip), %rbx      # 0x9fd0
leaq 0x38db(%rip), %rsi      # 0x70a7
movl $0x12, %edx
movq %rbx, %rdi
callq 0x2240
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2150
xorl %eax, %eax
jmp 0x3842
movl $0xfffffc18, %edx       # imm = 0xFFFFFC18
xorl %esi, %esi
xorl %eax, %eax
movl 0x24(%rcx,%rsi,4), %edi
incq %rsi
cmpl %edi, %edx
cmovlel %edi, %edx
cmovlel %esi, %eax
cmpq $0x1a, %rsi
jne 0x380d
jmp 0x3842
movl $0xfffffc18, %edx       # imm = 0xFFFFFC18
xorl %esi, %esi
xorl %eax, %eax
movl 0x24(%rcx,%rsi,4), %edi
incq %rsi
cmpl %edi, %edx
cmovlel %edi, %edx
cmovlel %esi, %eax
cmpq $0x1a, %rsi
jne 0x382d
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/liujan[P]MPI_multi_thread_randomforest/Tree.cpp
// Function: Tree::randomSelect()
vector<int> Tree::randomSelect(){
	vector<int> v;
	for (int i = 0; i < numOfFeatures; i++){
		double p = rand() * 1.0 / RAND_MAX;
		if (p <= 0.05)
			v.push_back(i);
	}
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq -0x14(%rbp), %r14
movl $0x0, (%r14)
callq 0x2090
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x3781(%rip), %xmm0     # 0x7008
movsd 0x37a9(%rip), %xmm1     # 0x7038
ucomisd %xmm0, %xmm1
jb 0x38b9
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x38ae
movl -0x14(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x38b9
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4ce4
movl -0x14(%rbp), %eax
leal 0x1(%rax), %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x268, %eax            # imm = 0x268
jl 0x3873
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x38ec
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2200
movq %r14, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O3/liujan[P]MPI_multi_thread_randomforest/Tree.cpp
// Function: Tree::~Tree()
Tree::~Tree(){
	Node *head = root;
	queue<Node*>q;
	q.push(head);
	while (!q.empty()){
		head = q.front();
		q.pop();
		if (head == NULL)
			continue;
		Node *left = head->left;
		Node *right = head->right;
		delete head;
		q.push(left);
		q.push(right);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq (%rdi), %rbx
movq %rbx, -0x28(%rbp)
xorps %xmm0, %xmm0
leaq -0x90(%rbp), %rdi
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
xorl %esi, %esi
callq 0x4076
movq -0x60(%rbp), %rax
movq -0x50(%rbp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x3950
movq %rbx, (%rax)
movq -0x60(%rbp), %rcx
addq $0x8, %rcx
movq %rcx, -0x60(%rbp)
jmp 0x3964
leaq -0x90(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x41fe
movq -0x60(%rbp), %rcx
movq -0x80(%rbp), %rax
cmpq %rax, %rcx
je 0x3a6d
leaq -0x90(%rbp), %rbx
leaq -0x38(%rbp), %r14
leaq -0x30(%rbp), %r15
movq (%rax), %r12
movq %r12, -0x28(%rbp)
movq -0x70(%rbp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x399a
addq $0x8, %rax
jmp 0x39cb
movq -0x78(%rbp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x2200
movq -0x68(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x68(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x78(%rbp)
leaq 0x200(%rax), %rcx
movq %rcx, -0x70(%rbp)
movq -0x28(%rbp), %r12
movq %rax, -0x80(%rbp)
testq %r12, %r12
je 0x3a63
movq 0x10(%r12), %rax
movq %rax, -0x38(%rbp)
movq 0x18(%r12), %rax
movq %rax, -0x30(%rbp)
leaq 0x90(%r12), %rdi
callq 0x2848
movl $0xa8, %esi
movq %r12, %rdi
callq 0x2200
movq -0x60(%rbp), %rax
movq -0x50(%rbp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x3a2a
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x60(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x60(%rbp)
jmp 0x3a39
movq %rbx, %rdi
movq %r14, %rsi
callq 0x41fe
movq -0x60(%rbp), %rax
movq -0x50(%rbp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x3a54
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
addq $0x8, -0x60(%rbp)
jmp 0x3a5f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x41fe
movq -0x80(%rbp), %rax
cmpq %rax, -0x60(%rbp)
jne 0x3980
leaq -0x90(%rbp), %rdi
callq 0x3cd4
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a88
movq %rax, %rdi
callq 0x28ab
// File: /workspace/github_cpp_makefile_star2_O3/liujan[P]MPI_multi_thread_randomforest/RandomForest.cpp
// Function: build(void*)
void* build(void *arg){
	M t1 = (M)(*((M*)arg));
	RandomForest *rf = t1.rf;
	int t = t1.i;
	if (rf->test_samples.empty()){
		cout << "[Error] test sample is empty" << endl;
		return NULL;
	}

	Tree *tree = new Tree();
	if (tree->readSample(rf->all_samples)){
		cout << t  << "  ";
		tree->buildTree();
		for (int j = 0; j < rf->test_samples.size(); j++){
			int id = rf->test_samples[j].first;
			int type = tree->predict(rf->test_samples[j].second);
			result[t][id][type]++;
		}
	}
	delete tree;
	
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq (%rdi), %r14
movq 0x18(%r14), %rax
cmpq 0x20(%r14), %rax
je 0x4f9a
movslq 0x8(%rdi), %r15
movl $0x8, %edi
callq 0x21f0
movq %rax, %rbx
movq %rax, %rdi
callq 0x2c1c
leaq -0x68(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3ad8
movq %rbx, -0x30(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2c5c
movl %eax, %r12d
leaq -0x68(%rbp), %rdi
callq 0x2848
testb %r12b, %r12b
je 0x4f7f
movq 0x50fe(%rip), %rdi      # 0x9fd0
movl %r15d, %esi
callq 0x2340
leaq 0x225c(%rip), %rsi      # 0x713d
movl $0x2, %edx
movq %rax, %rdi
callq 0x2240
movq -0x30(%rbp), %rdi
callq 0x2db4
movq 0x18(%r14), %rsi
cmpq %rsi, 0x20(%r14)
je 0x4f7f
movl $0x8, %r13d
xorl %ebx, %ebx
imulq $0x291b4, %r15, %rax    # imm = 0x291B4
leaq 0x52f9(%rip), %rcx      # 0xa210
addq %rax, %rcx
movq %rcx, -0x38(%rbp)
movslq -0x8(%rsi,%r13), %r12
addq %r13, %rsi
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x2a0c
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x3746
movl %eax, %r15d
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x4f56
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x2200
movslq %r15d, %rax
imulq $0x6c, %r12, %rcx
addq -0x38(%rbp), %rcx
incl (%rcx,%rax,4)
incq %rbx
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rax
subq %rsi, %rax
sarq $0x5, %rax
addq $0x20, %r13
cmpq %rbx, %rax
ja 0x4f1e
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x38f4
movl $0x8, %esi
movq %rbx, %rdi
callq 0x2200
jmp 0x4fdc
movq 0x502f(%rip), %rbx      # 0x9fd0
leaq 0x2178(%rip), %rsi      # 0x7120
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x2240
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2150
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x2848
jmp 0x5020
movq %rax, %r14
movl $0x8, %esi
movq %rbx, %rdi
jmp 0x501b
movq %rax, %r14
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x5020
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x2200
movq %r14, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O3/liujan[P]MPI_multi_thread_randomforest/RandomForest.cpp
// Function: RandomForest::predict()
int** RandomForest::predict(){
	if (this->test_samples.empty()){
		cout << "[Error] test sample is empty" << endl;
		return NULL;
	}
	if (r == NULL){
		cout << "r is NULL" << endl;
		return NULL;
	}
	
	return r;
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rax
cmpq 0x20(%rdi), %rax
je 0x5226
movq 0x30(%rdi), %rax
testq %rax, %rax
jne 0x526e
movq 0x4db8(%rip), %rdi      # 0x9fd0
leaq 0x1f3d(%rip), %rsi      # 0x715c
movl $0x9, %edx
jmp 0x5239
movq 0x4da3(%rip), %rdi      # 0x9fd0
leaq 0x1eec(%rip), %rsi      # 0x7120
movl $0x1c, %edx
callq 0x2240
movq 0x4d8b(%rip), %rbx      # 0x9fd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2150
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Baobaobear[P]sort/./sortlib.hpp
// Function: void baobao::internal::merge_2_part<false, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, int*, std::less<int>>(int*, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, std::less<int>)
void merge_2_part(RandomAccessBufferIterator buf, RandomAccessIterator beg, RandomAccessIterator mid, RandomAccessIterator end, Comp compare)
{
    if (!compare(*mid, *(mid - 1)))
    {
        return;
    }
    while (beg < mid && !compare(*mid, *beg))
    {
        ++beg;
    }
    if (beg < mid)
    {
        RandomAccessIterator mid_last = mid - 1, last = end - 1;
        while (mid_last < last && !compare(*last, *mid_last))
        {
            --last;
        }
        if (mid_last == last)
        {
            return;
        }
        end = last + 1;
    }
    else
    {
        return;
    }

    if (end - beg < merge_2_part_insertion_sort_threshold)
    {
        insert_sort_part(beg, mid, end, compare);
        return;
    }

    merge_2_part_force<safecopy>(buf, beg, mid, end, compare);
}

// Assembly:
movq %rcx, %rax
movl -0x4(%rdx), %r8d
movl (%rdx), %ecx
cmpl %r8d, %ecx
setl %r9b
cmpq %rdx, %rsi
setb %r10b
andb %r9b, %r10b
cmpb $0x1, %r10b
jne 0xf271
movq %rax, %r9
subq %rsi, %r9
cmpl (%rsi), %ecx
jl 0xf21e
addq $0x4, %rsi
addq $-0x4, %r9
cmpq %rdx, %rsi
jb 0xf1fd
jmp 0xf271
leaq -0x4(%rcx), %rax
leaq -0x4(%r10), %r9
cmpl %r8d, -0x4(%rcx)
jl 0xf229
movq %rax, %rcx
movq %r9, %r10
cmpq %rdx, %rax
ja 0xf210
cmpq %rdx, %rcx
je 0xf271
cmpq $0x7f, %r10
jg 0xf272
cmpq %rdx, %rcx
jbe 0xf271
movl -0x4(%rdx), %r8d
movl (%rdx), %eax
cmpl %r8d, %eax
jge 0xf268
leaq -0x4(%rdx), %rdi
movl %r8d, (%rdx)
cmpq %rdi, %rsi
je 0xf266
movl -0x4(%rdi), %r8d
cmpl %r8d, %eax
jge 0xf266
movl %r8d, (%rdi)
addq $-0x4, %rdi
jmp 0xf24f
movl %eax, (%rdi)
addq $0x4, %rdx
cmpq %rcx, %rdx
jb 0xf23d
retq
// File: /workspace/github_cpp_makefile_star2_O3/AgathokakologicalBit[P]wit/src/main.cpp
// Function: (anonymous namespace)::draw_p(unsigned int, unsigned long)
void draw_p(std::uint32_t depth, std::uint64_t mask)
  {
    if (depth == ~(static_cast<std::uint32_t>(0)))
      return;

    std::wcout << L"\x1b[32m";
    for (std::uint32_t i = 0; i < depth; ++i)
    {
      if (mask & (static_cast<std::uint64_t>(1) << i))
        std::cout << "\x20\x20\x20";
      else
        std::cout << "\u2502\x20\x20";
    }

    if (mask & (static_cast<std::uint64_t>(1) << depth))
      std::cout << "\u2514\u2500 ";
    else
      std::cout << "\u251C\u2500 ";

    std::wcout << L"\x1b[37m";
  }

// Assembly:
cmpl $-0x1, %edi
je 0x4d07
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movq 0x1831d(%rip), %rdi     # 0x1cfc8
leaq 0x105fe(%rip), %rsi     # 0x152b0
movl $0x5, %edx
callq 0x30f0
testl %ebp, %ebp
je 0x4d08
movl %ebp, %r13d
xorl %ebp, %ebp
movq 0x182f4(%rip), %r14     # 0x1cfc0
leaq 0x103fc(%rip), %r15     # 0x150cf
leaq 0x103f1(%rip), %r12     # 0x150cb
btq %rbp, %rbx
jae 0x4ced
movl $0x3, %edx
movq %r14, %rdi
movq %r12, %rsi
jmp 0x4cf8
movl $0x5, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3240
incq %rbp
cmpq %rbp, %r13
jne 0x4cda
jmp 0x4d0b
retq
xorl %r13d, %r13d
btq %r13, %rbx
leaq 0x103c7(%rip), %rax     # 0x150dd
leaq 0x103b8(%rip), %rsi     # 0x150d5
cmovaeq %rax, %rsi
movq 0x18298(%rip), %rdi     # 0x1cfc0
movl $0x7, %edx
callq 0x3240
movq 0x1828f(%rip), %rdi     # 0x1cfc8
leaq 0x10588(%rip), %rsi     # 0x152c8
movl $0x5, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x30f0