LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Infinidat[P]slimfastq/usrs.cpp
// Function: UsrSave::load_page()
void UsrSave::load_page() {

    size_t size  = m_end - m_cur ;
    assert(size <= PLL_STRT);
    size_t start = PLL_STRT - size;
    for (size_t i = 0 ; i < size; i++)
        m_buff[start+i] = m_buff[m_cur+i];

    likely_if (mp.rec != NULL) {
        UCHAR* pl = mp_last;
        for (UCHAR* p = mp.rec; p < mp.rec_end; p++ , pl++)
            *pl = *p;
        mp.rec = mp_last;
        mp.rec_end = pl;
        *pl++ = '\n';           // Just in case
        *pl   = 0;              // clean debug
    }

    size_t cnt = fread(&m_buff[PLL_STRT], 1, PLL_SIZE, m_in);
    m_cur  = start;
    m_end = PLL_STRT + cnt  ;

    if (m_cur == m_end)
        m_valid = false;
    else
        m_page_count++;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movl 0x12404c(%rcx), %eax
subl 0x124048(%rcx), %eax
cltq
movq %rax, 0x38(%rsp)
cmpq $0x24000, 0x38(%rsp)    # imm = 0x24000
ja 0xcc03
jmp 0xcc22
leaq 0x4710(%rip), %rdi      # 0x1131a
leaq 0x471a(%rip), %rsi      # 0x1132b
movl $0x63, %edx
leaq 0x4717(%rip), %rcx      # 0x11334
callq 0x21b0
movl $0x24000, %eax          # imm = 0x24000
subq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0xcc79
movq 0x8(%rsp), %rax
movslq 0x124048(%rax), %rcx
addq 0x28(%rsp), %rcx
movb 0x31(%rax,%rcx), %dl
movq 0x30(%rsp), %rcx
addq 0x28(%rsp), %rcx
movb %dl, 0x31(%rax,%rcx)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0xcc3a
movq 0x8(%rsp), %rax
cmpq $0x0, 0x1240a0(%rax)
je 0xcd29
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1240d0, %rcx         # imm = 0x1240D0
movq %rcx, 0x20(%rsp)
movq 0x1240a0(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
cmpq 0x1240a8(%rcx), %rax
jae 0xcceb
movq 0x18(%rsp), %rax
movb (%rax), %cl
movq 0x20(%rsp), %rax
movb %cl, (%rax)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0xccac
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1240d0, %rcx         # imm = 0x1240D0
movq %rcx, 0x1240a0(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x1240a8(%rax)
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rsp)
movb $0xa, (%rax)
movq 0x20(%rsp), %rax
movb $0x0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x31, %rdi
addq $0x24000, %rdi          # imm = 0x24000
movq 0x124050(%rax), %rcx
movl $0x1, %esi
movl $0x100000, %edx         # imm = 0x100000
callq 0x23a0
movq 0x8(%rsp), %rcx
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movl %eax, 0x124048(%rcx)
movq 0x10(%rsp), %rax
addq $0x24000, %rax          # imm = 0x24000
movl %eax, 0x12404c(%rcx)
movl 0x124048(%rcx), %eax
cmpl 0x12404c(%rcx), %eax
jne 0xcd91
movq 0x8(%rsp), %rax
movb $0x0, 0x30(%rax)
jmp 0xcda8
movq 0x8(%rsp), %rax
movq 0x124040(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x124040(%rax)
addq $0x48, %rsp
retq
nopl (%rax)
// File: Infinidat[P]slimfastq/usrs.cpp
// Function: UsrSave::update(UsrBase::exception_t, unsigned short)
void UsrSave::update(exception_t type, UINT16 dat) {
    switch (type) {
    case ET_LLEN:
        x_llen -> put ( g_record_count - m_last.i_llen );
        x_llen -> put ( dat );
        m_last.i_llen = g_record_count;
        m_llen = dat;
        break;

    case ET_QLEN:
        x_qlen -> put( g_record_count - m_last.i_qlen );
        x_qlen -> put( dat );
        m_last.i_qlen = g_record_count;
        // m_qlen = dat;
        break;

    case ET_SOLPF_GEN:
        x_sgen->put( g_record_count - m_last.i_sgen);
        x_sgen->put_chr( dat );
        m_last.i_sgen = g_record_count;
        m_last.solid_pf_gen = dat;
        break;

    case ET_SOLPF_QLT:
        x_sqlt->put( g_record_count - m_last.i_sqlt);
        x_sqlt->put_chr( dat );
        m_last.i_sqlt = g_record_count;
        m_last.solid_pf_qlt = dat;
        break;

    default : assert(0);
    }
}

// Assembly:
subq $0x28, %rsp
movw %dx, %ax
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movw %ax, 0x1a(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %eax
movq %rax, 0x10(%rsp)
subq $0x3, %rax
ja 0xd878
movq 0x10(%rsp), %rax
leaq 0x3b5e(%rip), %rcx      # 0x1127c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rax
movq 0x124068(%rax), %rdi
leaq 0x8b26(%rip), %rcx      # 0x16260
movq (%rcx), %rsi
subq (%rax), %rsi
callq 0xf7a0
movq 0x8(%rsp), %rax
movq 0x124068(%rax), %rdi
movzwl 0x1a(%rsp), %eax
movl %eax, %esi
callq 0xf7a0
movq 0x8(%rsp), %rax
leaq 0x8af7(%rip), %rcx      # 0x16260
movq (%rcx), %rcx
movq %rcx, (%rax)
movzwl 0x1a(%rsp), %ecx
movl %ecx, 0x12405c(%rax)
jmp 0xd897
movq 0x8(%rsp), %rax
movq 0x124070(%rax), %rdi
leaq 0x8ace(%rip), %rcx      # 0x16260
movq (%rcx), %rsi
subq 0x8(%rax), %rsi
callq 0xf7a0
movq 0x8(%rsp), %rax
movq 0x124070(%rax), %rdi
movzwl 0x1a(%rsp), %eax
movl %eax, %esi
callq 0xf7a0
movq 0x8(%rsp), %rax
leaq 0x8a9e(%rip), %rcx      # 0x16260
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0xd897
movq 0x8(%rsp), %rax
movq 0x124078(%rax), %rdi
leaq 0x8a7f(%rip), %rcx      # 0x16260
movq (%rcx), %rsi
subq 0x10(%rax), %rsi
callq 0xf7a0
movq 0x8(%rsp), %rax
movq 0x124078(%rax), %rdi
movw 0x1a(%rsp), %ax
movzbl %al, %esi
callq 0xf990
movq 0x8(%rsp), %rax
leaq 0x8a4e(%rip), %rcx      # 0x16260
movq (%rcx), %rcx
movq %rcx, 0x10(%rax)
movw 0x1a(%rsp), %cx
movb %cl, 0x28(%rax)
jmp 0xd897
movq 0x8(%rsp), %rax
movq 0x124080(%rax), %rdi
leaq 0x8a2a(%rip), %rcx      # 0x16260
movq (%rcx), %rsi
subq 0x18(%rax), %rsi
callq 0xf7a0
movq 0x8(%rsp), %rax
movq 0x124080(%rax), %rdi
movw 0x1a(%rsp), %ax
movzbl %al, %esi
callq 0xf990
movq 0x8(%rsp), %rax
leaq 0x89f9(%rip), %rcx      # 0x16260
movq (%rcx), %rcx
movq %rcx, 0x18(%rax)
movw 0x1a(%rsp), %cx
movb %cl, 0x29(%rax)
jmp 0xd897
leaq 0x34f7(%rip), %rdi      # 0x10d76
leaq 0x3aa5(%rip), %rsi      # 0x1132b
movl $0x9a, %edx
leaq 0x3abc(%rip), %rcx      # 0x1134e
callq 0x21b0
addq $0x28, %rsp
retq
nopl (%rax)
// File: Infinidat[P]slimfastq/usrs.cpp
// Function: UsrSave::encode()
int UsrSave::encode() {

    UINT32  sanity = conf.profiling ? 100000 : 3000000000;

    RecSave rec;
    GenSave gen;
    QltSave qlt;

    while( ++ g_record_count < sanity  and get_record() ) {
        gen.save(mp.gen, mp.qlt, m_llen, m_qlen);
        rec.save(mp.rec, mp.rec_end, mp.prev_rec, mp.prev_rec_end);
        qlt.save(mp.qlt, m_qlen);
    }
    conf.set_info("num_records", g_record_count-1);
    return 0;
}

// Assembly:
subq $0xc8a58, %rsp          # imm = 0xC8A58
movq %rdi, 0xc8a50(%rsp)
movq 0xc8a50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xa30d(%rip), %rax      # 0x183e0
movb 0xd(%rax), %al
testb $0x1, %al
movl $0x186a0, %ecx          # imm = 0x186A0
movl $0xb2d05e00, %eax       # imm = 0xB2D05E00
cmovnel %ecx, %eax
movl %eax, 0xc8a4c(%rsp)
leaq 0x3d0(%rsp), %rdi
callq 0xa330
leaq 0x370(%rsp), %rdi
callq 0x7b80
jmp 0xe108
leaq 0x10(%rsp), %rdi
callq 0x8fd0
jmp 0xe114
jmp 0xe116
leaq 0x8143(%rip), %rax      # 0x16260
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x8135(%rip), %rax      # 0x16260
movq %rcx, (%rax)
movl 0xc8a4c(%rsp), %eax
movl %eax, %edx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0x7(%rsp)
jae 0xe15c
movq 0x8(%rsp), %rdi
callq 0xdb50
movb %al, 0x6(%rsp)
jmp 0xe152
movb 0x6(%rsp), %al
movb %al, 0x7(%rsp)
jmp 0xe15c
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0xe169
jmp 0xe23c
movq 0x8(%rsp), %rax
movq 0x1240c0(%rax), %rsi
movq 0x1240c8(%rax), %rdx
movslq 0x12405c(%rax), %rcx
movslq 0x124060(%rax), %r8
leaq 0x370(%rsp), %rdi
callq 0xf2e0
jmp 0xe199
movq 0x8(%rsp), %rax
movq 0x1240a0(%rax), %rsi
movq 0x1240a8(%rax), %rdx
movq 0x1240b0(%rax), %rcx
movq 0x1240b8(%rax), %r8
leaq 0x3d0(%rsp), %rdi
callq 0xae60
jmp 0xe1c9
movq 0x8(%rsp), %rax
movq 0x1240c8(%rax), %rsi
movslq 0x124060(%rax), %rdx
leaq 0x10(%rsp), %rdi
callq 0xf3b0
jmp 0xe1e8
jmp 0xe116
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x368(%rsp)
movl %eax, 0x364(%rsp)
jmp 0xe299
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x368(%rsp)
movl %eax, 0x364(%rsp)
jmp 0xe28c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x368(%rsp)
movl %eax, 0x364(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x91b0
jmp 0xe28c
leaq 0x801d(%rip), %rax      # 0x16260
movq (%rax), %rdx
decq %rdx
leaq 0xa190(%rip), %rdi      # 0x183e0
leaq 0x32ac(%rip), %rsi      # 0x11503
callq 0x3dd0
jmp 0xe25e
leaq 0x10(%rsp), %rdi
callq 0x91b0
leaq 0x370(%rsp), %rdi
callq 0x7e50
leaq 0x3d0(%rsp), %rdi
callq 0xa4a0
xorl %eax, %eax
addq $0xc8a58, %rsp          # imm = 0xC8A58
retq
leaq 0x370(%rsp), %rdi
callq 0x7e50
leaq 0x3d0(%rsp), %rdi
callq 0xa4a0
movq 0x368(%rsp), %rdi
callq 0x23f0
nopw %cs:(%rax,%rax)
// File: Infinidat[P]slimfastq/usrs.cpp
// Function: UsrLoad::~UsrLoad()
UsrLoad::~UsrLoad() {
    DELETE(x_llen);
    DELETE(x_qlen);
    DELETE(x_sgen);
    DELETE(x_sqlt);

    DELETE(x_lgen);
    DELETE(x_lqlt);
    DELETE(x_lrec);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpq $0x0, 0x24080(%rax)
je 0xe7d4
movq 0x38(%rsp), %rax
movq 0x24080(%rax), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, %rax
je 0xe7d2
movq 0x30(%rsp), %rdi
callq 0xf840
movq 0x30(%rsp), %rdi
movl $0x2db0, %esi           # imm = 0x2DB0
callq 0x2290
jmp 0xe7d4
movq 0x38(%rsp), %rax
movq $0x0, 0x24080(%rax)
jmp 0xe7e6
jmp 0xe7e8
movq 0x38(%rsp), %rax
cmpq $0x0, 0x24088(%rax)
je 0xe829
movq 0x38(%rsp), %rax
movq 0x24088(%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0xe827
movq 0x28(%rsp), %rdi
callq 0xf840
movq 0x28(%rsp), %rdi
movl $0x2db0, %esi           # imm = 0x2DB0
callq 0x2290
jmp 0xe829
movq 0x38(%rsp), %rax
movq $0x0, 0x24088(%rax)
jmp 0xe83b
jmp 0xe83d
movq 0x38(%rsp), %rax
cmpq $0x0, 0x24090(%rax)
je 0xe87e
movq 0x38(%rsp), %rax
movq 0x24090(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0xe87c
movq 0x20(%rsp), %rdi
callq 0xf840
movq 0x20(%rsp), %rdi
movl $0x2db0, %esi           # imm = 0x2DB0
callq 0x2290
jmp 0xe87e
movq 0x38(%rsp), %rax
movq $0x0, 0x24090(%rax)
jmp 0xe890
jmp 0xe892
movq 0x38(%rsp), %rax
cmpq $0x0, 0x24098(%rax)
je 0xe8d3
movq 0x38(%rsp), %rax
movq 0x24098(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0xe8d1
movq 0x18(%rsp), %rdi
callq 0xf840
movq 0x18(%rsp), %rdi
movl $0x2db0, %esi           # imm = 0x2DB0
callq 0x2290
jmp 0xe8d3
movq 0x38(%rsp), %rax
movq $0x0, 0x24098(%rax)
jmp 0xe8e5
jmp 0xe8e7
movq 0x38(%rsp), %rax
cmpq $0x0, 0x240a0(%rax)
je 0xe928
movq 0x38(%rsp), %rax
movq 0x240a0(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0xe926
movq 0x10(%rsp), %rdi
callq 0xf840
movq 0x10(%rsp), %rdi
movl $0x2db0, %esi           # imm = 0x2DB0
callq 0x2290
jmp 0xe928
movq 0x38(%rsp), %rax
movq $0x0, 0x240a0(%rax)
jmp 0xe93a
jmp 0xe93c
movq 0x38(%rsp), %rax
cmpq $0x0, 0x240a8(%rax)
je 0xe97d
movq 0x38(%rsp), %rax
movq 0x240a8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xe97b
movq 0x8(%rsp), %rdi
callq 0xf840
movq 0x8(%rsp), %rdi
movl $0x2db0, %esi           # imm = 0x2DB0
callq 0x2290
jmp 0xe97d
movq 0x38(%rsp), %rax
movq $0x0, 0x240a8(%rax)
jmp 0xe98f
jmp 0xe991
movq 0x38(%rsp), %rax
cmpq $0x0, 0x240b0(%rax)
je 0xe9cf
movq 0x38(%rsp), %rax
movq 0x240b0(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xe9cd
movq (%rsp), %rdi
callq 0xf840
movq (%rsp), %rdi
movl $0x2db0, %esi           # imm = 0x2DB0
callq 0x2290
jmp 0xe9cf
movq 0x38(%rsp), %rax
movq $0x0, 0x240b0(%rax)
jmp 0xe9e1
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Infinidat[P]slimfastq/usrs.cpp
// Function: UsrLoad::save()
void UsrLoad::save() {

    UCHAR* p_rec = flip ? m_rep : m_rec ;
    flip = flip ? 0 : 1 ;

    putline(p_rec, m_rec_size+1);
    if (m_2nd_rec) {
        putline(m_gen_ptr, m_llen + m_llen_factor);
        p_rec[0] = '+';
        putline(p_rec, m_rec_size+1);
        p_rec[0] = '@';
    }
    else {
        putline(m_gen_ptr, m_llen + m_llen_factor + 2);
    }
    putline(m_qlt_ptr, m_qlen + m_llen_factor);

}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, 0x60(%rax)
je 0xed39
movq 0x10(%rsp), %rax
addq $0x61, %rax
movq %rax, 0x8(%rsp)
jmp 0xed49
movq 0x10(%rsp), %rax
addq $0x2062, %rax           # imm = 0x2062
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movb 0x60(%rdi), %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x60(%rdi)
movq 0x18(%rsp), %rsi
movl 0x54(%rdi), %edx
addl $0x1, %edx
callq 0xee10
movq 0x10(%rsp), %rax
testb $0x1, 0x50(%rax)
je 0xedd0
movq 0x10(%rsp), %rdi
movq 0x24078(%rdi), %rsi
movq 0x38(%rdi), %rax
addq 0x40(%rdi), %rax
movl %eax, %edx
callq 0xee10
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movb $0x2b, (%rax)
movq 0x18(%rsp), %rsi
movl 0x54(%rdi), %edx
addl $0x1, %edx
callq 0xee10
movq 0x18(%rsp), %rax
movb $0x40, (%rax)
jmp 0xedef
movq 0x10(%rsp), %rdi
movq 0x24078(%rdi), %rsi
movq 0x38(%rdi), %rax
addq 0x40(%rdi), %rax
addq $0x2, %rax
movl %eax, %edx
callq 0xee10
movq 0x10(%rsp), %rdi
movq 0x24070(%rdi), %rsi
movq 0x48(%rdi), %rax
addq 0x40(%rdi), %rax
movl %eax, %edx
callq 0xee10
addq $0x28, %rsp
retq
nop
// File: Infinidat[P]slimfastq/usrs.cpp
// Function: UsrLoad::putline(unsigned char*, unsigned int)
void UsrLoad::putline(UCHAR* buf, UINT32 size) {
    buf[size++] = '\n';
    size_t cnt = fwrite(buf, 1, size, m_out);

    rarely_if (cnt != size)
        croak("USR: Error writing output");
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movl 0x14(%rsp), %edx
movl %edx, %esi
addl $0x1, %esi
movl %esi, 0x14(%rsp)
movl %edx, %edx
movb $0xa, (%rcx,%rdx)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %ecx
movl %ecx, %edx
movq 0x30(%rax), %rcx
movl $0x1, %esi
callq 0x2420
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
cmpq %rcx, %rax
je 0xee79
leaq 0x269d(%rip), %rdi      # 0x1150f
movb $0x0, %al
callq 0x3450
addq $0x28, %rsp
retq
nop
// File: Infinidat[P]slimfastq/usrs.cpp
// Function: UsrSave::load_check()
void UsrSave::load_check() {
    likely_if (m_cur+PLL_STRT < m_end)
        return;
    for (int i = m_cur, cnt=0; i < m_end; i++)
        if (m_buff[i] == '\n')
            if (++cnt >= 4)
                return;
    load_page();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x124048(%rcx), %eax
addl $0x24000, %eax          # imm = 0x24000
cmpl 0x12404c(%rcx), %eax
jge 0xf1e7
jmp 0xf24c
movq (%rsp), %rax
movl 0x124048(%rax), %eax
movl %eax, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x12404c(%rcx), %eax
jge 0xf243
movq (%rsp), %rax
movslq 0xc(%rsp), %rcx
movzbl 0x31(%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0xf234
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
cmpl $0x4, %eax
jl 0xf232
jmp 0xf24c
jmp 0xf234
jmp 0xf236
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xf1fd
movq (%rsp), %rdi
callq 0xcbd0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Infinidat[P]slimfastq/./qlts.hpp
// Function: QltSave::save(unsigned char const*, unsigned long)
inline void save(const UCHAR* buf, size_t size) {
        switch(conf.level) {
        default:
        case 1: return save_1(buf, size);
        case 2: return save_2(buf, size);
        case 3:
        case 4: return save_3(buf, size);
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
leaq 0x900d(%rip), %rax      # 0x183e0
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x1, %eax
je 0xf3fc
jmp 0xf3e1
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0xf411
jmp 0xf3ec
movl 0xc(%rsp), %eax
addl $-0x3, %eax
subl $0x2, %eax
jb 0xf426
jmp 0xf3fa
jmp 0xf3fc
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x92e0
jmp 0xf439
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x9400
jmp 0xf439
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x9520
addq $0x28, %rsp
retq
nop
// File: Infinidat[P]slimfastq/./qlts.hpp
// Function: QltLoad::load(unsigned char*, unsigned long)
inline UINT32 load(UCHAR* buffer, const size_t size) {
        switch(conf.level) {
        default:
        case 1: return load_1(buffer, size);
        case 2: return load_2(buffer, size);
        case 3:
        case 4: return load_3(buffer, size);
        }
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x8f7c(%rip), %rax      # 0x183e0
movl 0x4(%rax), %eax
movl %eax, 0x14(%rsp)
subl $0x1, %eax
je 0xf48d
jmp 0xf472
movl 0x14(%rsp), %eax
subl $0x2, %eax
je 0xf4a7
jmp 0xf47d
movl 0x14(%rsp), %eax
addl $-0x3, %eax
subl $0x2, %eax
jb 0xf4c1
jmp 0xf48b
jmp 0xf48d
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x9920
movl %eax, 0x34(%rsp)
jmp 0xf4d9
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x9a30
movl %eax, 0x34(%rsp)
jmp 0xf4d9
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x9b50
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Infinidat[P]slimfastq/./gens.hpp
// Function: GenBase::get_mask() const
inline UINT64 get_mask() const {
        switch (conf.level) {
        default:
        case 1: return BRANGER_MASK_1;
        case 2: return BRANGER_MASK_2;
        case 3: return BRANGER_MASK_3;
        case 4: return BRANGER_MASK_4;
        }
    }

// Assembly:
movq %rdi, -0x10(%rsp)
leaq 0x8e04(%rip), %rax      # 0x183e0
movl 0x4(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rsp)
subl $0x3, %eax
ja 0xf602
movq -0x18(%rsp), %rax
leaq 0x1c93(%rip), %rcx      # 0x1128c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xf604
movq $0x3ffff, -0x8(%rsp)    # imm = 0x3FFFF
jmp 0xf62e
movq $0x3fffff, -0x8(%rsp)   # imm = 0x3FFFFF
jmp 0xf62e
movq $0xffffff, -0x8(%rsp)   # imm = 0xFFFFFF
jmp 0xf62e
movq $0x3ffffff, -0x8(%rsp)  # imm = 0x3FFFFFF
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
nop
// File: Infinidat[P]slimfastq/xfile.cpp
// Function: XFileSave::~XFileSave()
XFileSave::~XFileSave() {
    if (filer) {
        put(0);                 // no more exceptions
        rcoder.done();
        delete filer;
        filer = NULL;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x2da8(%rax)
je 0xf77a
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xf7a0
jmp 0xf72d
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0x2d40
jmp 0xf73d
movq 0x8(%rsp), %rax
movq 0x2da8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xf76a
movq (%rsp), %rdi
callq 0x6ed0
movq (%rsp), %rdi
movl $0x4040, %esi           # imm = 0x4040
callq 0x2290
movq 0x8(%rsp), %rax
movq $0x0, 0x2da8(%rax)
movq 0x8(%rsp), %rdi
callq 0xfd10
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x2d30
nopw %cs:(%rax,%rax)
// File: Infinidat[P]slimfastq/xfile.cpp
// Function: XFileLoad::~XFileLoad()
XFileLoad::~XFileLoad() {
    if (filer) {
        rcoder.done();
        delete filer;
        filer = NULL;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x2da8(%rax)
je 0xf8aa
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0x2d40
jmp 0xf86d
movq 0x8(%rsp), %rax
movq 0x2da8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xf89a
movq (%rsp), %rdi
callq 0x7520
movq (%rsp), %rdi
movl $0x4040, %esi           # imm = 0x4040
callq 0x2290
movq 0x8(%rsp), %rax
movq $0x0, 0x2da8(%rax)
movq 0x8(%rsp), %rdi
callq 0xfd10
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x2d30
nopw %cs:(%rax,%rax)
// File: Infinidat[P]slimfastq/xfile.cpp
// Function: XFileLoad::init()
void XFileLoad::init() {
    filer = new FilerLoad(m_filename, &m_valid);
    assert(filer);
    if (m_valid)
        rcoder.init(filer);
    else
        DELETE(filer);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x4040, %edi           # imm = 0x4040
callq 0x2280
movq 0x10(%rsp), %rdx
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq (%rdx), %rsi
addq $0x8, %rdx
callq 0x71e0
jmp 0xfa7b
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x2da8(%rax)
cmpq $0x0, 0x2da8(%rax)
je 0xfa98
jmp 0xfad6
leaq 0x58e(%rip), %rdi       # 0x1002d
leaq 0x1afb(%rip), %rsi      # 0x115a1
movl $0x53, %edx
leaq 0x1b10(%rip), %rcx      # 0x115c2
callq 0x21b0
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x4040, %esi           # imm = 0x4040
callq 0x2290
jmp 0xfb55
movq 0x10(%rsp), %rax
testb $0x1, 0x8(%rax)
je 0xfafb
movq 0x10(%rsp), %rax
movq %rax, %rdi
addq $0x10, %rdi
movq 0x2da8(%rax), %rsi
callq 0x2db0
jmp 0xfb50
jmp 0xfafd
movq 0x10(%rsp), %rax
cmpq $0x0, 0x2da8(%rax)
je 0xfb3e
movq 0x10(%rsp), %rax
movq 0x2da8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xfb3c
movq 0x8(%rsp), %rdi
callq 0x7520
movq 0x8(%rsp), %rdi
movl $0x4040, %esi           # imm = 0x4040
callq 0x2290
jmp 0xfb3e
movq 0x10(%rsp), %rax
movq $0x0, 0x2da8(%rax)
jmp 0xfb50
addq $0x38, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x23f0
nop
// File: Infinidat[P]slimfastq/xfile.cpp
// Function: XFileLoad::get_str(unsigned char*)
UCHAR* XFileLoad::get_str(UCHAR* p) {
    size_t len = get();
    for (UINT32 j = 0; j < len; j++)
        p[j] = ranger_str.get(&rcoder);
    return p + len;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xfb60
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpq 0x10(%rsp), %rax
jae 0xfca6
movq (%rsp), %rsi
movq %rsi, %rdi
addq $0x2a9a, %rdi           # imm = 0x2A9A
addq $0x10, %rsi
callq 0x2e40
movb %al, %dl
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xfc69
movq 0x18(%rsp), %rax
addq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: aalto-speech[P]ftk/src/substrings.cc
// Function: write_substrings(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, float>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, float>>>&)
void write_substrings(const string &outfname,
                      vector<pair<string, float> > &sorted_substrs)
{
    ofstream outfile(outfname);
    if (!outfile) {
        cerr << "Something went wrong opening the output file." << endl;
        exit(1);
    }

    for (auto it = sorted_substrs.cbegin(); it != sorted_substrs.cend(); ++it)
        outfile << it->second << "\t" << it->first << endl;

    outfile.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x210(%rbp), %rdi
movl $0x10, %edx
callq 0x47b0
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x41e0
movb %al, -0x231(%rbp)
jmp 0x5428
movb -0x231(%rbp), %al
testb $0x1, %al
jne 0x5434
jmp 0x5492
movq 0x94bad(%rip), %rdi     # 0x99fe8
leaq 0x64bf1(%rip), %rsi     # 0x6a033
callq 0x43d0
movq %rax, -0x240(%rbp)
jmp 0x5450
movq -0x240(%rbp), %rdi
movq 0x94b3a(%rip), %rsi     # 0x99f98
callq 0x4410
jmp 0x5465
movl $0x1, %edi
callq 0x4480
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x45d0
jmp 0x557f
movq -0x10(%rbp), %rdi
callq 0x64d0
movq %rax, -0x228(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6540
movq %rax, -0x230(%rbp)
leaq -0x228(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x6500
testb $0x1, %al
jne 0x54ce
jmp 0x555c
leaq -0x228(%rbp), %rdi
callq 0x6570
movss 0x20(%rax), %xmm0
leaq -0x210(%rbp), %rdi
callq 0x4310
movq %rax, -0x248(%rbp)
jmp 0x54f4
movq -0x248(%rbp), %rdi
leaq 0x64f48(%rip), %rsi     # 0x6a44a
callq 0x43d0
movq %rax, -0x250(%rbp)
jmp 0x5510
leaq -0x228(%rbp), %rdi
callq 0x6570
movq -0x250(%rbp), %rdi
movq %rax, %rsi
callq 0x4390
movq %rax, -0x258(%rbp)
jmp 0x5534
movq -0x258(%rbp), %rdi
movq 0x94a56(%rip), %rsi     # 0x99f98
callq 0x4410
jmp 0x5549
jmp 0x554b
leaq -0x228(%rbp), %rdi
callq 0x6590
jmp 0x54a2
leaq -0x210(%rbp), %rdi
callq 0x4580
jmp 0x556a
leaq -0x210(%rbp), %rdi
callq 0x45d0
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x46f0
nopl (%rax,%rax)
// File: keyan[P]ev_routing_engine/./utils.h
// Function: haversine_dist(double, double, double, double)
inline Kilometers haversine_dist(double lat1, double lng1, double lat2, double lng2) {
  double lat_rad1 = degree_to_radian(lat1);
  double lng_rad1 = degree_to_radian(lng1);
  double lat_rad2 = degree_to_radian(lat2);
  double lng_rad2 = degree_to_radian(lng2);

  double diff_lat = lat_rad2 - lat_rad1;
  double diff_lng = lng_rad2 - lng_rad1;

  double u = sin(diff_lat / 2.0);
  double v = sin(diff_lng / 2.0);

  double computation = asin(sqrt(u * u + cos(lat_rad1) * cos(lat_rad2) * v * v));

  return 2.0 * EARTH_RADIUS_KM * computation;
}

// Assembly:
subq $0x88, %rsp
movsd %xmm0, 0x80(%rsp)
movsd %xmm1, 0x78(%rsp)
movsd %xmm2, 0x70(%rsp)
movsd %xmm3, 0x68(%rsp)
movsd 0x80(%rsp), %xmm0
callq 0x17b50
movsd %xmm0, 0x60(%rsp)
movsd 0x78(%rsp), %xmm0
callq 0x17b50
movsd %xmm0, 0x58(%rsp)
movsd 0x70(%rsp), %xmm0
callq 0x17b50
movsd %xmm0, 0x50(%rsp)
movsd 0x68(%rsp), %xmm0
callq 0x17b50
movsd %xmm0, 0x48(%rsp)
movsd 0x50(%rsp), %xmm0
subsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x48(%rsp), %xmm0
subsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x40(%rsp), %xmm0
movsd 0x8bcd(%rip), %xmm1     # 0x1f068
divsd %xmm1, %xmm0
callq 0x2070
movsd %xmm0, 0x30(%rsp)
movsd 0x38(%rsp), %xmm0
movsd 0x8bb0(%rip), %xmm1     # 0x1f068
divsd %xmm1, %xmm0
callq 0x2070
movsd %xmm0, 0x28(%rsp)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x60(%rsp), %xmm0
callq 0x23a0
movsd %xmm0, 0x8(%rsp)
movsd 0x50(%rsp), %xmm0
callq 0x23a0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movaps %xmm0, %xmm3
movsd 0x18(%rsp), %xmm0
mulsd %xmm3, %xmm1
mulsd 0x28(%rsp), %xmm1
mulsd 0x28(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x2190
callq 0x2350
movsd %xmm0, 0x20(%rsp)
movsd 0x8b20(%rip), %xmm0     # 0x1f060
mulsd 0x20(%rsp), %xmm0
addq $0x88, %rsp
retq
nop
// File: meghanamreddy[P]Range-trees-and-Interval-Trees/interval_tree.cpp
// Function: IntervalTree::getSortedEndPointsX(std::vector<Line*, std::allocator<Line*>>)
vector<int> IntervalTree::getSortedEndPointsX(vector<Line*> lines) {
	vector<int> endpoints;
	int i;
	for (i=0; i<lines.size(); i++) {
		endpoints.push_back(lines[i]->x1);
		endpoints.push_back(lines[i]->x2);
	}
	sort (endpoints.begin(), endpoints.end(), myfunction);
	return endpoints;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x58(%rbp)
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x3420
movl $0x0, -0x20(%rbp)
movq -0x58(%rbp), %rdi
movslq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x3440
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x244e
movq -0x58(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x34d0
movq -0x50(%rbp), %rdi
movq (%rax), %rsi
callq 0x3460
jmp 0x240b
movq -0x58(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x34d0
movq -0x50(%rbp), %rdi
movq (%rax), %rsi
addq $0x4, %rsi
callq 0x3460
jmp 0x242a
jmp 0x242c
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x23d3
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x35a0
jmp 0x249b
movq -0x50(%rbp), %rdi
callq 0x3540
movq -0x50(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x3570
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0xf7(%rip), %rdx       # 0x2380
callq 0x34f0
jmp 0x247e
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x2491
movq -0x50(%rbp), %rdi
callq 0x35a0
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x21b0
nopw %cs:(%rax,%rax)
// File: meghanamreddy[P]Range-trees-and-Interval-Trees/interval_tree.cpp
// Function: IntervalTree::getSortedEndPointsY(std::vector<Line*, std::allocator<Line*>>)
vector<int> IntervalTree::getSortedEndPointsY(vector<Line*> lines) {
	vector<int> endpoints;
	int i;
	for (i=0; i<lines.size(); i++) {
		endpoints.push_back(lines[i]->y1);
		endpoints.push_back(lines[i]->y2);
	}
	sort (endpoints.begin(), endpoints.end(), myfunction);
	return endpoints;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x58(%rbp)
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x3420
movl $0x0, -0x20(%rbp)
movq -0x58(%rbp), %rdi
movslq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x3440
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x2562
movq -0x58(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x34d0
movq -0x50(%rbp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x3460
jmp 0x251f
movq -0x58(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x34d0
movq -0x50(%rbp), %rdi
movq (%rax), %rsi
addq $0xc, %rsi
callq 0x3460
jmp 0x253e
jmp 0x2540
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x24e3
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x35a0
jmp 0x25af
movq -0x50(%rbp), %rdi
callq 0x3540
movq -0x50(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x3570
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x20b(%rip), %rdx      # 0x2380
callq 0x34f0
jmp 0x2592
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x25a5
movq -0x50(%rbp), %rdi
callq 0x35a0
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x21b0
nopl (%rax,%rax)
// File: meghanamreddy[P]Range-trees-and-Interval-Trees/interval_tree.cpp
// Function: IntervalTree::preorder(IntervalNode*)
void IntervalTree::preorder(IntervalNode *r)
{
	int i;
        if (r != NULL)
        {
	       	cout<< " [[[ ";
		for (i=0; i<r->I_mid.size(); i++)
			cout << " {" << r->I_mid[i]->y1 << "  " << r->I_mid[i]->y2 << "} " ;
		cout << " ]]] ";
		if (r->rangetree != NULL)
			r->rangetree->preorder();
                preorder(r->left);
                preorder(r->right);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2716
movq 0xb9ce(%rip), %rdi      # 0xdfd8
leaq 0x79f3(%rip), %rsi      # 0xa004
callq 0x2100
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x3440
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x26c9
movq 0xb98f(%rip), %rdi      # 0xdfd8
leaq 0x79ba(%rip), %rsi      # 0xa00a
callq 0x2100
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x34d0
movq -0x38(%rbp), %rdi
movq (%rax), %rax
movl 0x8(%rax), %esi
callq 0x21a0
movq %rax, %rdi
leaq 0x798a(%rip), %rsi      # 0xa00d
callq 0x2100
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x34d0
movq -0x30(%rbp), %rdi
movq (%rax), %rax
movl 0xc(%rax), %esi
callq 0x21a0
movq %rax, %rdi
leaq 0x799f(%rip), %rsi      # 0xa055
callq 0x2100
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x261d
movq 0xb908(%rip), %rdi      # 0xdfd8
leaq 0x7939(%rip), %rsi      # 0xa010
callq 0x2100
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x26f4
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x72b0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x25e0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x25e0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: meghanamreddy[P]Range-trees-and-Interval-Trees/interval_tree.cpp
// Function: IntervalTree::queryX(int, int, int, int, int, IntervalNode*)
void IntervalTree::queryX(int maxX, int minX, int x, int y1, int y2, IntervalNode* node) {
	if (x < node->x_mid) {
		node->rangetree->twodquery(minX, x, y1, y2);
		if (node->left != NULL)
			queryX(maxX, minX, x, y1, y2, node->left);
	}
	else if (x > node->x_mid) {
		node->rangetree->twodquery(x, maxX, y1, y2);
		if (node->right != NULL)
			queryX(maxX, minX, x, y1, y2, node->right);
	}
	else {
		node->rangetree->twodquery(x, x, y1, y2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movq 0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x3241
movq 0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
callq 0x82d0
movq 0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x323f
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x1c(%rbp), %r9d
movq 0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, (%rsp)
callq 0x31c0
jmp 0x32b5
movl -0x14(%rbp), %eax
movq 0x10(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x3299
movq 0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x14(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
callq 0x82d0
movq 0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x3297
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x1c(%rbp), %r9d
movq 0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, (%rsp)
callq 0x31c0
jmp 0x32b3
movq 0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
callq 0x82d0
jmp 0x32b5
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: meghanamreddy[P]Range-trees-and-Interval-Trees/interval_tree.cpp
// Function: IntervalTree::queryY(int, int, int, int, int, IntervalNode*)
void IntervalTree::queryY(int maxY, int minY, int y, int x1, int x2, IntervalNode* node) {
	if (y < node->x_mid) {
		node->rangetree->twodquery(x1, x2, minY, y);
		if (node->left != NULL)
			queryY(maxY, minY, y, x1, x2, node->left);
	}
	else if (y > node->x_mid) {
		node->rangetree->twodquery(x1, x2, y, maxY);
		if (node->right != NULL)
			queryY(maxY, minY, y, x1, x2, node->right);
	}
	else {
		node->rangetree->twodquery(x1, x2, y, y);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movq 0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x33a1
movq 0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %r8d
callq 0x82d0
movq 0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x339f
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x1c(%rbp), %r9d
movq 0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, (%rsp)
callq 0x3320
jmp 0x3415
movl -0x14(%rbp), %eax
movq 0x10(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x33f9
movq 0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0xc(%rbp), %r8d
callq 0x82d0
movq 0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x33f7
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x1c(%rbp), %r9d
movq 0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, (%rsp)
callq 0x3320
jmp 0x3413
movq 0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x14(%rbp), %r8d
callq 0x82d0
jmp 0x3415
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: meghanamreddy[P]Range-trees-and-Interval-Trees/./interval_tree.h
// Function: IntervalNode::IntervalNode()
IntervalNode() {
		x_mid = 0;
		left = NULL;
		right = NULL;
		rangetree = NULL;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x8, %rdi
callq 0x37e0
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::rotateWithLeftChild(BinaryRangeNode*)
BinaryRangeNode* BinaryRangeTree::rotateWithLeftChild(BinaryRangeNode* k2)
 {
     BinaryRangeNode *k1 = k2->left;
     k2->left = k1->right;
     k1->right = k2;
     k2->height = max(height(k2->left), height(k2->right)) + 1;
     k1->height = max(height(k1->left), k2->height) + 1;
     return k1;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x6dc0
movq -0x20(%rbp), %rdi
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x6dc0
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rdi
movl %eax, %edx
callq 0x6df0
movq -0x20(%rbp), %rdi
movl %eax, %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x6dc0
movq -0x20(%rbp), %rdi
movl %eax, %esi
movq -0x10(%rbp), %rax
movl (%rax), %edx
callq 0x6df0
movl %eax, %ecx
addl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::countNodes(BinaryRangeNode*)
int BinaryRangeTree::countNodes(BinaryRangeNode *r)
 {
     if (r == NULL)
         return 0;
     else
     {
         int l = 1;
         l += countNodes(r->left);
         l += countNodes(r->right);
         return l;
     }
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7088
movl $0x0, -0x4(%rbp)
jmp 0x70c3
movq -0x28(%rbp), %rdi
movl $0x1, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x7060
movq -0x28(%rbp), %rdi
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x7060
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::search(BinaryRangeNode*, int)
bool BinaryRangeTree::search(BinaryRangeNode *r, int val)
 {
     bool found = false;
     while ((r != NULL) && !found)
     {
         int rval = r->data;
         if (val < rval)
             r = r->left;
         else if (val > rval)
             r = r->right;
         else
         {
             found = true;
             break;
         }
         found = search(r, val);
     }
     return found;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x15(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x29(%rbp)
je 0x7133
movb -0x15(%rbp), %al
xorb $-0x1, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x713c
jmp 0x7191
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x715c
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x717a
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x7172
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x7178
movb $0x1, -0x15(%rbp)
jmp 0x7191
jmp 0x717a
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x7100
andb $0x1, %al
movb %al, -0x15(%rbp)
jmp 0x711f
movb -0x15(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::inorder(BinaryRangeNode*)
void BinaryRangeTree::inorder(BinaryRangeNode *r)
 {
	int i;
     if (r != NULL)
     {
         inorder(r->left);
         cout<< " { " << r->data<<" : ";
		for (i=0; i<r->data2.size(); i++)
			cout << r->data2[i] << "  ";
	cout << "} ";
         inorder(r->right);
     }
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x72aa
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x71c0
movq 0x6ddd(%rip), %rdi      # 0xdfd8
leaq 0x2e2e(%rip), %rsi      # 0xa030
callq 0x2100
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x21a0
movq %rax, %rdi
leaq 0x2e14(%rip), %rsi      # 0xa034
callq 0x2100
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x37c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x7286
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x37a0
movl (%rax), %esi
movq 0x6d71(%rip), %rdi      # 0xdfd8
callq 0x21a0
movq %rax, %rdi
leaq 0x2d97(%rip), %rsi      # 0xa00d
callq 0x2100
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x722c
movq 0x6d4b(%rip), %rdi      # 0xdfd8
leaq 0x2dc1(%rip), %rsi      # 0xa055
callq 0x2100
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x71c0
addq $0x30, %rsp
popq %rbp
retq
// File: meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::preorder(BinaryRangeNode*)
void BinaryRangeTree::preorder(BinaryRangeNode *r)
 {
	int i;
     if (r != NULL)
     {
	for (i=0; i<r->lines.size(); i++) {
			if (r->lines[i]->reported != 1)	{
				cout << " OP1 { (" << r->lines[i]->x1 << " " << r->lines[i]->y1 << ") -- (" << r->lines[i]->x2 << " " << r->lines[i]->y2 << ") } " << endl;
			}
	}
         preorder(r->left);
         preorder(r->right);
     }
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7493
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x3440
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x7471
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x34d0
movq (%rax), %rax
movb 0x10(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0x7461
movq 0x6c5d(%rip), %rdi      # 0xdfd8
leaq 0x2cc1(%rip), %rsi      # 0xa043
callq 0x2100
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x34d0
movq -0x48(%rbp), %rdi
movq (%rax), %rax
movl (%rax), %esi
callq 0x21a0
movq %rax, %rdi
leaq 0x2c5a(%rip), %rsi      # 0xa00e
callq 0x2100
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x34d0
movq -0x40(%rbp), %rdi
movq (%rax), %rax
movl 0x8(%rax), %esi
callq 0x21a0
movq %rax, %rdi
leaq 0x2c65(%rip), %rsi      # 0xa04c
callq 0x2100
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x34d0
movq -0x38(%rbp), %rdi
movq (%rax), %rax
movl 0x4(%rax), %esi
callq 0x21a0
movq %rax, %rdi
leaq 0x2bf4(%rip), %rsi      # 0xa00e
callq 0x2100
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x34d0
movq -0x30(%rbp), %rdi
movq (%rax), %rax
movl 0xc(%rax), %esi
callq 0x21a0
movq %rax, %rdi
leaq 0x2c06(%rip), %rsi      # 0xa053
callq 0x2100
movq %rax, %rdi
movq 0x6b6c(%rip), %rsi      # 0xdfc8
callq 0x2120
jmp 0x7463
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x732a
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x7300
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x7300
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::postorder(BinaryRangeNode*)
void BinaryRangeTree::postorder(BinaryRangeNode *r)
 {
	int i;
     if (r != NULL)
     {
         postorder(r->left);
         postorder(r->right);
         cout<< " { " << r->data<<" : ";
		for (i=0; i<r->data2.size(); i++)
			cout << r->data2[i] << "  ";
	cout << "} ";
     }
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x75aa
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x74c0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x74c0
movq 0x6acc(%rip), %rdi      # 0xdfd8
leaq 0x2b1d(%rip), %rsi      # 0xa030
callq 0x2100
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x21a0
movq %rax, %rdi
leaq 0x2b03(%rip), %rsi      # 0xa034
callq 0x2100
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x37c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x7597
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x37a0
movl (%rax), %esi
movq 0x6a60(%rip), %rdi      # 0xdfd8
callq 0x21a0
movq %rax, %rdi
leaq 0x2a86(%rip), %rsi      # 0xa00d
callq 0x2100
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x753d
movq 0x6a3a(%rip), %rdi      # 0xdfd8
leaq 0x2ab0(%rip), %rsi      # 0xa055
callq 0x2100
addq $0x30, %rsp
popq %rbp
retq
// File: meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::buildytrees(BinaryRangeNode*)
void BinaryRangeTree::buildytrees(BinaryRangeNode *r) {
	if (r != NULL) {
		BinaryRangeTree* temp_tree = new BinaryRangeTree();
		buildytrees(r, temp_tree);
		r->ytree = temp_tree;
		buildytrees(r->left);	
		buildytrees(r->right);	
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x766a
movl $0x8, %edi
callq 0x2110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x3ac0
jmp 0x760a
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7680
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x75d0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x75d0
jmp 0x766a
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x20f0
jmp 0x7670
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x21b0
nopl (%rax)