LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/gfa_ut.cpp
// Function: gen_cul_g_t(ul_resolve_t*)
void gen_cul_g_t(ul_resolve_t *uidx)
{
    ma_ug_t *ug = uidx->l1_ug; uint64_t k; ul_str_idx_t *str_idx = &(uidx->pstr);
    CALLOC(uidx->cg, 1);
    uidx->cg->n[0] = uidx->idx->n; uidx->cg->n[1] = ug->g->n_seq; 
    uidx->cg->tot = uidx->cg->n[0] + uidx->cg->n[1];
    uidx->cg->g = asg_init();
    for (k = 0; k < uidx->cg->tot; k++) {
        if(k < uidx->cg->n[0]) {
            asg_seq_set(uidx->cg->g, k, str_occ_w(&(str_idx->str.a[k]), &(uidx->idx->a[k]), ug), 
                                                                        ((str_idx->str.a[k].cn>1)?0:1));
        } else {
            asg_seq_set(uidx->cg->g, k, ug->u.a[k-uidx->cg->n[0]].n, 0);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movl $0x1, %edi
movl $0x20, %esi
callq 0x2120
movq %rax, 0x1e8(%rbx)
movq 0x30(%rbx), %rcx
movq 0x50(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq %r14, (%rsp)
movq 0x18(%r14), %rdx
movl 0x14(%rdx), %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movq %rdx, 0x10(%rax)
addq %rdx, %rcx
movq %rcx, 0x18(%rax)
callq 0x9fccc
movq 0x1e8(%rbx), %rcx
movq %rax, (%rcx)
cmpq $0x0, 0x18(%rcx)
je 0x21eb9e
movl $0x10, %r13d
xorl %ebp, %ebp
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rcx), %r12
movq 0x8(%rcx), %rax
cmpq %rax, %r15
jae 0x21eb59
movq 0x1d0(%rbx), %rdi
addq %rbp, %rdi
movq 0x30(%rbx), %rax
movq 0x48(%rax), %rsi
addq %r14, %rsi
movq (%rsp), %rdx
callq 0x21e9ef
movq 0x1d0(%rbx), %rdx
xorl %ecx, %ecx
testl $0x7ffffffe, 0x18(%rdx,%rbp) # imm = 0x7FFFFFFE
sete %cl
movq %r12, %rdi
movl %r15d, %esi
movl %eax, %edx
jmp 0x21eb79
movq (%rsp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x3, %rax
leaq (%rax,%rax,4), %rax
subq %rax, %rcx
movl (%r13,%rcx), %edx
movq %r12, %rdi
movl %r15d, %esi
xorl %ecx, %ecx
callq 0xa0115
incq %r15
movq 0x1e8(%rbx), %rcx
addq $0x58, %r14
addq $0x20, %rbp
addq $0x28, %r13
cmpq 0x18(%rcx), %r15
jb 0x21eb11
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/gfa_ut.cpp
// Function: init_ulg_opt_t(ulg_opt_t*, ug_opt_t*, long, double, double, double, double, double, long, long, bub_label_t*, unsigned int)
void init_ulg_opt_t(ulg_opt_t *z, ug_opt_t *uopt, int64_t clean_round, 
double min_path_drop_ratio, double max_path_drop_ratio,
double min_ovlp_drop_ratio, double max_ovlp_drop_ratio, double hom_check_drop_rate, 
int64_t max_tip, int64_t max_tip_hifi, bub_label_t *b_mask_t, uint32_t is_trio)
{
    z->tipsLen = uopt->tipsLen;
    z->tip_drop_ratio = uopt->tip_drop_ratio;
    z->stops_threshold = uopt->stops_threshold;
    z->chimeric_rate = uopt->chimeric_rate;
    z->drop_ratio = uopt->drop_ratio;


    z->b_mask_t = b_mask_t;
    z->clean_round = clean_round;
    z->min_path_drop_ratio = min_path_drop_ratio;
    z->max_path_drop_ratio = max_path_drop_ratio;
    z->min_ovlp_drop_ratio = min_ovlp_drop_ratio;
    z->max_ovlp_drop_ratio = max_ovlp_drop_ratio;
    z->hom_check_drop_rate = hom_check_drop_rate;
    z->max_tip = max_tip;
    z->max_tip_hifi = max_tip_hifi;
    z->is_trio = is_trio;
}

// Assembly:
movl 0x8(%rsp), %eax
movq 0x18(%rsi), %r10
movq %r10, (%rdi)
movss 0x20(%rsi), %xmm5
movss %xmm5, 0x8(%rdi)
movq 0x28(%rsi), %r10
movq %r10, 0x10(%rdi)
movss 0x38(%rsi), %xmm5
movss %xmm5, 0x18(%rdi)
movss 0x3c(%rsi), %xmm5
movss %xmm5, 0x1c(%rdi)
movq %r9, 0x20(%rdi)
movq %rdx, 0x28(%rdi)
movsd %xmm0, 0x48(%rdi)
movsd %xmm1, 0x50(%rdi)
movsd %xmm2, 0x30(%rdi)
movsd %xmm3, 0x38(%rdi)
movsd %xmm4, 0x40(%rdi)
movq %rcx, 0x58(%rdi)
movq %r8, 0x60(%rdi)
movl %eax, 0x68(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/gfa_ut.cpp
// Function: renew_paf1(ma_hit_t_alloc*, unsigned long*, unsigned long, unsigned long)
void renew_paf1(ma_hit_t_alloc *paf, uint64_t *a, uint64_t an, uint64_t len)
{
    uint64_t i, k, qn, tn; ma_hit_t arc;
    arc.qns = 0; arc.qe = len;
    arc.tn = 0; arc.ts = 0; arc.te = len;
    arc.rev = arc.el = arc.ml = arc.no_l_indel = arc.bl = 0;

    for (i = 0; i < an; i++) {
        qn = ((uint32_t)a[i]);
        for (k = 0; k < an; k++) {
            tn = ((uint32_t)a[k]);
            update_qtn(&arc, qn, tn); 
            add_ma_hit_t_alloc(&(paf[qn]), &arc);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, (%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movl %ecx, 0x18(%rsp)
movq %rax, 0x1c(%rsp)
movl %ecx, 0x24(%rsp)
movw $0x0, 0x30(%rsp)
movabsq $-0x7fffffffc0000001, %rax # imm = 0x800000003FFFFFFF
andq %rax, 0x28(%rsp)
testq %rdx, %rdx
je 0x21f147
movq %rdx, %rbx
movq %rsi, %r14
xorl %eax, %eax
leaq 0x10(%rsp), %r12
movq %rax, 0x8(%rsp)
movq (%r14,%rax,8), %r15
movl %r15d, %eax
shlq $0x20, %r15
leaq (%rax,%rax,2), %rax
movq (%rsp), %rcx
leaq (%rcx,%rax,8), %r13
xorl %ebp, %ebp
movl (%r14,%rbp,8), %eax
movl 0x10(%rsp), %ecx
orq %r15, %rcx
movq %rcx, 0x10(%rsp)
movl %eax, 0x1c(%rsp)
movq %r13, %rdi
movq %r12, %rsi
callq 0x9fdd9
incq %rbp
cmpq %rbp, %rbx
jne 0x21f113
movq 0x8(%rsp), %rax
incq %rax
cmpq %rbx, %rax
jne 0x21f0f5
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/gfa_ut.cpp
// Function: destroy_integer_t(integer_t*)
void destroy_integer_t(integer_t *z)
{
    free(z->f.a); free(z->p.a); free(z->o.a); free(z->u.a);
    free(z->vis.a); free(z->sc.a); free(z->snp.a); free(z->res_dump.a);
    free(z->q.a); free(z->t.a); free(z->b.a); 
    
    free(z->pg.seq.a); free(z->pg.arc.a); free(z->pg.idx.a); free(z->pg.e_idx.a);
    free(z->pg.srt_b.ind.a);
    free(z->pg.srt_b.stack.a);
    free(z->pg.srt_b.res.a);
    free(z->pg.srt_b.res2nid.a);
    free(z->pg.srt_b.aln.a);

    free(z->pg.bb.a.a);
    free(z->pg.bb.S.a);
    free(z->pg.bb.T.a);
    free(z->pg.bb.b.a);
    free(z->pg.bb.e.a);
    free(z->pg.bb.us.a);

    free(z->pg.bb.dp.ref.a);
    free(z->pg.bb.dp.pat.a);
    free(z->pg.bb.dp.pat_cor.a);
    free(z->pg.bb.dp.g_flt.a);
    free(z->pg.bb.dp.m_dir.a);
    free(z->pg.bb.dp.m_score.a);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
callq 0x2220
movq 0x70(%rbx), %rdi
callq 0x2220
movq 0x88(%rbx), %rdi
callq 0x2220
movq 0xa0(%rbx), %rdi
callq 0x2220
movq 0xb8(%rbx), %rdi
callq 0x2220
movq 0xd0(%rbx), %rdi
callq 0x2220
movq 0xe8(%rbx), %rdi
callq 0x2220
movq 0x310(%rbx), %rdi
callq 0x2220
movq 0x10(%rbx), %rdi
callq 0x2220
movq 0x28(%rbx), %rdi
callq 0x2220
movq 0x40(%rbx), %rdi
callq 0x2220
movq 0x100(%rbx), %rdi
callq 0x2220
movq 0x118(%rbx), %rdi
callq 0x2220
movq 0x130(%rbx), %rdi
callq 0x2220
movq 0x1c8(%rbx), %rdi
callq 0x2220
movq 0x150(%rbx), %rdi
callq 0x2220
movq 0x168(%rbx), %rdi
callq 0x2220
movq 0x180(%rbx), %rdi
callq 0x2220
movq 0x198(%rbx), %rdi
callq 0x2220
movq 0x1b0(%rbx), %rdi
callq 0x2220
movq 0x1e0(%rbx), %rdi
callq 0x2220
movq 0x1f8(%rbx), %rdi
callq 0x2220
movq 0x210(%rbx), %rdi
callq 0x2220
movq 0x228(%rbx), %rdi
callq 0x2220
movq 0x240(%rbx), %rdi
callq 0x2220
movq 0x258(%rbx), %rdi
callq 0x2220
movq 0x270(%rbx), %rdi
callq 0x2220
movq 0x288(%rbx), %rdi
callq 0x2220
movq 0x2a0(%rbx), %rdi
callq 0x2220
movq 0x2b8(%rbx), %rdi
callq 0x2220
movq 0x2d0(%rbx), %rdi
callq 0x2220
movq 0x2e8(%rbx), %rdi
popq %rbx
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/gfa_ut.cpp
// Function: usg_t_destroy(usg_t*)
void usg_t_destroy(usg_t *g) {
    uint32_t k;
    for (k = 0; k < g->mp.n; k++) {
        free(g->mp.a[k].a);
    }
    free(g->mp.a);

    for (k = 0; k < g->n; k++) {
        free(g->a[k].arc[0].a); free(g->a[k].arc[1].a);
        free(g->a[k].arc_mm[0].a); free(g->a[k].arc_mm[1].a);
    }
    free(g->a);
    
    free(g);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x21f2fc
movl $0x1, %ebp
xorl %eax, %eax
movq 0x28(%rbx), %rcx
leaq (%rax,%rax,2), %rax
movq (%rcx,%rax,8), %rdi
callq 0x2220
movl %ebp, %eax
incl %ebp
cmpq %rax, 0x18(%rbx)
ja 0x21f2e1
movq 0x28(%rbx), %rdi
callq 0x2220
cmpq $0x0, 0x8(%rbx)
je 0x21f355
movl $0x1, %ebp
xorl %eax, %eax
movq (%rbx), %rcx
imulq $0x78, %rax, %r14
movq 0x20(%rcx,%r14), %rdi
callq 0x2220
movq (%rbx), %rax
movq 0x38(%rax,%r14), %rdi
callq 0x2220
movq (%rbx), %rax
movq 0x50(%rax,%r14), %rdi
callq 0x2220
movq (%rbx), %rax
movq 0x68(%rax,%r14), %rdi
callq 0x2220
movl %ebp, %eax
incl %ebp
cmpq %rax, 0x8(%rbx)
ja 0x21f313
movq (%rbx), %rdi
callq 0x2220
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/gfa_ut.cpp
// Function: destroy_ul_resolve_t(ul_resolve_t*)
void destroy_ul_resolve_t(ul_resolve_t *uidx)
{
    ma_ug_destroy(uidx->l1_ug);
    uint32_t k;
    for (k = 0; k < uidx->str_b.n_thread; k++) {
        destroy_integer_t(&(uidx->str_b.buf[k]));
    }
    free(uidx->str_b.buf);

    for (k = 0; k < uidx->pstr.str.n; k++) {
        free(uidx->pstr.str.a[k].a);
    }
    free(uidx->pstr.str.a); 
    free(uidx->pstr.occ.a); 
    free(uidx->pstr.idx.a);

    
    free(uidx->uovl.telo);
    for (k = 0; k < uidx->uovl.n; k++) {
        free(uidx->uovl.a[k].a);
    }
    free(uidx->uovl.a);
    free(uidx->uovl.item_idx);
    asg_destroy(uidx->uovl.i_g);
    

    free(uidx->uovl.cc.uc); 
    free(uidx->uovl.cc.hc); 
    free(uidx->uovl.cc.raw_uc); 
    if(uidx->uovl.cc.iug_a) {
        for (k = 0; k < uidx->uovl.i_ug->u.n; k++) free(uidx->uovl.cc.iug_a[k].a);
    }
    free(uidx->uovl.cc.iug_a); 
    free(uidx->uovl.cc.iug_idx); 
    free(uidx->uovl.cc.iug_b);

    asg_destroy(uidx->uovl.bg.bg); 
    free(uidx->uovl.bg.w_n); 
    free(uidx->uovl.bg.a_n);
    ma_ug_destroy(uidx->uovl.i_ug);
    usg_t_destroy(uidx->uovl.h_usg);

    free(uidx);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xa0004
cmpq $0x0, 0x1e0(%rbx)
je 0x21f3a9
movl $0x1, %ebp
xorl %eax, %eax
imulq $0x328, %rax, %rdi      # imm = 0x328
addq 0x1d8(%rbx), %rdi
callq 0x21f156
movl %ebp, %eax
incl %ebp
cmpq %rax, 0x1e0(%rbx)
ja 0x21f389
movq 0x1d8(%rbx), %rdi
callq 0x2220
cmpq $0x0, 0x1c0(%rbx)
je 0x21f3e8
movl $0x1, %ebp
xorl %eax, %eax
movq 0x1d0(%rbx), %rcx
shlq $0x5, %rax
movq 0x10(%rcx,%rax), %rdi
callq 0x2220
movl %ebp, %eax
incl %ebp
cmpq %rax, 0x1c0(%rbx)
ja 0x21f3c6
movq 0x1d0(%rbx), %rdi
callq 0x2220
movq 0x1b8(%rbx), %rdi
callq 0x2220
movq 0x1a0(%rbx), %rdi
callq 0x2220
movq 0x2a8(%rbx), %rdi
callq 0x2220
cmpq $0x0, 0x1f8(%rbx)
je 0x21f44a
movl $0x1, %ebp
xorl %eax, %eax
movq 0x1f0(%rbx), %rcx
shlq $0x5, %rax
movq (%rcx,%rax), %rdi
callq 0x2220
movl %ebp, %eax
incl %ebp
cmpq %rax, 0x1f8(%rbx)
ja 0x21f429
movq 0x1f0(%rbx), %rdi
callq 0x2220
movq 0x220(%rbx), %rdi
callq 0x2220
movq 0x228(%rbx), %rdi
callq 0x9fcdb
movq 0x248(%rbx), %rdi
callq 0x2220
movq 0x250(%rbx), %rdi
callq 0x2220
movq 0x258(%rbx), %rdi
callq 0x2220
cmpq $0x0, 0x260(%rbx)
je 0x21f4d5
movq 0x230(%rbx), %rax
cmpq $0x0, (%rax)
je 0x21f4d5
movl $0x1, %ebp
xorl %eax, %eax
movq 0x260(%rbx), %rcx
leaq (%rax,%rax,2), %rax
movq 0x10(%rcx,%rax,8), %rdi
callq 0x2220
movl %ebp, %eax
movq 0x230(%rbx), %rcx
incl %ebp
cmpq %rax, (%rcx)
ja 0x21f4b0
movq 0x260(%rbx), %rdi
callq 0x2220
movq 0x268(%rbx), %rdi
callq 0x2220
movq 0x270(%rbx), %rdi
callq 0x2220
movq 0x278(%rbx), %rdi
callq 0x9fcdb
movq 0x280(%rbx), %rdi
callq 0x2220
movq 0x288(%rbx), %rdi
callq 0x2220
movq 0x230(%rbx), %rdi
callq 0xa0004
movq 0x240(%rbx), %rdi
callq 0x21f2cc
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/gfa_ut.cpp
// Function: renew_R_to_U(asg_t*, ma_hit_t_alloc*, ma_hit_t_alloc*, long, ma_sub_t*, R_to_U*, int, int)
void renew_R_to_U(asg_t *ng, ma_hit_t_alloc* src, ma_hit_t_alloc* r_src, int64_t n_read, ma_sub_t *coverage_cut, 
R_to_U* ruIndex, int max_hang, int min_ovlp)
{
    sset_aux s; memset(&s, 0, sizeof(s)); 
    kt_for(asm_opt.thread_num, clear_ma_hit_t_alloc, src, n_read);
    kt_for(asm_opt.thread_num, clear_ma_hit_t_alloc, r_src, n_read);

    s.g = NULL; s.cov = coverage_cut;
    kt_for(asm_opt.thread_num, reset_ma_sub_t, &s, n_read);

    ma_hit_contained_advance(src, n_read, coverage_cut, ruIndex, max_hang, min_ovlp);

    // s.g = ng; s.cov = coverage_cut;
    // kt_for(asm_opt.thread_num, reset_ma_sub_t, &s, n_read);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, (%rsp)
movq %rsi, %r13
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r12
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
xorl %eax, %eax
movq %rax, 0x30(%r12)
leaq 0x6b1ce(%rip), %rbp     # 0x28a758
movl 0x7c(%rbp), %edi
leaq 0x6f(%rip), %rbx        # 0x21f603
movq %rbx, %rsi
movq %r13, %rdx
callq 0x1047b4
movl 0x7c(%rbp), %edi
movq %rbx, %rsi
movq (%rsp), %rdx
movq %r15, %rcx
callq 0x1047b4
xorl %eax, %eax
movq %rax, (%r12)
movq %r14, 0x10(%r12)
movl 0x7c(%rbp), %edi
leaq 0x74(%rip), %rsi        # 0x21f63a
movq %r12, %rdx
movq %r15, %rcx
callq 0x1047b4
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq 0x8(%rsp), %rcx
movl 0x80(%rsp), %r8d
movl 0x88(%rsp), %r9d
callq 0xa1a33
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/gfa_ut.cpp
// Function: init_ug_clean_t(ug_opt_t*, asg_t*, unsigned char, unsigned char, long, double, double, long)
ug_clean_t *init_ug_clean_t(ug_opt_t *uopt, asg_t *sg, uint8_t is_ou, uint8_t is_trio, int64_t max_ext, double len_rat, double ou_rat, int64_t min_ou)
{
    uint64_t i;
    ug_clean_t *sl; CALLOC(sl, 1);
    ma_ug_t *ug = ma_ug_gen(sg);
    for (i = 0; i < ug->g->n_seq; ++i) {
        if(ug->g->seq[i].del) continue;
        ug->g->seq[i].c = PRIMARY_LABLE;
    }
    MALLOC(sl->idx, (ug->g->n_seq<<1)); memset(sl->idx, -1, sizeof((*(sl->idx)))*(ug->g->n_seq<<1));
    MALLOC(sl->bid, (ug->g->n_seq<<1)); memset(sl->bid, -1, sizeof((*(sl->bid)))*(ug->g->n_seq<<1));
    sl->uopt = uopt; sl->sg = sg; sl->ug = ug; sl->idx_n = sl->bid_n = ug->g->n_seq<<1;
    memset(&(sl->b), 0, sizeof(sl->b)); CALLOC(sl->b.a, (ug->g->n_seq<<1));
    sl->is_ou = is_ou;
    sl->is_trio = is_trio;
    sl->max_ext = max_ext;
    sl->len_rat = len_rat;
    sl->ou_rat = ou_rat;
    sl->min_ou = min_ou;
    if(is_ou) update_ug_ou(sl->ug, sl->sg);
    return sl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r12
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2120
movq %rax, %r15
movq %rbx, %rdi
callq 0xb0285
movq %rax, %r14
movq 0x18(%rax), %rax
movl 0x14(%rax), %r13d
movl %r13d, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
je 0x21f8a1
movq 0x20(%rax), %rcx
xorl %edx, %edx
cmpl $0x0, (%rcx,%rdx,8)
js 0x21f88c
movb $0x0, 0x4(%rcx,%rdx,8)
incq %rdx
movl 0x14(%rax), %r13d
movl %r13d, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
cmpq %rsi, %rdx
jb 0x21f881
addl %esi, %esi
movslq %esi, %rdi
shlq $0x2, %rdi
callq 0x2280
movq %rax, 0x80(%r15)
addl %r13d, %r13d
movslq %r13d, %rdx
shlq $0x2, %rdx
movq %rax, %rdi
movl $0xff, %esi
callq 0x20e0
movq 0x18(%r14), %rax
movl 0x14(%rax), %eax
addl %eax, %eax
movslq %eax, %r13
shlq $0x2, %r13
movq %r13, %rdi
callq 0x2280
movq %rax, 0x88(%r15)
movq %rax, %rdi
movl $0xff, %esi
movq %r13, %rdx
callq 0x20e0
movq %r12, (%r15)
movq %rbx, 0x8(%r15)
movq %r14, 0x10(%r15)
movq 0x18(%r14), %rax
movl 0x14(%rax), %eax
addl %eax, %eax
movl %eax, 0x94(%r15)
movl %eax, 0x90(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movups %xmm0, 0x28(%r15)
movups %xmm0, 0x38(%r15)
movups %xmm0, 0x48(%r15)
movups %xmm0, 0x58(%r15)
movups %xmm0, 0x68(%r15)
movq $0x0, 0x78(%r15)
movslq %eax, %rdi
movl $0x1c, %esi
callq 0x2120
movq %rax, 0x18(%r15)
movb %bpl, 0x98(%r15)
movl 0x4(%rsp), %eax
movb %al, 0x99(%r15)
movq 0x8(%rsp), %rax
movq %rax, 0xa0(%r15)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0xb0(%r15)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0xb8(%r15)
movq 0x20(%rsp), %rax
movq %rax, 0xc0(%r15)
testb %bpl, %bpl
je 0x21f9b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb0169
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/gfa_ut.cpp
// Function: usg_topocut_aux_del(ma_ug_t*, unsigned int, int, asg64_v*)
int usg_topocut_aux_del(ma_ug_t *ug, uint32_t v, int max_ext, asg64_v *b)
{
	int32_t n_ext; 
	for (n_ext = 0; n_ext < max_ext && v != (uint32_t)-1; ) {
		if (usg_topocut_aux_unambi1(ug->g, v^1) == (uint32_t)-1) break;
        if(b) kv_push(uint64_t, *b, v); n_ext += ug->u.a[v>>1].n;
		v = usg_topocut_aux_unambi1(ug->g, v);
	}
	return n_ext;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
testl %edx, %edx
setle %al
cmpl $-0x1, %esi
sete %cl
xorl %r14d, %r14d
orb %al, %cl
jne 0x22005c
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r15
xorl %r14d, %r14d
movl $0x2, %r13d
movq 0x18(%r15), %rdi
movl %r12d, %esi
xorl $0x1, %esi
callq 0x21ff37
cmpl $-0x1, %eax
je 0x22005c
testq %rbx, %rbx
je 0x22002d
movq 0x8(%rbx), %rax
cmpq %rax, (%rbx)
jne 0x220018
leaq (%rax,%rax), %rsi
testq %rax, %rax
cmoveq %r13, %rsi
movq %rsi, 0x8(%rbx)
movq 0x10(%rbx), %rdi
shlq $0x3, %rsi
callq 0x2370
movq %rax, 0x10(%rbx)
movl %r12d, %eax
movq (%rbx), %rcx
movq 0x10(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, (%rbx)
movq %rax, (%rdx,%rcx,8)
movl %r12d, %eax
shrl %eax
leaq (%rax,%rax,4), %rax
movq 0x10(%r15), %rcx
movq 0x18(%r15), %rdi
addl 0x10(%rcx,%rax,8), %r14d
movl %r12d, %esi
callq 0x21ff37
cmpl $-0x1, %eax
je 0x22005c
movl %eax, %r12d
cmpl %ebp, %r14d
jl 0x21ffd6
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/gfa_ut.cpp
// Function: cal_utg_occ(ma_ug_t*, unsigned int)
uint32_t cal_utg_occ(ma_ug_t *ug, uint32_t begNode)
{
    uint32_t v = begNode, w, kv, occ = 0; ma_utg_t *u;

    while (1) {
        kv = get_real_length(ug->g, v, NULL);
        u = &(ug->u.a[v>>1]); occ += u->n; 
        if(kv!=1) break;
        ///kv must be 1 here
        kv = get_real_length(ug->g, v, &w);
        if(get_real_length(ug->g, w^1, NULL)!=1) break;
        v = w;
        if(v == begNode) break;
    }
    return occ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
movq 0x28(%rdx), %rdi
xorl %eax, %eax
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl %esi, %r9d
movl %r9d, %r10d
movq (%rdi,%r10,8), %r10
xorl %ebx, %ebx
movq %r10, %r11
andq %r8, %r11
je 0x2200de
movq 0x8(%rdx), %r14
movq %r10, %r15
shrq $0x20, %r15
leaq (%r15,%r15,2), %r15
leaq (%r14,%r15,8), %r14
addq $0xc, %r14
leaq (,%r11,8), %r15
leaq (%r15,%r15,2), %r15
xorl %r12d, %r12d
movl (%r14,%r12), %ebp
notl %ebp
shrl $0x1f, %ebp
addl %ebp, %ebx
addq $0x18, %r12
cmpq %r12, %r15
jne 0x2200c4
cmpl $0x1, %ebx
sete %bl
movl %r9d, %r14d
shrl %r14d
leaq (%r14,%r14,4), %r14
addl 0x10(%rcx,%r14,8), %eax
testb %bl, %bl
je 0x220191
testq %r11, %r11
je 0x22012d
movq 0x8(%rdx), %rbx
shrq $0x20, %r10
shlq $0x3, %r11
leaq (%r11,%r11,2), %r11
leaq (%r10,%r10,2), %r10
leaq (%rbx,%r10,8), %r10
addq $0xc, %r10
xorl %ebx, %ebx
cmpl $0x0, (%r10,%rbx)
js 0x220124
movl -0x4(%r10,%rbx), %r9d
addq $0x18, %rbx
cmpq %rbx, %r11
jne 0x220118
movl %r9d, %r10d
xorl $0x1, %r10d
movq (%rdi,%r10,8), %r10
movq %r10, %r11
andq %r8, %r11
je 0x220180
movq 0x8(%rdx), %rbx
shrq $0x20, %r10
leaq (%r10,%r10,2), %r10
leaq (%rbx,%r10,8), %r10
addq $0xc, %r10
shlq $0x3, %r11
leaq (%r11,%r11,2), %r11
xorl %ebx, %ebx
xorl %ebp, %ebp
movl (%r10,%rbx), %r14d
notl %r14d
shrl $0x1f, %r14d
addl %r14d, %ebp
addq $0x18, %rbx
cmpq %rbx, %r11
jne 0x220160
cmpl $0x1, %ebp
setne %r10b
jmp 0x220183
movb $0x1, %r10b
cmpl %esi, %r9d
je 0x220191
testb %r10b, %r10b
je 0x22008d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/huntzhan[P]SAM-PNG/solution.cc
// Function: CreateSAM(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
State *CreateSAM(const string &T) {
  auto start = new State;
  auto last = start;

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

  return start;
}

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

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

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

  nodes.push_back(node);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rsp, %rsi
movq %rdi, (%rsi)
movq %r14, %rdi
callq 0x3bea
testq %rax, %rax
jne 0x2801
leaq 0x10(%rsp), %r15
movq %r14, (%r15)
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3c66
movq (%r12), %rax
leaq 0x18(%rax), %rsi
xorl %ecx, %ecx
movq %rcx, (%r15)
movq 0x20(%rax), %rdx
movq %rdx, 0x8(%r15)
movq %rcx, 0x10(%r15)
movq 0x30(%rax), %rdx
movq %rdx, 0x18(%r15)
movups 0x38(%rax), %xmm0
movups %xmm0, 0x20(%r15)
movq %rcx, 0x30(%r15)
leaq 0x8(%rsp), %rdx
movq %r15, (%rdx)
movq %r15, %rdi
callq 0x38fc
movq 0x10(%r15), %r15
testq %r15, %r15
je 0x27d4
movq 0x10(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2738
movq (%r15), %r15
jmp 0x27bb
leaq 0x10(%rsp), %rdi
callq 0x3a4a
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x27f6
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x2801
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x3ee4
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3a4a
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/huntzhan[P]SAM-PNG/solution.cc
// Function: main
int main() {
  string T;
  fin >> T;

  auto start = CreateSAM(T);

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

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

  CreateDOTSource(nodes, T);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x78, %rsp
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x509c(%rip), %rdi      # 0x8160
leaq 0x20(%rsp), %rsi
callq 0x2140
leaq 0x20(%rsp), %rdi
callq 0x269f
leaq 0x70(%rsp), %rcx
movq %rcx, -0x30(%rcx)
movq $0x1, -0x28(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rcx)
movl $0x3f800000, -0x10(%rcx) # imm = 0x3F800000
movups %xmm0, -0x8(%rcx)
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
leaq 0x40(%rsp), %rsi
movq %rax, %rdi
callq 0x2738
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq %rcx, %rax
setne %dl
addq $-0x8, %rcx
cmpq %rax, %rcx
seta %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x315b
addq $0x8, %rax
movq -0x8(%rax), %rdx
movq (%rcx), %rsi
movq %rsi, -0x8(%rax)
movq %rdx, (%rcx)
addq $-0x8, %rcx
leaq 0x8(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0x313d
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x2822
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x317e
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x20e0
leaq 0x40(%rsp), %rdi
callq 0x3b7a
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x319f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x20e0
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
retq
jmp 0x31ab
movq %rax, %rbx
jmp 0x31d3
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x31c9
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x20e0
leaq 0x40(%rsp), %rdi
callq 0x3b7a
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x31ea
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x20e0
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/arturb-dev[P]CPP-Dynamic-Class-Loading/./dlclass.cpp
// Function: std::shared_ptr<Polygon> DLClass<Polygon>::make_obj<int>(int)
std::shared_ptr<T> DLClass<T>::make_obj(Args... args) {
    if(!shared->create || !shared->destroy) {
        if(!shared->open_module(module)) {
            return std::shared_ptr<T>(NULL);
        }
    }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
movq 0x20(%rsi), %r14
cmpq $0x0, (%r14)
je 0x2675
cmpq $0x0, 0x8(%r14)
jne 0x26ba
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %r13
movq %r13, %rdi
callq 0x28da
movq %r14, %rdi
movq %r13, %rsi
callq 0x2a40
movl %eax, %r14d
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x26b5
callq 0x20e0
testb %r14b, %r14b
je 0x26db
movq 0x20(%r12), %r13
movq 0x28(%r12), %r14
testq %r14, %r14
je 0x26e8
movq 0x28f8(%rip), %rax      # 0x4fc8
cmpb $0x0, (%rax)
je 0x26e3
incl 0x8(%r14)
jmp 0x26e8
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x2740
lock
incl 0x8(%r14)
movq 0x20(%r12), %rax
movl %r15d, %edi
callq *(%rax)
movq %r13, -0x38(%rbp)
movq %r14, -0x30(%rbp)
testq %r14, %r14
je 0x2716
movq 0x28c2(%rip), %rcx      # 0x4fc8
cmpb $0x0, (%rcx)
je 0x2711
incl 0x8(%r14)
jmp 0x2716
lock
incl 0x8(%r14)
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2bc2
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x2733
callq 0x27c6
testq %r14, %r14
je 0x2740
movq %r14, %rdi
callq 0x27c6
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x278c
callq 0x20e0
jmp 0x278c
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x277f
callq 0x27c6
jmp 0x277f
movq %rax, %rbx
testq %r14, %r14
je 0x278c
movq %r14, %rdi
callq 0x27c6
movq %rbx, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2a1d
callq 0x2090
movq $0x0, 0x10(%rbx)
cmpq $0x0, (%rbx)
je 0x2a2a
movq $0x0, (%rbx)
cmpq $0x0, 0x8(%rbx)
je 0x2a39
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/arturb-dev[P]CPP-Dynamic-Class-Loading/./dlclass.cpp
// Function: DLClass<Polygon>::shared_obj::open_module(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool DLClass<T>::shared_obj::open_module(std::string module) {
    
    dll_handle = dlopen(module.c_str(), RTLD_LAZY);

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

    // Reset errors
    dlerror();

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

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rdi
movl $0x1, %esi
callq 0x2120
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x2aa0
callq 0x20d0
movq 0x10(%rbx), %rdi
leaq 0x64a(%rip), %rsi       # 0x30bd
callq 0x20c0
movq %rax, (%rbx)
callq 0x20d0
testq %rax, %rax
je 0x2aeb
movq %rax, %r15
movq 0x2561(%rip), %r14      # 0x4ff0
leaq 0x62e(%rip), %rsi       # 0x30c4
movl $0x1e, %edx
jmp 0x2b23
movq 0x2549(%rip), %rbx      # 0x4ff0
leaq 0x5f6(%rip), %rsi       # 0x30a4
movl $0x18, %edx
movq %rbx, %rdi
callq 0x2110
callq 0x20d0
testq %rax, %rax
je 0x2b72
movq %rax, %r14
movq %rax, %rdi
callq 0x2060
movq 0x2515(%rip), %rdi      # 0x4ff0
movq %r14, %rsi
movq %rax, %rdx
callq 0x2110
jmp 0x2b89
movq 0x10(%rbx), %rdi
leaq 0x5ed(%rip), %rsi       # 0x30e3
callq 0x20c0
movq %rax, 0x8(%rbx)
callq 0x20d0
testq %rax, %rax
je 0x2bbd
movq %rax, %r15
movq 0x24d9(%rip), %r14      # 0x4ff0
leaq 0x5cd(%rip), %rsi       # 0x30eb
movl $0x1f, %edx
movq %r14, %rdi
callq 0x2110
movq %r15, %rdi
callq 0x2060
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2110
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x29fe
jmp 0x2bb0
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2070
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
jmp 0x2bb2
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4c64(%rip), %xmm0     # 0xa400
leaq 0x20(%rsp), %rsi
movaps %xmm0, 0x20(%rsi)
movups 0x4c44(%rip), %xmm0     # 0xa3f0
movaps %xmm0, 0x10(%rsi)
movups 0x4c29(%rip), %xmm0     # 0xa3e0
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0xc, %edx
callq 0x6244
testb $0x3, %bl
sete %al
imull $0xc28f5c29, %ebx, %ecx # imm = 0xC28F5C29
addl $0x51eb850, %ecx        # imm = 0x51EB850
rorl $0x2, %ecx
cmpl $0x28f5c29, %ecx        # imm = 0x28F5C29
setae %cl
testb %cl, %al
jne 0x5813
movslq %ebx, %rax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x27, %rax
addl %ecx, %eax
imull $0x190, %eax, %eax      # imm = 0x190
movl %ebx, %ecx
subl %eax, %ecx
jne 0x5835
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq $0x2, %rdx
jb 0x58b0
movl $0x1d, 0x4(%rax)
movabsq $-0x100000000, %rsi     # imm = 0xFFFFFFFF00000000
addq %r14, %rsi
sarq $0x20, %rsi
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
subq %rdi, %rdx
sarq $0x2, %rdx
cmpq %rsi, %rdx
jbe 0x58b5
movl (%rdi,%rsi,4), %ebp
testq %rdi, %rdi
je 0x5871
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2150
movq %r14, %rax
shrq $0x20, %rax
xorl %ecx, %ecx
cmpl %r14d, %ebp
setl %cl
movl %r14d, %edx
movl $0x1, %esi
cmovgeq %rdx, %rsi
addl %eax, %ecx
xorl %edx, %edx
cmpl $0xd, %ecx
setge %dl
movl $0x1, %eax
cmovll %ecx, %eax
shlq $0x20, %rax
orq %rsi, %rax
addl %ebx, %edx
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x1, %esi
leaq 0x497b(%rip), %rdi      # 0xa237
xorl %eax, %eax
callq 0x21c0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x58dd
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movups 0x4ad3(%rip), %xmm0     # 0xa400
leaq 0x20(%rsp), %rsi
movaps %xmm0, 0x20(%rsi)
movups 0x4ab3(%rip), %xmm0     # 0xa3f0
movaps %xmm0, 0x10(%rsi)
movups 0x4a98(%rip), %xmm0     # 0xa3e0
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0xc, %edx
callq 0x6244
movl 0x8(%rbx), %ecx
testb $0x3, %cl
sete %al
imull $0xc28f5c29, %ecx, %edx # imm = 0xC28F5C29
addl $0x51eb850, %edx        # imm = 0x51EB850
movl %edx, %ecx
rorl $0x2, %ecx
cmpl $0x28f5c29, %ecx        # imm = 0x28F5C29
setae %cl
rorl $0x4, %edx
cmpl $0xa3d70b, %edx         # imm = 0xA3D70B
jb 0x5991
andb %cl, %al
je 0x59af
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq $0x2, %rdx
jb 0x5a0d
movl $0x1d, 0x4(%rax)
movl (%rbx), %ecx
leal 0x1(%rcx), %eax
movl %eax, (%rbx)
movslq 0x4(%rbx), %rax
leaq -0x1(%rax), %rsi
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
subq %rdi, %rdx
sarq $0x2, %rdx
cmpq %rsi, %rdx
jbe 0x5a12
cmpl -0x4(%rdi,%rax,4), %ecx
jl 0x59e5
incl %eax
movl %eax, 0x4(%rbx)
movl $0x1, (%rbx)
cmpl $0xd, 0x4(%rbx)
jl 0x59f5
incl 0x8(%rbx)
movl $0x1, 0x4(%rbx)
testq %rdi, %rdi
je 0x5a07
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2150
addq $0x50, %rsp
popq %rbx
retq
movl $0x1, %esi
leaq 0x481e(%rip), %rdi      # 0xa237
xorl %eax, %eax
callq 0x21c0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x5a3a
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq %rsi, %rax
shrq $0x20, %rax
cmpl %eax, 0x4(%rdi)
setl %cl
sete %dl
cmpl %esi, (%rdi)
setl %al
andb %dl, %al
orb %cl, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq %rsi, %rax
shrq $0x20, %rax
cmpl %eax, 0x4(%rdi)
setg %cl
sete %dl
cmpl %esi, (%rdi)
setg %al
andb %dl, %al
orb %cl, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/pc260533[P]ITC313-TP1/chambre.cpp
// Function: Chambre::getTypeDeChambreToString[abi:cxx11](TypeDeChambre)
std::string Chambre::getTypeDeChambreToString(TypeDeChambre typeDeChambre) {
    std::string res = "";
    switch (typeDeChambre) {
        case TypeDeChambre::Simple:
            res = "Simple";
            break;
        case TypeDeChambre::Double:
            res = "Double";
            break;
        case TypeDeChambre::Suite:
            res = "Suite";
            break;
    }
    return res;
}

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rsp, %rdi
xorl %edx, %edx
callq 0x6a4e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x767a
leaq 0x10(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x6b30
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rsp, %rdi
movl $0x1, %edx
callq 0x6a4e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x767a
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6b5e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rsp, %rdi
movl $0x2, %edx
callq 0x6a4e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x767a
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6b8c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x6b9d
jmp 0x6bcd
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
jne 0x6bbe
jmp 0x6bd0
jmp 0x6bcd
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6bd0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2150
jmp 0x6bd0
movq %rax, %r14
movq %rbx, %rdi
callq 0x42a8
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3838(%rip), %rsi      # 0xa423
movq %rbx, %rdi
callq 0x2060
testl %eax, %eax
je 0x6c26
leaq 0x382c(%rip), %rsi      # 0xa42a
movq %rbx, %rdi
callq 0x2060
testl %eax, %eax
je 0x6c2a
leaq 0x3820(%rip), %rsi      # 0xa431
movq %rbx, %rdi
callq 0x2060
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
addl %eax, %eax
jmp 0x6c2f
xorl %eax, %eax
jmp 0x6c2f
movl $0x1, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6aca
xorl %r12d, %r12d
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
xorl %ebx, %ebx
xorl %ebp, %ebp
movq 0x60(%r15), %rdi
movq 0x68(%r15), %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
imulq %r13, %rdx
cmpq %rbx, %rdx
jae 0x7bd7
movb $0x1, %bpl
jmp 0x7c67
jbe 0x7c8a
addq %r12, %rdi
callq 0x6a44
testb %al, %al
jne 0x7c67
movq 0x60(%r15), %rdi
movq 0x68(%r15), %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
imulq %r13, %rdx
cmpq %rbx, %rdx
jbe 0x7c8a
addq %r12, %rdi
callq 0x6a30
cmpl 0x4(%rsp), %eax
jne 0x7c67
movq 0x60(%r15), %rdi
movq 0x68(%r15), %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
imulq %r13, %rdx
cmpq %rbx, %rdx
jbe 0x7c8a
addq %r12, %rdi
movl $0x1, %esi
callq 0x6a48
movq 0x60(%r15), %rax
movq 0x68(%r15), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %r13, %rdx
cmpq %rbx, %rdx
jbe 0x7c8a
movb 0x10(%rax,%r12), %cl
movb %cl, 0x10(%r14)
movups (%rax,%r12), %xmm0
movups %xmm0, (%r14)
jmp 0x7bcf
incq %rbx
addq $0x18, %r12
testb $0x1, %bpl
je 0x7bb7
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x25a6(%rip), %rdi      # 0xa237
movq %rbx, %rsi
xorl %eax, %eax
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/pc260533[P]ITC313-TP1/reservation.cpp
// Function: Reservation::setPeriodeDeReservation(Date, Date)
bool Reservation::setPeriodeDeReservation(Date dateDebut, Date dateFin) {
    bool res = false;
    if (dateDebut.estAvantDate(dateFin)) {
        res = true;
        this->dateDebutReservation = dateDebut;
        this->dateFinReservation = dateFin;
    }
    this->calculMontantTotal();
    return res;
}

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

  int length = 0;

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

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

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

  int length = 0;

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebp
movl %esi, (%rdi)
leaq 0x8(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movslq %esi, %r14
leaq 0x30(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movq %r14, %rsi
callq 0x32aa
leaq 0x18(%rsp), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x3268
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2dfb
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
testl %ebp, %ebp
jle 0x2e73
movl %ebp, %r14d
xorl %r15d, %r15d
xorl %r13d, %r13d
leaq (,%r13,2), %rbp
addq %r13, %rbp
movq %r13, 0x10(%rsp)
xorl %ebx, %ebx
movl $0x38, %edi
callq 0x2150
movq %r13, (%rax)
movq %rax, %rcx
addq $0x10, %rcx
movl $0x0, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rcx, 0x28(%rax)
movq %r15, 0x30(%rax)
movq (%r12), %rcx
movq (%rcx,%rbp,8), %rcx
movq %rax, (%rcx,%rbx,8)
incq %rbx
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %r13
cmpq %rbx, %r14
jne 0x2e1a
movq 0x10(%rsp), %r13
incq %r13
cmpq %r14, %r13
jne 0x2e08
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2ea3
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
jmp 0x2ea3
jmp 0x2ea0
movq %rax, %r14
movq %r12, %rdi
callq 0x3328
movq %r14, %rdi
callq 0x2240
nop