LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
cmpq %rcx, %rax
jge 0x37de0a
movq -0x10(%rbp), %rax
movq (%rax), %rax
imulq $0x28, -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x37ddf7
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x37ddf7
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x37ddf7
movq -0x28(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jne 0x37ddf7
movq -0x28(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jne 0x37ddf7
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
andq $0x3fffffff, %rax       # imm = 0x3FFFFFFF
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
andq $0x3fffffff, %rcx       # imm = 0x3FFFFFFF
cmpl %ecx, %eax
jne 0x37ddf7
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x1e, %rax
andq $0x1, %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
shrq $0x1e, %rcx
andq $0x1, %rcx
cmpl %ecx, %eax
jne 0x37ddf7
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x1f, %rax
andq $0x1, %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
shrq $0x1f, %rcx
andq $0x1, %rcx
cmpl %ecx, %eax
jne 0x37ddf7
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x20, %rax
andq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
shrq $0x20, %rcx
andq $0x7fffffff, %rcx       # imm = 0x7FFFFFFF
cmpl %ecx, %eax
jne 0x37ddf7
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x3f, %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
shrq $0x3f, %rcx
cmpl %ecx, %eax
jne 0x37ddf7
movq -0x28(%rbp), %rax
movzbl 0x20(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x20(%rcx), %ecx
cmpl %ecx, %eax
jne 0x37ddf7
movq -0x28(%rbp), %rax
movzbl 0x21(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x21(%rcx), %ecx
cmpl %ecx, %eax
jne 0x37ddf7
movq $0x0, -0x8(%rbp)
jmp 0x37de12
jmp 0x37ddf9
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x37dc84
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x37de66
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
shrl %ecx
movl %ecx, %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
xorl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x37de85
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
shrl %ecx
movl %ecx, %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
xorl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x37deae
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x18(%rbp), %ecx
shrl %ecx
movl %ecx, %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x37deca
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x18(%rbp), %ecx
shrl %ecx
movl %ecx, %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
movl -0x20(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
shrq $0x20, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x20(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jae 0x37df36
movq -0x38(%rbp), %rax
movl -0x28(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl -0x24(%rbp), %eax
jne 0x37df29
jmp 0x37df36
jmp 0x37df2b
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x37df09
movl -0x28(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jae 0x37df40
jmp 0x37df5f
leaq 0x8d83(%rip), %rdi      # 0x386cca
leaq 0x1826b(%rip), %rsi     # 0x3961b9
movl $0x45ce, %edx           # imm = 0x45CE
leaq 0x1d5ec(%rip), %rcx     # 0x39b546
callq 0x2130
movl -0x1c(%rbp), %edx
movq -0x38(%rbp), %rax
movl -0x28(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %ecx
andl $0x1, %edx
shll $0x1f, %edx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
orl %edx, %ecx
movl %ecx, 0xc(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
nopl (%rax)
// File: mh0fm4[P]SCDC/test/units/dataprov_access/test_access.c
// Function: main
int main(int argc, char *argv[])
{
  const char *uri = "scdc:/access";
  scdc_dataprov_t dp;


  printf("SCDC access demo for C\n");

  scdc_init(SCDC_INIT_DEFAULT);

  // dp = scdc_dataprov_open("access", "access:stub");
  dp = scdc_dataprov_open("access", "access:fs", ACCESS_FS_CONF);
  // dp = scdc_dataprov_open("access", "access:webdav:no100continue", ACCESS_WEBDAV_CONF);
  // dp = scdc_dataprov_open("access", "access:nfs", ACCESS_NFS_CONF);

  test_access(uri);

  scdc_dataprov_close(dp);

  scdc_release();

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x7c2d5(%rip), %rax     # 0x8a1b2
movq %rax, -0x18(%rbp)
leaq 0x7c2d7(%rip), %rdi     # 0x8a1bf
movb $0x0, %al
callq 0xcd00
leaq 0x7c77e(%rip), %rdi     # 0x8a674
movb $0x0, %al
callq 0xdfb0
leaq 0x7c2b4(%rip), %rdi     # 0x8a1b8
leaq 0x7c2cc(%rip), %rsi     # 0x8a1d7
leaq 0x7c2cf(%rip), %rdx     # 0x8a1e1
movb $0x0, %al
callq 0xe4e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd7e0
movq -0x20(%rbp), %rdi
callq 0xe5b0
callq 0xe160
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x58, %edi
callq 0x2150
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
callq 0x3680
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2130
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x22e0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x38d0
testb $0x1, %al
jne 0x29e7
jmp 0x2a15
leaq -0x28(%rbp), %rdi
callq 0x3910
movb (%rax), %al
movb %al, -0x31(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movsbl -0x31(%rbp), %edx
callq 0x25f0
movq %rax, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3930
jmp 0x29d4
jmp 0x2a17
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x2a3e
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x3950
movq -0x18(%rbp), %rdi
callq 0x37c0
movq %rax, -0x18(%rbp)
jmp 0x2a17
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x3970
cmpq $0x0, %rax
jbe 0x2a7f
jmp 0x2b47
movq -0x10(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x39a0
movq %rax, -0x28(%rbp)
movb %dl, -0x20(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x3880
leaq -0x68(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x39e0
movq %rax, -0x70(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3a10
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x3a40
testb $0x1, %al
jne 0x2ade
leaq -0x68(%rbp), %rdi
callq 0x38b0
jmp 0x2b3a
leaq -0x70(%rbp), %rdi
callq 0x3a70
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2a50
jmp 0x2b10
jmp 0x2b12
leaq -0x70(%rbp), %rdi
callq 0x3aa0
jmp 0x2ac2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x38b0
jmp 0x2b50
movq -0x18(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x3ad0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x22b0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq -0x20(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x2230
movq -0xa0(%rbp), %rsi
leaq 0x10d4f(%rip), %rdi     # 0x141f8
callq 0x2210
jmp 0x34b0
leaq -0x20(%rbp), %rdi
callq 0x2980
movq %rax, -0xa8(%rbp)
jmp 0x34c2
movq -0xa8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x3ff0
leaq -0x88(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x4010
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
movq -0x38(%rbp), %rdi
callq 0x2a50
jmp 0x3509
leaq -0x88(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x4070
movq -0xc0(%rbp), %rdi
movq %rax, -0x90(%rbp)
callq 0x40a0
movq %rax, -0x98(%rbp)
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x4030
jmp 0x354b
leaq -0x88(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2b60
jmp 0x355d
leaq -0x88(%rbp), %rdi
callq 0x40d0
leaq -0x70(%rbp), %rdi
callq 0x4130
leaq -0x20(%rbp), %rdi
callq 0x2328
xorl %eax, %eax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x35b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x40d0
leaq -0x70(%rbp), %rdi
callq 0x4130
leaq -0x20(%rbp), %rdi
callq 0x2328
movq -0x28(%rbp), %rdi
callq 0x22b0
nopw (%rax,%rax)
// File: 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
subq $0xc0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x20, %rdi
callq 0x3a00
cmpq $0x0, (%rax)
je 0x2860
movq -0x70(%rbp), %rdi
addq $0x20, %rdi
callq 0x3a00
cmpq $0x0, 0x8(%rax)
jne 0x28f4
movq -0x70(%rbp), %rdi
addq $0x20, %rdi
callq 0x3a00
movq -0x70(%rbp), %rsi
movq %rax, -0x98(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x2070
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x3a20
movb %al, -0x81(%rbp)
jmp 0x28a3
movb -0x81(%rbp), %al
xorb $-0x1, %al
movb %al, -0x99(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2090
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x28c6
jmp 0x28f2
movq -0x80(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a20
jmp 0x2998
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2090
jmp 0x29a5
jmp 0x28f4
movq -0x70(%rbp), %rsi
addq $0x20, %rsi
movq %rsi, -0xb0(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3ba0
movq -0xb0(%rbp), %rdi
callq 0x3a00
movq (%rax), %rax
movl -0x14(%rbp), %edi
callq *%rax
movq %rax, -0xa8(%rbp)
jmp 0x2929
leaq -0x68(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x3ba0
movq -0x80(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq -0xb8(%rbp), %rdx
callq 0x3bd0
jmp 0x2956
leaq -0x68(%rbp), %rdi
callq 0x3c50
leaq -0x58(%rbp), %rdi
callq 0x2d50
jmp 0x2998
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x298d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3c50
leaq -0x58(%rbp), %rdi
callq 0x2d50
jmp 0x29a5
movq -0x78(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x21a0
nop
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x3704
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x20b0
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3719
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3730
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x2060
movq %rax, %rdi
movl $0x1, %esi
callq 0x2150
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, 0x10(%rax)
jne 0x3aa7
movq 0x4582(%rip), %rdi      # 0x7ff0
leaq 0x15e9(%rip), %rsi      # 0x505e
callq 0x2100
movq %rax, -0x38(%rbp)
callq 0x20e0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x2100
movq %rax, %rdi
movq 0x451f(%rip), %rsi      # 0x7fb8
callq 0x2120
movb $0x0, -0x1(%rbp)
jmp 0x3b87
callq 0x20e0
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x15bc(%rip), %rsi      # 0x5077
callq 0x20d0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
callq 0x20e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3b17
movq 0x450f(%rip), %rdi      # 0x7ff0
leaq 0x1596(%rip), %rsi      # 0x507e
callq 0x2100
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x2100
movq %rax, %rdi
movq 0x44b5(%rip), %rsi      # 0x7fb8
callq 0x2120
movq -0x28(%rbp), %rdi
callq 0x36d0
movb $0x0, -0x1(%rbp)
jmp 0x3b87
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x1577(%rip), %rsi      # 0x509d
callq 0x20d0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x20e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3b83
movq 0x44a3(%rip), %rdi      # 0x7ff0
leaq 0x1551(%rip), %rsi      # 0x50a5
callq 0x2100
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x2100
movq %rax, %rdi
movq 0x4449(%rip), %rsi      # 0x7fb8
callq 0x2120
movq -0x28(%rbp), %rdi
callq 0x36d0
movb $0x0, -0x1(%rbp)
jmp 0x3b87
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movups 0x5d7f(%rip), %xmm0     # 0xf450
movaps %xmm0, -0x40(%rbp)
movups 0x5d64(%rip), %xmm0     # 0xf440
movaps %xmm0, -0x50(%rbp)
movups 0x5d49(%rip), %xmm0     # 0xf430
movaps %xmm0, -0x60(%rbp)
leaq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0xc, -0x28(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xa200
movq -0x80(%rbp), %rcx
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0xa220
jmp 0x971f
leaq -0x61(%rbp), %rdi
callq 0xa2a0
movq -0x88(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x9756
movq -0x88(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x64, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x976d
movq -0x88(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x190, %ecx            # imm = 0x190
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x97c7
leaq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0xa2c0
movq %rax, -0x90(%rbp)
jmp 0x9784
movq -0x90(%rbp), %rax
movl $0x1d, (%rax)
jmp 0x97c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x61(%rbp), %rdi
callq 0xa2a0
jmp 0x9853
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xa300
jmp 0x9853
movq -0x88(%rbp), %rax
movl (%rax), %ecx
incl %ecx
movl %ecx, (%rax)
movl (%rax), %ecx
movl %ecx, -0x9c(%rbp)
movl 0x4(%rax), %eax
decl %eax
movslq %eax, %rsi
leaq -0x20(%rbp), %rdi
callq 0xa2c0
movq %rax, -0x98(%rbp)
jmp 0x97f6
movl -0x9c(%rbp), %eax
movq -0x98(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x981d
movq -0x88(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movl $0x1, (%rax)
movq -0x88(%rbp), %rax
cmpl $0xc, 0x4(%rax)
jle 0x9841
movq -0x88(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movl $0x1, 0x4(%rax)
leaq -0x20(%rbp), %rdi
callq 0xa300
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x3350
nopl (%rax)
// File: pc260533[P]ITC313-TP1/date.cpp
// Function: Date::moisProchain()
void Date::moisProchain() {
    if (this->mois == 12) {
        this->mois = 1;
    }
    else {
        this->mois++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0xc, 0x4(%rax)
jne 0x9883
movq -0x10(%rbp), %rax
movl $0x1, 0x4(%rax)
jmp 0x9890
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pc260533[P]ITC313-TP1/date.cpp
// Function: Date::estAvantDate(Date)
bool Date::estAvantDate(Date date) {
    bool res = false;
    if (this->mois < date.mois) {
        res = true;
    }
    if ((this->mois == date.mois) && (this->jour < date.jour)) {
        res = true;
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, -0x1c(%rbp)
movl %edx, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x29(%rbp)
movl 0x4(%rax), %eax
cmpl -0x8(%rbp), %eax
jge 0x98f5
movb $0x1, -0x29(%rbp)
movq -0x38(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x9910
movq -0x38(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jge 0x9910
movb $0x1, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: pc260533[P]ITC313-TP1/date.cpp
// Function: Date::estApresDate(Date)
bool Date::estApresDate(Date date) {
    bool res = false;
    if (this->mois > date.mois) {
        res = true;
    }
    if ((this->mois == date.mois) && (this->jour > date.jour)) {
        res = true;
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, -0x1c(%rbp)
movl %edx, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x29(%rbp)
movl 0x4(%rax), %eax
cmpl -0x8(%rbp), %eax
jle 0x9955
movb $0x1, -0x29(%rbp)
movq -0x38(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x9970
movq -0x38(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jle 0x9970
movb $0x1, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
leaq -0x16(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x3360
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x3b25(%rip), %rsi      # 0xf4a3
callq 0x4a30
jmp 0xb985
leaq -0x16(%rbp), %rdi
callq 0x3240
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
testl %eax, %eax
je 0xb9c5
jmp 0xb99a
movl -0x44(%rbp), %eax
subl $0x1, %eax
je 0xb9f0
jmp 0xb9a4
movl -0x44(%rbp), %eax
subl $0x2, %eax
je 0xba04
jmp 0xba18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x16(%rbp), %rdi
callq 0x3240
jmp 0xba35
movq -0x38(%rbp), %rdi
leaq 0x3aa3(%rip), %rsi      # 0xf473
callq 0x32c0
jmp 0xb9d7
jmp 0xba18
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3160
jmp 0xba35
movq -0x38(%rbp), %rdi
leaq 0x3a7f(%rip), %rsi      # 0xf47a
callq 0x32c0
jmp 0xba02
jmp 0xba18
movq -0x38(%rbp), %rdi
leaq 0x3a72(%rip), %rsi      # 0xf481
callq 0x32c0
jmp 0xba16
jmp 0xba18
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0xba2b
movq -0x38(%rbp), %rdi
callq 0x3160
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3350
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xc0b0
movq -0x90(%rbp), %rsi
leaq -0x38(%rbp), %rdi
xorl %edx, %edx
callq 0xb940
jmp 0xbafc
movq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xc0d0
jmp 0xbb0e
leaq -0x38(%rbp), %rdi
callq 0x3160
movq -0x90(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movl $0x1, %edx
callq 0xb940
jmp 0xbb2e
movq -0xa0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xc0d0
jmp 0xbb40
leaq -0x68(%rbp), %rdi
callq 0x3160
movq -0x90(%rbp), %rsi
leaq -0x88(%rbp), %rdi
movl $0x2, %edx
callq 0xb940
jmp 0xbb63
movq -0xa0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xc0d0
jmp 0xbb78
leaq -0x88(%rbp), %rdi
callq 0x3160
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xbbf2
jmp 0xbbe6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xbc02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3160
jmp 0xbc02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3160
jmp 0xbc02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x3160
jmp 0xbc02
movq -0xa0(%rbp), %rdi
callq 0x5080
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x5080
movq -0x40(%rbp), %rdi
callq 0x3350
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, %rax
movq -0x28(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq 0x3826(%rip), %rsi      # 0xf473
callq 0xc100
testb $0x1, %al
jne 0xbc58
jmp 0xbc61
movl $0x0, -0x14(%rbp)
jmp 0xbca1
movq -0x20(%rbp), %rdi
leaq 0x380e(%rip), %rsi      # 0xf47a
callq 0xc100
testb $0x1, %al
jne 0xbc77
jmp 0xbc80
movl $0x1, -0x14(%rbp)
jmp 0xbc9f
movq -0x20(%rbp), %rdi
leaq 0x37f6(%rip), %rsi      # 0xf481
callq 0xc100
testb $0x1, %al
jne 0xbc96
jmp 0xbc9d
movl $0x2, -0x14(%rbp)
jmp 0xbc9f
jmp 0xbca1
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, -0xd(%rbp)
addq $0x60, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x60f0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5f20
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xd850
testb $0x1, %al
jne 0xd01c
jmp 0xd068
leaq -0x20(%rbp), %rdi
callq 0x65e0
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xb900
testb $0x1, %al
jne 0xd05b
leaq -0x40(%rbp), %rdi
callq 0xb880
cmpl -0xc(%rbp), %eax
jne 0xd05b
movb $0x1, -0xd(%rbp)
jmp 0xd05d
leaq -0x20(%rbp), %rdi
callq 0xd890
jmp 0xd009
movb -0xd(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0xba40
movb $0x0, -0xd(%rbp)
movl $0x0, -0x14(%rbp)
movb -0xd(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xd0c0
jmp 0xd183
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x60, %rdi
callq 0x61f0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jbe 0xd0ea
movb $0x1, -0xd(%rbp)
jmp 0xd175
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movslq -0x14(%rbp), %rsi
callq 0x4fe0
movq %rax, %rdi
callq 0xb900
testb $0x1, %al
jne 0xd173
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movslq -0x14(%rbp), %rsi
callq 0x4fe0
movq %rax, %rdi
callq 0xb880
cmpl -0xc(%rbp), %eax
jne 0xd173
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movslq -0x14(%rbp), %rsi
callq 0x4fe0
movq %rax, %rdi
movl $0x1, %esi
callq 0xb920
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movslq -0x14(%rbp), %rsi
callq 0x4fe0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movb 0x10(%rcx), %cl
movb %cl, 0x10(%rax)
movb $0x1, -0xd(%rbp)
jmp 0xd175
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd0b2
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x1c(%rbp)
movl %edx, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movq %rcx, -0x38(%rbp)
movl %r8d, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x20(%rbp)
movq %rdi, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x0, -0x41(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x60(%rbp), %rsi
movl -0x58(%rbp), %edx
leaq -0xc(%rbp), %rdi
callq 0x98c0
testb $0x1, %al
jne 0xe735
jmp 0xe759
movq -0x68(%rbp), %rax
movb $0x1, -0x41(%rbp)
movq -0xc(%rbp), %rcx
movq %rcx, 0x4(%rax)
movl -0x4(%rbp), %ecx
movl %ecx, 0xc(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x20(%rbp), %ecx
movl %ecx, 0x18(%rax)
movq -0x68(%rbp), %rdi
callq 0xe2c0
movb -0x41(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
callq 0x31c0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0x31c0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x2a80
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
callq 0x2070
cltq
movq %rax, -0x68(%rbp)
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x3540
movq %rax, %rcx
movq -0x68(%rbp), %rax
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x44(%rbp)
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x3250
movq %rax, -0x50(%rbp)
movl -0x44(%rbp), %esi
leaq -0x50(%rbp), %rdi
callq 0x3560
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x32e0
movq -0x60(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rsi
callq 0x35b0
movq %rax, -0x38(%rbp)
jmp 0x29f9
movl -0x2c(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
callq 0x31c0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0x31c0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x2bb5
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
callq 0x35e0
movl %eax, -0x44(%rbp)
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x3250
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x3280
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x32b0
testb $0x1, %al
jne 0x2b44
jmp 0x2ba8
leaq -0x60(%rbp), %rdi
callq 0x32e0
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x7c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x84(%rbp)
movq -0x7c(%rbp), %rdi
movq -0x84(%rbp), %rsi
callq 0x35f0
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
cmpl -0x44(%rbp), %eax
jge 0x2b9b
movl -0x74(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x18(%rbp), %rdi
movl -0x70(%rbp), %esi
movl -0x6c(%rbp), %edx
callq 0x31c0
movq %rax, -0x50(%rbp)
jmp 0x2b9d
leaq -0x60(%rbp), %rdi
callq 0x3440
jmp 0x2b31
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x2aec
movl -0x2c(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movl -0xc(%rbp), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
callq 0x4f30
movslq -0xc(%rbp), %rax
movq %rax, -0x60(%rbp)
movq $0x0, -0x30(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x5000
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rcx
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x5020
jmp 0x37c7
movq -0x60(%rbp), %rsi
movq -0x70(%rbp), %rdi
leaq -0x28(%rbp), %rdx
callq 0x4f50
jmp 0x37da
leaq -0x28(%rbp), %rdi
callq 0x50a0
leaq -0x31(%rbp), %rdi
callq 0x5100
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x38ca
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x38ba
movl $0x38, %edi
callq 0x21a0
movq %rax, -0x80(%rbp)
jmp 0x3822
movq -0x80(%rbp), %rdi
movl -0x48(%rbp), %esi
movl -0x4c(%rbp), %edx
callq 0x5120
jmp 0x3833
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
movslq -0x48(%rbp), %rsi
callq 0x3eb0
movq %rax, %rdi
movslq -0x4c(%rbp), %rsi
callq 0x3ed0
movq -0x80(%rbp), %rcx
movq %rcx, (%rax)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x3806
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3885
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x50a0
leaq -0x31(%rbp), %rdi
callq 0x5100
jmp 0x38d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x38d3
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
movl $0x38, %esi
callq 0x21b0
jmp 0x38d3
jmp 0x38bc
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x37f3
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x5160
movq -0x40(%rbp), %rdi
callq 0x22a0
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x50(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl (%rcx), %eax
jge 0x3a56
movl $0x0, -0x14(%rbp)
movq -0x50(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jge 0x3a46
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x3a36
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x3a26
movl -0x18(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
addl %ecx, %eax
cmpl -0xc(%rbp), %eax
jg 0x3a16
movl -0x10(%rbp), %eax
addl -0x18(%rbp), %eax
cmpl $0x0, %eax
jl 0x3a16
movq -0x50(%rbp), %rcx
movl -0x10(%rbp), %eax
addl -0x18(%rbp), %eax
cmpl (%rcx), %eax
jge 0x3a16
movl -0x14(%rbp), %eax
addl -0x1c(%rbp), %eax
cmpl $0x0, %eax
jl 0x3a16
movq -0x50(%rbp), %rcx
movl -0x14(%rbp), %eax
addl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x3a16
cmpl $0x0, -0x18(%rbp)
jne 0x39bc
cmpl $0x0, -0x1c(%rbp)
je 0x3a16
leaq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x7d80
movq %rax, -0x34(%rbp)
movl -0x10(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x14(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x44(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x44(%rbp), %rsi
callq 0x3af0
movq %rax, -0x3c(%rbp)
leaq -0x34(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x7f90
movq -0x50(%rbp), %rdi
movq %rax, -0x2c(%rbp)
movq %rdx, -0x24(%rbp)
movq -0x2c(%rbp), %rsi
movq -0x24(%rbp), %rdx
callq 0x7f40
jmp 0x3a18
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x394f
jmp 0x3a28
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x393b
jmp 0x3a38
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3924
jmp 0x3a48
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x390e
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x2170
movl %eax, %edi
callq 0x2180
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jge 0x3aea
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl (%rcx), %eax
jge 0x3add
leaq -0x14(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x7d80
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rsi
callq 0x8a30
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3aa3
jmp 0x3adf
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3a91
addq $0x30, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0x3bdf
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl (%rcx), %eax
jge 0x3bcf
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movslq -0xc(%rbp), %rsi
callq 0x3eb0
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x3ed0
cmpq $0x0, (%rax)
je 0x3bc2
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movslq -0xc(%rbp), %rsi
callq 0x3eb0
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x3ed0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x3bc0
movq -0x20(%rbp), %rdi
callq 0x9f40
movq -0x20(%rbp), %rdi
movl $0x38, %esi
callq 0x21b0
jmp 0x3bc2
jmp 0x3bc4
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3b51
jmp 0x3bd1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3b3b
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x5160
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq 0x5b95(%rip), %rdi      # 0x16fd0
leaq 0x19cf(%rip), %rsi      # 0x12e11
callq 0x2150
movq %rax, %rdi
movq 0x5b6f(%rip), %rsi      # 0x16fc0
callq 0x2170
movl $0x0, 0x44(%rsp)
movl $0x0, 0x40(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x1909(%rip), %xmm0     # 0x12d80
movsd %xmm0, 0x30(%rsp)
movsd 0x100b(%rip), %xmm0     # 0x12490
mulsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x18df(%rip), %xmm0     # 0x12d78
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
divsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x18b7(%rip), %xmm0     # 0x12d70
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
mulsd 0x30(%rsp), %xmm0
leaq 0xe0e(%rip), %rax       # 0x122e0
mulsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movl 0x44(%rsp), %edi
movl 0x40(%rsp), %esi
movsd 0x20(%rsp), %xmm1
movsd 0x38(%rsp), %xmm2
xorps %xmm0, %xmm0
callq 0x6bd0
movsd %xmm0, 0x8(%rsp)
movl 0x44(%rsp), %edi
movl 0x40(%rsp), %esi
movsd 0x10(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movsd 0x38(%rsp), %xmm2
callq 0x6bd0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
subsd 0x8(%rsp), %xmm0
movq 0x5a9c(%rip), %rdi      # 0x16fd0
callq 0x2280
movq %rax, %rdi
movq 0x5a7d(%rip), %rsi      # 0x16fc0
callq 0x2170
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x90, %rdi
movq %rdi, -0x28(%rbp)
callq 0xa0c0
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movl 0x20(%rcx), %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rsi
addq $0x90, %rsi
callq 0xa0e0
jmp 0xa04a
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8c(%rcx), %ecx
movl %ecx, 0x8c(%rax)
movl $0x0, -0x20(%rbp)
cmpl $0x1a, -0x20(%rbp)
jge 0xa0a5
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movl 0x24(%rcx,%rdx,4), %edx
movslq -0x20(%rbp), %rcx
movl %edx, 0x24(%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xa065
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xa330
jmp 0xa0ab
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x9c10
nopw %cs:(%rax,%rax)
nop