LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/gfa_ut.cpp
// Function: usg_arc_occ(usg_t*, unsigned int, unsigned int*)
inline uint32_t usg_arc_occ(usg_t *g, uint32_t v, uint32_t *res)
{
    uint32_t i, kv, nv = usg_arc_n(g, v);; 
    usg_arc_t *av = usg_arc_a(g, v);
    for (i = kv = 0; i < nv; i++) {
        if(av[i].del) continue;
        if(res) res[kv] = av[i].v;
        kv++;
    }
    return kv;
}

// Assembly:
movl %esi, %eax
shrl %eax
andl $0x1, %esi
imulq $0x78, %rax, %rax
addq (%rdi), %rax
imulq $0x18, %rsi, %rsi
movl 0x10(%rsi,%rax), %ecx
movq 0x20(%rsi,%rax), %rsi
shlq $0x5, %rcx
xorl %edi, %edi
xorl %eax, %eax
cmpq %rdi, %rcx
je 0x1df1f3
cmpl $0x0, 0xc(%rsi,%rdi)
js 0x1df1ed
testq %rdx, %rdx
je 0x1df1eb
movl 0x8(%rsi,%rdi), %r8d
movl %eax, %r9d
movl %r8d, (%rdx,%r9,4)
incl %eax
addq $0x20, %rdi
jmp 0x1df1ce
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/gfa_ut.cpp
// Function: dup_paf_check(ma_hit_t_alloc*, ma_hit_t*)
inline uint64_t dup_paf_check(ma_hit_t_alloc *x, ma_hit_t *p)
{
    int64_t i; ma_hit_t *z;
    for (i = 0; i < x->length; i++) {
        z = &(x->buffer[i]);
        if((z->qns == p->qns) && (z->tn == p->tn) && (z->qe == p->qe) && (z->ts == p->ts) && (z->te == p->te) && 
            (z->cc == p->cc) && (z->ml == p->ml) && (z->rev == p->rev) && (z->bl == p->bl) && (z->del == p->del) && 
            (z->el == p->el) && (z->no_l_indel == p->no_l_indel)) {
            return 0;
        }    
    }
    return 1;
}

// Assembly:
movl 0xc(%rdi), %ecx
pushq $0x21
popq %rdx
xorl %r8d, %r8d
pushq $0x1
popq %rax
cmpq %rcx, %r8
jae 0x1df269
movq (%rdi), %r9
movq -0x21(%r9,%rdx), %r10
cmpq (%rsi), %r10
jne 0x1df25e
movl -0x15(%r9,%rdx), %r10d
cmpl 0xc(%rsi), %r10d
jne 0x1df25e
movl -0x19(%r9,%rdx), %r10d
cmpl 0x8(%rsi), %r10d
jne 0x1df25e
movl -0x11(%r9,%rdx), %r10d
cmpl 0x10(%rsi), %r10d
jne 0x1df25e
movl -0xd(%r9,%rdx), %r10d
cmpl 0x14(%rsi), %r10d
jne 0x1df25e
movq -0x9(%r9,%rdx), %r10
cmpq 0x18(%rsi), %r10
jne 0x1df25e
movb -0x1(%r9,%rdx), %r10b
cmpb 0x20(%rsi), %r10b
jne 0x1df25e
movb (%r9,%rdx), %r9b
cmpb 0x21(%rsi), %r9b
je 0x1df267
incq %r8
addq $0x28, %rdx
jmp 0x1df200
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/gfa_ut.cpp
// Function: asg_arc_del_by_ug(asg_t*, ma_ug_t*, unsigned int, unsigned int, unsigned int)
inline void asg_arc_del_by_ug(asg_t *sg, ma_ug_t *ug, uint32_t uv, uint32_t uw, uint32_t del)
{
    uint32_t rv, rw, i, nv; asg_arc_t *av;
    if(uv&1) rv = ug->u.a[uv>>1].start^1;
    else rv = ug->u.a[uv>>1].end^1;

    if(uw&1) rw = ug->u.a[uw>>1].end;
    else rw = ug->u.a[uw>>1].start;

    av = asg_arc_a(sg, rv);
    nv = asg_arc_n(sg, rv);
    for (i = 0; i < nv; i++) {
        if(av[i].v == rw) break;
    }
    assert(i < nv);
    av[i].del = del;
}

// Assembly:
pushq %rax
xorl %eax, %eax
testb $0x1, %dl
sete %al
movq 0x10(%rsi), %rsi
shrl %edx
imulq $0x28, %rdx, %rdx
addq %rsi, %rdx
movl 0x4(%rdx,%rax,4), %edx
xorq $0x1, %rdx
movl %ecx, %eax
shrl %eax
imulq $0x28, %rax, %rax
addq %rsi, %rax
andl $0x1, %ecx
movl 0x4(%rax,%rcx,4), %ecx
movq 0x8(%rdi), %rax
movq 0x28(%rdi), %rsi
movq (%rsi,%rdx,8), %rdx
movl %edx, %esi
shrq $0x20, %rdx
imulq $0x18, %rdx, %rdx
leaq (%rdx,%rax), %rdi
addq $-0xc, %rdi
imulq $0x18, %rsi, %r9
addq $0x18, %r9
xorl %r10d, %r10d
leaq 0x18(%r10), %rsi
cmpq %rsi, %r9
je 0x1df2ef
cmpl %ecx, 0x14(%rdi,%r10)
movq %rsi, %r10
jne 0x1df2c3
addq %rax, %rdx
shll $0x1f, %r8d
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andl -0xc(%rsi,%rdx), %eax
orl %r8d, %eax
movl %eax, -0xc(%rsi,%rdx)
popq %rax
retq
leaq 0x8ea8(%rip), %rdi      # 0x1e819e
leaq 0x181dc(%rip), %rsi     # 0x1f74d9
leaq 0x1d519(%rip), %rcx     # 0x1fc81d
movl $0x45ce, %edx           # imm = 0x45CE
callq 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O2/huntzhan[P]SAM-PNG/solution.cc
// Function: AddSymbolToSAM(State*, State*, char)
State *AddSymbolToSAM(State *start, State *last, char c) {
  auto cur = new State;
  cur->set_maxlen(last->maxlen() + 1);
  cur->set_first_endpos(last->first_endpos() + 1);

  auto p = last;
  while (p && !p->has_trans(c)) {
    p->set_trans(c, cur);
    p = p->link();
  }

  if (p == nullptr) {
    cur->set_link(start);
    cur->set_minlen(1);
    return cur;
  }

  auto q = p->trans(c);
  if (p->maxlen() + 1 == q->maxlen()) {
    cur->set_link(q);
    cur->set_minlen(q->maxlen() + 1);
  } else {
    auto sq = new State;
    sq->set_maxlen(p->maxlen() + 1);
    sq->set_trans(q->trans());
    sq->set_first_endpos(q->first_endpos());
    
    while (p && p->has_trans(c) && p->trans(c) == q) {
      p->set_trans(c, sq);
      p = p->link();
    }

    sq->set_link(q->link());
    sq->set_minlen(sq->link()->maxlen() + 1);

    q->set_link(sq);
    q->set_minlen(sq->maxlen() + 1);

    cur->set_link(sq);
    cur->set_minlen(sq->maxlen() + 1);
  }

  return cur;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
pushq $0x58
popq %rdi
callq 0x2110
movq %rax, %rbx
movq %rax, %rdi
callq 0x2c3c
movl (%r14), %eax
incl %eax
movl %eax, (%rbx)
movl 0x8(%r14), %eax
incl %eax
movl %eax, 0x8(%rbx)
movsbl %bpl, %ebp
testq %r14, %r14
je 0x248f
movq %r14, %rdi
movl %ebp, %esi
callq 0x2c70
movq %r14, %rdi
movl %ebp, %esi
testb %al, %al
jne 0x249b
movq %rbx, %rdx
callq 0x2c8e
movq 0x10(%r14), %r14
jmp 0x2469
movq %r15, 0x10(%rbx)
pushq $0x1
popq %rax
jmp 0x255c
callq 0x2cb4
movq %rax, %r15
movl (%r14), %eax
leal 0x1(%rax), %ecx
cmpl (%r15), %ecx
jne 0x24ba
movq %r15, 0x10(%rbx)
addl $0x2, %eax
jmp 0x255c
pushq $0x58
popq %rdi
callq 0x2110
movq %rax, %r12
movq %rax, %rdi
callq 0x2c3c
movl (%r14), %eax
incl %eax
movl %eax, (%r12)
leaq 0x18(%r15), %rsi
movq %rsp, %r13
movq %r13, %rdi
callq 0x3480
leaq 0x18(%r12), %rdi
movq %r13, %rsi
callq 0x3196
movq %rsp, %rdi
callq 0x359a
movl 0x8(%r15), %eax
movl %eax, 0x8(%r12)
testq %r14, %r14
je 0x2538
movq %r14, %rdi
movl %ebp, %esi
callq 0x2c70
testb %al, %al
je 0x2538
movq %r14, %rdi
movl %ebp, %esi
callq 0x2cb4
cmpq %r15, %rax
jne 0x2538
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x2c8e
movq 0x10(%r14), %r14
jmp 0x2503
movq 0x10(%r15), %rax
movq %rax, 0x10(%r12)
movl (%rax), %eax
incl %eax
movl %eax, 0x4(%r12)
movq %r12, 0x10(%r15)
movl (%r12), %eax
incl %eax
movl %eax, 0x4(%r15)
movq %r12, 0x10(%rbx)
movl %eax, 0x4(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x359a
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x58
popq %rdi
callq 0x2110
movq %rax, %rbx
movq %rax, %rdi
callq 0x2c3c
movq (%r14), %r15
movq 0x8(%r14), %r14
xorl %r12d, %r12d
movq %rbx, %rax
cmpq %r12, %r14
je 0x25d1
movsbl (%r15,%r12), %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x242c
incq %r12
jmp 0x25af
movb $0x1, 0x50(%rax)
movq 0x10(%rax), %rax
cmpq %rbx, %rax
jne 0x25c9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rsp, %rsi
movq %rdi, (%rsi)
movq %r14, %rdi
callq 0x384a
testq %rax, %rax
jne 0x2659
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x38da
movq (%r15), %rsi
addq $0x18, %rsi
leaq 0x8(%rsp), %rdi
callq 0x3480
leaq 0x18(%rsp), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x2644
movq 0x10(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x25e5
jmp 0x262b
leaq 0x8(%rsp), %rdi
callq 0x359a
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2cce
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x359a
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x70, %rsp
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x5644(%rip), %rdi      # 0x8188
leaq 0x18(%rsp), %rsi
callq 0x2170
leaq 0x18(%rsp), %rdi
callq 0x2584
leaq 0x68(%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)
andq $0x0, 0x10(%rdx)
leaq 0x38(%rsp), %rsi
movq %rax, %rdi
callq 0x25e5
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x48a4
movq %rsp, %rdi
leaq 0x18(%rsp), %rsi
callq 0x2678
movq %rsp, %rdi
callq 0x4886
leaq 0x38(%rsp), %rdi
callq 0x370c
leaq 0x18(%rsp), %rdi
callq 0x2248
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
retq
jmp 0x2bd4
movq %rax, %rbx
jmp 0x2bee
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4886
leaq 0x38(%rsp), %rdi
callq 0x370c
leaq 0x18(%rsp), %rdi
callq 0x2248
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rsi), %r12
cmpq $0x0, (%r12)
je 0x2559
cmpq $0x0, 0x8(%r12)
jne 0x2584
leaq -0x68(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x2110
movq %r12, %rdi
movq %r13, %rsi
callq 0x28ee
movl %eax, %r12d
leaq -0x68(%rbp), %rdi
callq 0x2070
testb %r12b, %r12b
je 0x25d1
addq $0x20, %r15
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x2a20
movq (%r15), %rax
movl %r14d, %edi
callq *(%rax)
movq %rax, %r14
leaq -0x48(%rbp), %r15
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x2a20
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x29cc
leaq -0x40(%rbp), %rdi
callq 0x263a
leaq -0x30(%rbp), %rdi
callq 0x263a
jmp 0x25d7
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x2070
jmp 0x2611
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x263a
jmp 0x2608
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x263a
movq %rbx, %rdi
callq 0x2180
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x286e
callq 0x20a0
andq $0x0, 0x10(%rbx)
cmpq $0x0, (%rbx)
je 0x2878
andq $0x0, (%rbx)
cmpq $0x0, 0x8(%rbx)
je 0x2884
andq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rdi
pushq $0x1
popq %rsi
callq 0x2120
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x2941
callq 0x20d0
movq 0x10(%rbx), %rdi
leaq 0x75b(%rip), %rsi       # 0x3077
callq 0x20c0
movq %rax, (%rbx)
callq 0x20d0
testq %rax, %rax
je 0x2971
movq %rax, %r14
movq 0x26b8(%rip), %rdi      # 0x4ff0
leaq 0x73f(%rip), %rsi       # 0x307e
jmp 0x29a0
movq 0x26a8(%rip), %rdi      # 0x4ff0
leaq 0x70f(%rip), %rsi       # 0x305e
callq 0x20f0
movq %rax, %rbx
callq 0x20d0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x20f0
movq %rax, %rdi
callq 0x2080
jmp 0x29c0
movq 0x10(%rbx), %rdi
leaq 0x721(%rip), %rsi       # 0x309d
callq 0x20c0
movq %rax, 0x8(%rbx)
callq 0x20d0
testq %rax, %rax
je 0x29c7
movq %rax, %r14
movq 0x2657(%rip), %rdi      # 0x4ff0
leaq 0x705(%rip), %rsi       # 0x30a5
callq 0x20f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x20f0
movq %rax, %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2852
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, %al
jmp 0x29c2
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x50, %rsp
movl %edx, %ebx
movq %rsi, %r14
movups 0x30c2(%rip), %xmm0     # 0x7400
leaq 0x20(%rsp), %rsi
movaps %xmm0, 0x20(%rsi)
movups 0x30a2(%rip), %xmm0     # 0x73f0
movaps %xmm0, 0x10(%rsi)
movups 0x3087(%rip), %xmm0     # 0x73e0
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rdi
pushq $0xc
popq %rdx
leaq 0x7(%rsp), %rcx
callq 0x49b6
testb $0x3, %bl
sete %cl
pushq $0x64
popq %rsi
movl %ebx, %eax
cltd
idivl %esi
testl %edx, %edx
setne %sil
movl $0x190, %edi            # imm = 0x190
movl %ebx, %eax
cltd
idivl %edi
testb %sil, %cl
jne 0x4395
testl %edx, %edx
jne 0x43a8
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x49ec
movl $0x1d, (%rax)
movabsq $-0x100000000, %rsi     # imm = 0xFFFFFFFF00000000
addq %r14, %rsi
sarq $0x20, %rsi
leaq 0x8(%rsp), %rdi
callq 0x49ec
movq %r14, %rcx
shrq $0x20, %rcx
xorl %edx, %edx
cmpl %r14d, (%rax)
setl %dl
movl %r14d, %eax
pushq $0x1
popq %rsi
cmovgeq %rax, %rsi
addl %ecx, %edx
xorl %ebp, %ebp
cmpl $0xd, %edx
pushq $0x1
popq %r14
cmovll %edx, %r14d
setge %bpl
addl %ebx, %ebp
shlq $0x20, %r14
orq %rsi, %r14
leaq 0x8(%rsp), %rdi
callq 0x4c0e
movq %r14, %rax
movl %ebp, %edx
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4c0e
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2f91(%rip), %xmm0     # 0x7400
leaq 0x20(%rsp), %rsi
movaps %xmm0, 0x20(%rsi)
movups 0x2f71(%rip), %xmm0     # 0x73f0
movaps %xmm0, 0x10(%rsi)
movups 0x2f56(%rip), %xmm0     # 0x73e0
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rdi
pushq $0xc
popq %rdx
leaq 0x7(%rsp), %rcx
callq 0x49b6
movl 0x8(%rbx), %ecx
testb $0x3, %cl
sete %sil
pushq $0x64
popq %rdi
movl %ecx, %eax
cltd
idivl %edi
testl %edx, %edx
setne %dil
movl $0x190, %r8d            # imm = 0x190
movl %ecx, %eax
cltd
idivl %r8d
testl %edx, %edx
je 0x44cc
andb %dil, %sil
je 0x44df
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x49ec
movl $0x1d, (%rax)
movl (%rbx), %r14d
leal 0x1(%r14), %eax
movl %eax, (%rbx)
movslq 0x4(%rbx), %rsi
decq %rsi
leaq 0x8(%rsp), %rdi
callq 0x49ec
movl 0x4(%rbx), %ecx
cmpl (%rax), %r14d
jl 0x450c
incl %ecx
movl %ecx, 0x4(%rbx)
movl $0x1, (%rbx)
cmpl $0xd, %ecx
jl 0x451b
incl 0x8(%rbx)
movl $0x1, 0x4(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x4c0e
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4c0e
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x24d9(%rip), %rsi      # 0x7453
leaq 0xf(%rsp), %rdx
callq 0x30f4
cmpl $0x3, %ebp
jae 0x4fa1
movl %ebp, %eax
leaq 0x2522(%rip), %rcx      # 0x74b4
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
callq 0x2260
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
callq 0x4f66
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5530
leaq 0x8(%rsp), %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rdx
callq 0x4f66
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5530
leaq 0x8(%rsp), %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
pushq $0x2
popq %rdx
callq 0x4f66
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5530
leaq 0x8(%rsp), %rdi
callq 0x20b0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x506f
jmp 0x507e
jmp 0x506f
jmp 0x507e
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x20b0
jmp 0x5081
movq %rax, %r14
movq %rbx, %rdi
callq 0x32c6
movq %r14, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2386(%rip), %rsi      # 0x7423
movq %rbx, %rdi
callq 0x53b8
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0x50d9
leaq 0x2376(%rip), %rsi      # 0x742a
movq %rbx, %rdi
callq 0x53b8
testb %al, %al
je 0x50c5
pushq $0x1
popq %rax
jmp 0x50d9
leaq 0x2365(%rip), %rsi      # 0x7431
movq %rbx, %rdi
callq 0x53b8
movzbl %al, %eax
addl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pc260533[P]ITC313-TP1/chambre.cpp
// Function: Chambre::toString[abi:cxx11]()
std::string Chambre::toString() {
    return "L'id de la chambre est : " + std::to_string(this->identifiantChambre) + ".\n"
            + "Le type de la chambre est : " + this->getTypeDeChambreToString(this->typeDeChambre) + "\n"
            + "Le prix par nuit de la chambre est : " + std::to_string(this->prixParNuit) + "\n"
            + "La chambre est reserve : " + std::to_string(this->estReserve);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
leaq 0x180(%rsp), %r15
movq %r15, %rdi
callq 0x31b3
leaq 0x2330(%rip), %rsi      # 0x7437
leaq 0x60(%rsp), %rdi
movq %r15, %rdx
callq 0x318f
leaq 0x2336(%rip), %rdx      # 0x7451
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x4a74
leaq 0x2320(%rip), %rdx      # 0x7454
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x4a74
movl 0x4(%r14), %edx
leaq 0x40(%rsp), %rdi
callq 0x4f66
leaq 0xc0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x4a0d
leaq 0x22da(%rip), %rdx      # 0x7452
leaq 0xe0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x4a74
leaq 0x22dd(%rip), %rdx      # 0x7471
leaq 0x100(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x4a74
movsd 0x8(%r14), %xmm0
leaq 0x20(%rsp), %rdi
callq 0x53c5
leaq 0x120(%rsp), %rdi
leaq 0x100(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x4a0d
leaq 0x2278(%rip), %rdx      # 0x7452
leaq 0x140(%rsp), %rdi
leaq 0x120(%rsp), %rsi
callq 0x4a74
leaq 0x22a1(%rip), %rdx      # 0x7497
leaq 0x160(%rsp), %rdi
leaq 0x140(%rsp), %rsi
callq 0x4a74
movzbl 0x10(%r14), %esi
movq %rsp, %rdi
callq 0x31b3
leaq 0x160(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x4a0d
movq %rsp, %rdi
callq 0x20b0
leaq 0x160(%rsp), %rdi
callq 0x20b0
leaq 0x140(%rsp), %rdi
callq 0x20b0
leaq 0x120(%rsp), %rdi
callq 0x20b0
leaq 0x20(%rsp), %rdi
callq 0x20b0
leaq 0x100(%rsp), %rdi
callq 0x20b0
leaq 0xe0(%rsp), %rdi
callq 0x20b0
leaq 0xc0(%rsp), %rdi
callq 0x20b0
leaq 0x40(%rsp), %rdi
callq 0x20b0
leaq 0xa0(%rsp), %rdi
callq 0x20b0
leaq 0x80(%rsp), %rdi
callq 0x20b0
leaq 0x60(%rsp), %rdi
callq 0x20b0
leaq 0x180(%rsp), %rdi
callq 0x20b0
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20b0
jmp 0x52e6
movq %rax, %rbx
leaq 0x160(%rsp), %rdi
callq 0x20b0
jmp 0x52f8
movq %rax, %rbx
leaq 0x140(%rsp), %rdi
callq 0x20b0
jmp 0x530a
movq %rax, %rbx
leaq 0x120(%rsp), %rdi
callq 0x20b0
jmp 0x531c
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x20b0
leaq 0x100(%rsp), %rdi
callq 0x20b0
leaq 0xe0(%rsp), %rdi
callq 0x20b0
leaq 0xc0(%rsp), %rdi
callq 0x20b0
leaq 0x40(%rsp), %rdi
callq 0x20b0
leaq 0xa0(%rsp), %rdi
callq 0x20b0
leaq 0x80(%rsp), %rdi
callq 0x20b0
leaq 0x60(%rsp), %rdi
callq 0x20b0
leaq 0x180(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2230
movq %rax, %rbx
jmp 0x5326
movq %rax, %rbx
jmp 0x5333
movq %rax, %rbx
jmp 0x5340
movq %rax, %rbx
jmp 0x534d
movq %rax, %rbx
jmp 0x5357
movq %rax, %rbx
jmp 0x5364
movq %rax, %rbx
jmp 0x5371
movq %rax, %rbx
jmp 0x537b
// File: /workspace/github_cpp_makefile_star2_O2/pc260533[P]ITC313-TP1/hotel.cpp
// Function: Hotel::chambreDeCeTypeEstDisponible(TypeDeChambre)
bool Hotel::chambreDeCeTypeEstDisponible(TypeDeChambre typeDeChambre) {
    bool res = false;
    for (Chambre chambre : this->listeChambresHotel) {
        if ((!chambre.getEstReserve()) && (chambre.getTypeDeChambre() == typeDeChambre)) {
            res = true;
        }
    }
    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movq 0x60(%rdi), %r15
movq 0x68(%rdi), %r12
xorl %ebp, %ebp
movq %rsp, %r14
cmpq %r12, %r15
je 0x5873
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movaps %xmm0, (%rsp)
movq %r14, %rdi
callq 0x4f5c
testb %al, %al
jne 0x586d
movq %r14, %rdi
callq 0x4f48
cmpl %ebx, %eax
sete %al
orb %al, %bpl
addq $0x18, %r15
jmp 0x583b
andb $0x1, %bpl
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x4(%rsp)
movq %rsi, %r15
movq %rdi, %r14
callq 0x4fc0
leaq 0x60(%r15), %r12
xorl %r13d, %r13d
pushq $0x18
popq %rbp
xorl %ebx, %ebx
testb $0x1, %bl
jne 0x5930
movq 0x68(%r15), %rax
subq 0x60(%r15), %rax
cqto
idivq %rbp
movb $0x1, %bl
cmpq %r13, %rax
jb 0x5928
movq %r12, %rdi
movq %r13, %rsi
callq 0x3286
movq %rax, %rdi
callq 0x4f5c
testb %al, %al
jne 0x5926
movq %r12, %rdi
movq %r13, %rsi
callq 0x3286
movq %rax, %rdi
callq 0x4f48
cmpl 0x4(%rsp), %eax
jne 0x5926
movq %r12, %rdi
movq %r13, %rsi
callq 0x3286
movq %rax, %rdi
pushq $0x1
popq %rsi
callq 0x4f60
movq %r12, %rdi
movq %r13, %rsi
callq 0x3286
movups (%rax), %xmm0
movups %xmm0, (%r14)
movb 0x10(%rax), %al
movb %al, 0x10(%r14)
jmp 0x5928
xorl %ebx, %ebx
incq %r13
jmp 0x58ac
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pc260533[P]ITC313-TP1/hotel.cpp
// Function: Hotel::toString[abi:cxx11]()
std::string Hotel::toString() {
    std::string res =  "L'id de l'hotel est : " + this->identifiantHotel + ".\n"
            + "Le nom de l'hotel est : " + this->nomHotel + "\n"
            + "La ville de l'hotel est : " + this->villeHotel + "\n"
            + "La liste des chambres :\n";
    for (Chambre chambre : this->listeChambresHotel) {
        res += chambre.toString() + "\n";
    }
    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x1b5e(%rip), %rsi      # 0x74c0
leaq 0xf8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x5ccf
leaq 0x1ad5(%rip), %rdx      # 0x7451
leaq 0x78(%rsp), %rdi
movq %r15, %rsi
callq 0x4a74
leaq 0x1b47(%rip), %rdx      # 0x74d7
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x4a74
leaq 0x20(%r14), %rdx
leaq 0xb8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x4eef
leaq 0x1a90(%rip), %rdx      # 0x7452
leaq 0xd8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x4a74
leaq 0x1b12(%rip), %rdx      # 0x74f0
leaq 0x10(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x4a74
leaq 0x40(%r14), %rdx
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4eef
leaq 0x1a48(%rip), %rdx      # 0x7452
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x4a74
leaq 0x1aeb(%rip), %rdx      # 0x750b
leaq 0x58(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x4a74
leaq 0x58(%rsp), %r15
movq %r15, %rdi
callq 0x20b0
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x20b0
leaq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0x20b0
leaq 0xd8(%rsp), %rdi
callq 0x20b0
leaq 0xb8(%rsp), %rdi
callq 0x20b0
leaq 0x98(%rsp), %rdi
callq 0x20b0
leaq 0x78(%rsp), %rdi
callq 0x20b0
leaq 0xf8(%rsp), %rdi
callq 0x20b0
movq 0x60(%r14), %rbp
movq 0x68(%r14), %rbx
leaq 0x19af(%rip), %r14      # 0x7452
cmpq %rbx, %rbp
je 0x5af6
movq 0x10(%rbp), %rax
movq %rax, 0x20(%rsp)
movups (%rbp), %xmm0
movaps %xmm0, 0x10(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x50dc
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x4a74
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x2270
movq %r15, %rdi
callq 0x20b0
movq %r12, %rdi
callq 0x20b0
addq $0x18, %rbp
jmp 0x5aa3
movq 0x8(%rsp), %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x58(%rsp), %rdi
callq 0x20b0
jmp 0x5b1f
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x20b0
jmp 0x5b2e
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x20b0
jmp 0x5b3d
movq %rax, %r14
leaq 0xd8(%rsp), %rdi
callq 0x20b0
jmp 0x5b4f
movq %rax, %r14
leaq 0xb8(%rsp), %rdi
callq 0x20b0
leaq 0x98(%rsp), %rdi
callq 0x20b0
leaq 0x78(%rsp), %rdi
callq 0x20b0
leaq 0xf8(%rsp), %rdi
jmp 0x5bb2
movq %rax, %r14
jmp 0x5b5c
movq %rax, %r14
jmp 0x5b69
movq %rax, %r14
jmp 0x5b73
movq %rax, %r14
jmp 0x5bad
movq %rax, %r14
jmp 0x5ba3
movq %rax, %r14
leaq 0x58(%rsp), %rdi
callq 0x20b0
leaq 0x38(%rsp), %rdi
callq 0x20b0
movq 0x8(%rsp), %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %ebx
movq %rcx, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
movq %rsi, (%rdi)
movl %edx, 0x8(%rdi)
movq %rcx, %rsi
movl %r8d, %edx
callq 0x455a
movl %eax, %ebp
testb %al, %al
je 0x6078
movl 0x10(%rsp), %eax
movl %eax, 0xc(%r14)
movq 0x8(%rsp), %rax
movq %rax, 0x4(%r14)
movq %r15, 0x10(%r14)
movl %ebx, 0x18(%r14)
movq %r14, %rdi
callq 0x5e5c
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq %esi, %rax
movq 0x8(%rdi), %rcx
imulq $0x18, %rax, %rax
sarq $0x20, %rsi
movq (%rcx,%rax), %rax
movq (%rax,%rsi,8), %r13
movslq %edx, %rax
imulq $0x18, %rax, %rax
sarq $0x20, %rdx
movq (%rcx,%rax), %rax
movq (%rax,%rdx,8), %r12
xorl %r14d, %r14d
leaq 0x8(%rsp), %r15
cmpq %r12, %r13
je 0x269d
incl %r14d
callq 0x2060
cltq
xorl %edx, %edx
divq 0x30(%r13)
movq 0x20(%r13), %rax
movq %rax, 0x8(%rsp)
movq %r15, %rdi
movl %edx, %esi
callq 0x2aea
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movslq %eax, %rcx
movq 0x8(%rbx), %rdx
imulq $0x18, %rcx, %rcx
sarq $0x20, %rax
movq (%rdx,%rcx), %rcx
movq (%rcx,%rax,8), %r13
jmp 0x2653
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdx, %r14
shrq $0x20, %r14
movslq %esi, %rax
movq 0x8(%rdi), %r15
imulq $0x18, %rax, %rax
sarq $0x20, %rsi
movq (%r15,%rax), %rax
movq (%rax,%rsi,8), %r13
movslq %ebx, %rax
imulq $0x18, %rax, %rax
movq %rdx, %rcx
sarq $0x20, %rcx
movq (%r15,%rax), %rax
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
cmpq 0x10(%rsp), %r13
je 0x2762
movl %eax, 0xc(%rsp)
movq 0x20(%r13), %rax
movq %r13, %r12
addq $0x10, %r12
movl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
cmpq %r12, %rax
je 0x275a
movslq 0x20(%rax), %rcx
movslq 0x24(%rax), %rdx
movl %ebx, %esi
subl %ecx, %esi
movl %esi, %edi
negl %edi
cmovsl %esi, %edi
movl %r14d, %r8d
subl %edx, %r8d
movl %r8d, %esi
negl %esi
cmovsl %r8d, %esi
addl %edi, %esi
cmpl %ebp, %esi
jge 0x2750
imulq $0x18, %rcx, %rcx
movq (%r15,%rcx), %rcx
movq (%rcx,%rdx,8), %r13
movl %esi, %ebp
movq %rax, %rdi
callq 0x2190
jmp 0x2715
movl 0xc(%rsp), %eax
incl %eax
jmp 0x26fa
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
andq $0x0, 0x18(%rdi)
movslq %esi, %r14
leaq 0x30(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movq %r14, %rsi
callq 0x30c4
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3088
leaq 0x18(%rsp), %rdi
callq 0x342c
xorl %r15d, %r15d
testl %ebp, %ebp
movl $0x0, %eax
cmovgl %ebp, %eax
movq %rax, 0x8(%rsp)
movl %ebp, %r13d
movabsq $0x100000000, %rbp      # imm = 0x100000000
cmpq 0x8(%rsp), %r15
je 0x2c22
imulq $0x18, %r15, %r12
movq %r15, 0x10(%rsp)
xorl %r14d, %r14d
cmpq %r14, %r13
je 0x2c18
pushq $0x38
popq %rdi
callq 0x2160
movq %r15, (%rax)
andl $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, 0x20(%rax)
movq %rcx, 0x28(%rax)
andq $0x0, 0x30(%rax)
movq (%rbx), %rcx
movq (%rcx,%r12), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
addq %rbp, %r15
jmp 0x2bd8
movq 0x10(%rsp), %r15
incq %r15
jmp 0x2bc5
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x342c
jmp 0x2c45
jmp 0x2c42
movq %rax, %r14
movq %rbx, %rdi
callq 0x311a
movq %r14, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %rbp
movl %esi, %eax
negl %eax
movl %eax, 0xc(%rsp)
movl (%rdi), %eax
xorl %edx, %edx
movslq %eax, %rcx
cmpq %rcx, %rdx
jge 0x2d37
xorl %esi, %esi
movq %rdx, 0x10(%rsp)
movslq %eax, %rcx
cmpq %rcx, %rsi
jge 0x2d2f
movq %rsi, %rax
shlq $0x20, %rax
orq %rdx, %rax
movq %rax, 0x20(%rsp)
movl 0xc(%rsp), %eax
movl %eax, %r14d
movq %rsi, 0x18(%rsp)
cmpl %ebx, %r14d
jg 0x2d24
movl %r14d, %r12d
negl %r12d
cmovsl %r14d, %r12d
leal (%r14,%rdx), %r15d
movl 0xc(%rsp), %r13d
cmpl %ebx, %r13d
jg 0x2d1a
movl %r13d, %eax
negl %eax
cmovsl %r13d, %eax
addl %r12d, %eax
cmpl %ebx, %eax
jg 0x2d15
testl %r15d, %r15d
js 0x2d15
movl (%rbp), %eax
cmpl %eax, %r15d
jge 0x2d15
movl %r13d, %ecx
orl %r14d, %ecx
je 0x2d15
movl %esi, %edx
addl %r13d, %edx
js 0x2d15
cmpl %eax, %edx
jge 0x2d15
shlq $0x20, %rdx
orq %r15, %rdx
movq %rbp, %rdi
movq 0x20(%rsp), %rsi
callq 0x37ee
movq 0x18(%rsp), %rsi
incl %r13d
jmp 0x2cc7
incl %r14d
movq 0x10(%rsp), %rdx
jmp 0x2caf
incq %rsi
movl (%rbp), %eax
jmp 0x2c88
incq %rdx
jmp 0x2c75
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15d, %r15d
xorl %edi, %edi
callq 0x2130
movl %eax, %edi
callq 0x2140
movl (%r14), %eax
movabsq $0x100000000, %r13      # imm = 0x100000000
movslq %eax, %rcx
cmpq %rcx, %r15
jge 0x2db0
movq %r15, (%rsp)
xorl %r12d, %r12d
movslq %eax, %rcx
cmpq %rcx, %r12
jge 0x2da7
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x39ce
incq %r12
movl (%r14), %eax
addq %r13, %r15
jmp 0x2d85
movq (%rsp), %r15
incq %r15
jmp 0x2d76
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movl (%rdi), %eax
xorl %edx, %edx
pushq $0x38
popq %r15
movslq %eax, %rcx
cmpq %rcx, %rdx
jge 0x2e2b
movq %rdx, (%rsp)
imulq $0x18, %rdx, %rbp
xorl %r13d, %r13d
movslq %eax, %rcx
cmpq %rcx, %r13
jge 0x2e22
movq (%rbx), %rcx
movq (%rcx,%rbp), %rcx
movq (%rcx,%r13,8), %r12
testq %r12, %r12
je 0x2e1d
leaq 0x8(%r12), %rdi
callq 0x3dd8
movq %r12, %rdi
movq %r15, %rsi
callq 0x2170
movl (%r14), %eax
incq %r13
jmp 0x2ded
movq (%rsp), %rdx
incq %rdx
jmp 0x2dda
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x311a
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/Examples.cpp
// Function: Example1()
void Example1()
{
	std::cout << "==== Example 1 ====" << std::endl;

	int alpha = 1;					// muon type neutrino
	int beta = 0;					// electron type neutrino
	double delta = 3 * M_PI / 2;	// The CP phase
	int exp_num = 0;				// 0 - DUNE, 1 - NOvA, 2 - T2K/T2HK
	double E = 2.5;					// neutrino energy in GeV
	int order = 0;					// Zeroth order in the perturbative expansion
	E *= -1;						// Negative energy for antineutrinos

	double Yrho, L;
	set_experimental_parameters(exp_num, &Yrho, &L); // Get matter density and baseline for the experiment

	double a = Yrho * E * Y_to_a;   // Y_to_a converts units
	double LE = L / E;
	double P = GF::Palphabeta(alpha, beta, a, LE, delta, order); // Calculate the transition probability using the general form described in the tables

	std::cout << std::setprecision(10); // Increases the number of decimal places to output
	std::cout << "P(nubar_mu->nubar_e) at zeroth order: ";
	std::cout << P << std::endl;

	order = 1; // First order in the perturbative expansion
	P = GF::Palphabeta(alpha, beta, a, LE, delta, order);
	std::cout << "P(nubar_mu->nubar_e) at first order:  ";
	std::cout << P << std::endl;

	order = 2; // Second order in the perturbative expansion
	P = Check::Palphabeta(alpha, beta, a, LE, delta, order);
	std::cout << "P(nubar_mu->nubar_e) at second order: ";
	std::cout << P << std::endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x612f(%rip), %rbx      # 0x10fd0
leaq 0x1f70(%rip), %rsi      # 0xce18
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x20(%rsp), %r14
leaq 0x18(%rsp), %r15
xorl %edi, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5058
movsd 0x1f21(%rip), %xmm2     # 0xcdf8
movsd (%r14), %xmm1
mulsd %xmm2, %xmm1
leaq 0x1449(%rip), %rax      # 0xc330
mulsd (%rax), %xmm1
movapd %xmm1, %xmm0
movsd %xmm1, 0x10(%rsp)
movsd (%r15), %xmm1
divsd %xmm2, %xmm1
movsd %xmm1, (%rsp)
pushq $0x1
popq %rbp
movsd 0x1ef2(%rip), %xmm2     # 0xce00
movl %ebp, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5e76
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0xa, 0x8(%rbx,%rax)
leaq 0x1ef6(%rip), %rsi      # 0xce2c
movq %rbx, %rdi
callq 0x2180
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x21f0
movq %rax, %rdi
callq 0x20c0
movl %ebp, %edi
xorl %esi, %esi
movsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
movsd 0x1e95(%rip), %xmm2     # 0xce00
movl %ebp, %edx
callq 0x5e76
movsd %xmm0, 0x8(%rsp)
leaq 0x1ed4(%rip), %rsi      # 0xce53
movq %rbx, %rdi
callq 0x2180
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x21f0
movq %rax, %rdi
callq 0x20c0
pushq $0x2
popq %rdx
movl %ebp, %edi
xorl %esi, %esi
movsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
movsd 0x1e49(%rip), %xmm2     # 0xce00
callq 0x338a
movsd %xmm0, (%rsp)
leaq 0x1eb2(%rip), %rsi      # 0xce7a
movq %rbx, %rdi
callq 0x2180
movq %rbx, %rdi
movsd (%rsp), %xmm0
callq 0x21f0
movq %rax, %rdi
callq 0x20c0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/Examples.cpp
// Function: Example2()
void Example2()
{
	std::cout << "==== Example 2 ====" << std::endl;

	int alpha = 0;		// electron type
	int beta = 0;		// electron type
	double delta = 0;	// irrelevant
	double E = 2.5e-3;	// 2.5 MeV in GeV
	E *= -1;			// anti-nus
	double L = 52.5;	// 52.5 km

	double LE = L / E;
	double Yrho = 2.6 * 0.5;
	double a = Yrho * E * Y_to_a;
	double P_vac = Exact::Palphabeta(alpha, beta, 0, LE, delta);
	double P_mat = Exact::Palphabeta(alpha, beta, a, LE, delta);

	std::cout << P_mat - P_vac << std::endl;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0x5fd4(%rip), %rbx      # 0x10fd0
leaq 0x1e9e(%rip), %rsi      # 0xcea1
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x1316(%rip), %rax      # 0xc330
movsd (%rax), %xmm0
mulsd 0x1de2(%rip), %xmm0     # 0xce08
movsd %xmm0, 0x8(%rsp)
movsd 0x1ddc(%rip), %xmm1     # 0xce10
xorpd %xmm0, %xmm0
xorps %xmm2, %xmm2
xorl %edi, %edi
xorl %esi, %esi
callq 0x4e00
movsd %xmm0, (%rsp)
xorps %xmm2, %xmm2
xorl %edi, %edi
xorl %esi, %esi
movsd 0x8(%rsp), %xmm0
movsd 0x1db2(%rip), %xmm1     # 0xce10
callq 0x4e00
subsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x21f0
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/liujan[P]MPI_multi_thread_randomforest/Node.cpp
// Function: Node::Node(Node const&)
Node::Node(const Node &other){
	this->attribute = other.attribute;
	this->value = other.value;
	this->left = other.left;
	this->right = other.right;
	this->sum = other.sum;
	this->samples = other.samples;
	this->depth = other.depth;
	for (int i = 0; i < numOfTypes; i++)
		this->num[i] = other.num[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x90, %esi
leaq (%rdi,%rsi), %r15
xorps %xmm0, %xmm0
andq $0x0, 0xa0(%rdi)
movups %xmm0, 0x90(%rdi)
movl (%rbx), %eax
movl %eax, (%rdi)
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rdi)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rdi)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%rdi)
movl 0x20(%rbx), %eax
movl %eax, 0x20(%rdi)
addq %rbx, %rsi
movq %r15, %rdi
callq 0x25d0
movl 0x8c(%rbx), %eax
movl %eax, 0x8c(%r14)
xorl %eax, %eax
cmpq $0x1a, %rax
je 0x25b1
movl 0x24(%rbx,%rax,4), %ecx
movl %ecx, 0x24(%r14,%rax,4)
incq %rax
jmp 0x259d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x26a4
movq %rbx, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2cf2
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, (%rdi)
jne 0x2c65
movl $0xa8, %edi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
callq 0x251c
movq %r15, (%rbx)
movq %r13, -0x30(%rbp)
movq %r12, -0x38(%rbp)
xorl %r15d, %r15d
movl $0x90, %r12d
xorl %r13d, %r13d
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x2cd0
callq 0x2090
cvtsi2sd %eax, %xmm0
divsd 0x336e(%rip), %xmm0     # 0x6008
movsd 0x336e(%rip), %xmm1     # 0x6010
ucomisd %xmm0, %xmm1
jb 0x2cc7
movq (%rbx), %rdi
addq %r12, %rdi
movq (%r14), %rsi
addq %r15, %rsi
callq 0x36ae
movq (%r14), %rax
movslq (%rax,%r15), %rax
movq (%rbx), %rcx
incl 0x20(%rcx,%rax,4)
incq %r13
addq $0x20, %r15
jmp 0x2c79
movq (%rbx), %rax
movq 0x98(%rax), %rcx
subq 0x90(%rax), %rcx
shrq $0x5, %rcx
movl %ecx, 0x20(%rax)
movq -0x38(%rbp), %r12
movq -0x30(%rbp), %r13
jmp 0x2d0d
movq 0x72d7(%rip), %rdi      # 0x9fd0
leaq 0x3360(%rip), %rsi      # 0x6060
callq 0x21e0
movq %rax, %rdi
callq 0x2110
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 0x2340