LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/soccin[P]BIC-RNAseq/tools/MergeFusion/Merger.cpp
// Function: Merger::sortBy(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Merger::sortBy(string sorting_criteria)
{
    if(sorting_criteria == "CALLER")
    {
        sort(fusion_vec.begin(), fusion_vec.end(), sortByCaller);
    }
    else if(sorting_criteria == "GENOMIC")
    {
        sort(fusion_vec.begin(), fusion_vec.end(), sortByGenomicPos);
    }
    else if(sorting_criteria == "GENE")
    {
        sort(fusion_vec.begin(), fusion_vec.end(), sortByGeneSymbol);
    }
    else if(sorting_criteria == "BREAKPOINT_COVERAGE")
    {
        sort(fusion_vec.begin(), fusion_vec.end(), sortByBreakpointCoverage);
    }
    else
    {
        cerr << "[ERROR]: unrecognized sorting criteria '" << sorting_criteria << "', output won't be sorted" << endl;
        
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x5f1e(%rip), %rsi      # 0x941c
movq %rbx, %rdi
callq 0x30c8
testb %al, %al
je 0x351a
movq (%r14), %rdi
movq 0x8(%r14), %rsi
leaq 0x4fc7(%rip), %rdx      # 0x84df
jmp 0x3581
leaq 0x5b21(%rip), %rsi      # 0x9042
movq %rbx, %rdi
callq 0x30c8
testb %al, %al
je 0x353d
movq (%r14), %rdi
movq 0x8(%r14), %rsi
leaq 0x4fb1(%rip), %rdx      # 0x84ec
jmp 0x3581
leaq 0x5edf(%rip), %rsi      # 0x9423
movq %rbx, %rdi
callq 0x30c8
testb %al, %al
je 0x3560
movq (%r14), %rdi
movq 0x8(%r14), %rsi
leaq 0x5028(%rip), %rdx      # 0x8586
jmp 0x3581
leaq 0x5ec1(%rip), %rsi      # 0x9428
movq %rbx, %rdi
callq 0x30c8
testb %al, %al
je 0x358a
movq (%r14), %rdi
movq 0x8(%r14), %rsi
leaq 0x4f49(%rip), %rdx      # 0x84ca
popq %rbx
popq %r14
popq %rbp
jmp 0x4e64
movq 0xaa5f(%rip), %rdi      # 0xdff0
leaq 0x602b(%rip), %rsi      # 0x95c3
callq 0x21b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21a0
leaq 0x603d(%rip), %rsi      # 0x95ec
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O2/soccin[P]BIC-RNAseq/tools/MergeFusion/Merger.cpp
// Function: Merger::locusToChr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Merger::locusToChr(string locus)
{
#ifdef _DEBUG
    cerr << "[DEBUG]: locus= " << locus << endl;
#endif
    if(locus.empty() || locus == "reserved")
        return "chrNA";
    if(locus == "mitochondria")
        return "chrMT";
    else
    {
        vector<string> p_split_item;
        split(locus, 'p', p_split_item);
        vector<string> q_split_item;
        split(p_split_item[0], 'q', q_split_item);
        vector<string> c_split_item;
        split(q_split_item[0], 'c', c_split_item);
        return "chr" + c_split_item[0];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdx)
je 0x35ef
movq %rdx, %r14
leaq 0x6023(%rip), %rsi      # 0x9606
movq %rdx, %rdi
callq 0x30c8
testb %al, %al
je 0x360e
leaq 0x6019(%rip), %rsi      # 0x960f
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x2cbe
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6000(%rip), %rsi      # 0x9615
movq %r14, %rdi
callq 0x30c8
testb %al, %al
je 0x362a
leaq 0x5ffa(%rip), %rsi      # 0x9622
jmp 0x35f6
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
pushq $0x70
popq %rsi
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x865f
leaq -0x70(%rbp), %rdx
xorps %xmm0, %xmm0
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
movq -0x30(%rbp), %rdi
pushq $0x71
popq %rsi
xorl %ecx, %ecx
callq 0x865f
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
movq -0x70(%rbp), %rdi
pushq $0x63
popq %rsi
xorl %ecx, %ecx
callq 0x865f
movq -0x50(%rbp), %rdx
leaq 0x5f9d(%rip), %rsi      # 0x9628
movq %rbx, %rdi
callq 0x3de2
leaq -0x50(%rbp), %rdi
callq 0x3e58
leaq -0x70(%rbp), %rdi
callq 0x3e58
leaq -0x30(%rbp), %rdi
callq 0x3e58
jmp 0x3602
movq %rax, %rbx
jmp 0x36c9
movq %rax, %rbx
jmp 0x36d2
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3e58
leaq -0x70(%rbp), %rdi
callq 0x3e58
leaq -0x30(%rbp), %rdi
callq 0x3e58
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/soccin[P]BIC-RNAseq/tools/MergeFusion/Merger.cpp
// Function: Merger::printHugoMap()
void Merger::printHugoMap()
{
    map<pair<string, string>, map<string, int> >::iterator it;
    for(it = hugo_map.begin(); it != hugo_map.end(); it ++)
    {
        cout << it->first.first << "\t" << it->first.second << "\t" << it->second.size() << endl;
        /*if(it->second.size() > 1)
        {
            map<string, int>::iterator it2;
            for(it2 = it->second.begin(); it2 != it->second.end(); it2 ++)
                cout << it2->first << "\t" << it2->second << endl;
        }*/
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %r15
addq $0x20, %rbx
movq 0xa323(%rip), %r14      # 0xdfc8
leaq 0x59a9(%rip), %r12      # 0x9655
cmpq %rbx, %r15
je 0x3d03
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x21a0
movq %rax, %rdi
movq %r12, %rsi
callq 0x21b0
leaq 0x40(%r15), %rsi
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
movq %r12, %rsi
callq 0x21b0
movq 0x88(%r15), %rsi
movq %rax, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x2100
movq %r15, %rdi
callq 0x2140
movq %rax, %r15
jmp 0x3cac
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/soccin[P]BIC-RNAseq/tools/MergeFusion/StandardFusion.cpp
// Function: StandardFusion::parseStar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void StandardFusion::parseStar(string line)  //done
{
    vector<string> parsed_item;
    split(line, '\t', parsed_item);
    chr1 = parsed_item[0];
    chr2 = parsed_item[3];
    start1 = -1;
    start2 = -1;
    end1 = -1;
    end2 = -1;
    breakpoint1 = atoi(parsed_item[1].c_str());
    breakpoint2 = atoi(parsed_item[4].c_str());
    strand1 = parsed_item[2];
    strand2 = parsed_item[5];
    breakpoint_coverage = 1;
    spanning_coverage = -1;
    total_coverage = -1;
    gene1 = "NA";
    gene2 = "NA";
    transcript1 = "NA";
    transcript2 = "NA";
    caller_id = STAR;
    
    info.append("JUNCTION_TYPE="); info.append(parsed_item[6]);
    info.append(";REPEAT_LEFT="); info.append(parsed_item[7]);
    info.append(";REPEAT_RIGHT="); info.append(parsed_item[8]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rax
movq %rdi, %rbx
pxor %xmm0, %xmm0
leaq -0x30(%rbp), %rdx
movdqa %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
pushq $0x9
popq %rsi
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x865f
movq -0x30(%rbp), %rsi
leaq 0x8(%rbx), %rdi
callq 0x2120
movq -0x30(%rbp), %rsi
addq $0x60, %rsi
leaq 0x28(%rbx), %rdi
callq 0x2120
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x48(%rbx)
movq -0x30(%rbp), %r14
movq 0x20(%r14), %rdi
callq 0x2290
movl %eax, 0x58(%rbx)
movq 0x80(%r14), %rdi
callq 0x2290
movl %eax, 0x5c(%rbx)
addq $0x40, %r14
leaq 0x60(%rbx), %rdi
movq %r14, %rsi
callq 0x2120
movl $0xa0, %esi
addq -0x30(%rbp), %rsi
leaq 0x80(%rbx), %rdi
callq 0x2120
movl $0x1, 0xa8(%rbx)
orq $-0x1, 0xa0(%rbx)
leaq 0xb0(%rbx), %rdi
leaq 0x1c66(%rip), %rsi      # 0x9612
callq 0x2360
leaq 0xd0(%rbx), %rdi
leaq 0x1c53(%rip), %rsi      # 0x9612
callq 0x2360
leaq 0xf0(%rbx), %rdi
leaq 0x1c40(%rip), %rsi      # 0x9612
callq 0x2360
leaq 0x110(%rbx), %rdi
leaq 0x1c2d(%rip), %rsi      # 0x9612
callq 0x2360
movl $0x5, (%rbx)
addq $0x130, %rbx            # imm = 0x130
leaq 0x225b(%rip), %rsi      # 0x9c59
movq %rbx, %rdi
callq 0x2350
movl $0xc0, %esi
addq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2370
leaq 0x224a(%rip), %rsi      # 0x9c68
movq %rbx, %rdi
callq 0x2350
movl $0xe0, %esi
addq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2370
leaq 0x2238(%rip), %rsi      # 0x9c76
movq %rbx, %rdi
callq 0x2350
movl $0x100, %esi            # imm = 0x100
addq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2370
leaq -0x30(%rbp), %rdi
callq 0x3e58
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3e58
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/soccin[P]BIC-RNAseq/tools/MergeFusion/StandardFusion.cpp
// Function: StandardFusion::normalize_gene_name(std::map<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>, std::less<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::pair<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>>>>&)
void StandardFusion::normalize_gene_name(map<pair<string, string>, map<string, int> >& hugo_map)
{
    if(gene1 != "NA")
        normalize_gene_name_worker(chr1, gene1, hugo_map);
    if(gene2 != "NA")
        normalize_gene_name_worker(chr2, gene2, hugo_map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xb0(%rdi), %r15
leaq 0x1b52(%rip), %rsi      # 0x9612
movq %r15, %rdi
callq 0x2d53
testb %al, %al
je 0x7adb
leaq 0x8(%r14), %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x7c60
leaq 0xd0(%r14), %r15
leaq 0x1b29(%rip), %rsi      # 0x9612
movq %r15, %rdi
callq 0x2d53
testb %al, %al
je 0x7b11
addq $0x28, %r14
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7c60
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/soccin[P]BIC-RNAseq/tools/MergeFusion/StandardFusion.cpp
// Function: StandardFusion::normalize_chrom_name_worker(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void StandardFusion::normalize_chrom_name_worker(string& chrom_name)
{
    if(chrom_name == "M" || chrom_name == "Mt" || chrom_name == "chrM" || chrom_name == "chrMt")
        chrom_name = "MT";
    if(chrom_name.substr(0, 3) != "chr")
        chrom_name = "chr" + chrom_name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x20df(%rip), %rsi      # 0x9c88
movq %rbx, %rdi
callq 0x30c8
testb %al, %al
jne 0x7bee
leaq 0x20d1(%rip), %rsi      # 0x9c8d
movq %rbx, %rdi
callq 0x30c8
testb %al, %al
jne 0x7bee
leaq 0x20b6(%rip), %rsi      # 0x9c85
movq %rbx, %rdi
callq 0x30c8
testb %al, %al
jne 0x7bee
leaq 0x20a8(%rip), %rsi      # 0x9c8a
movq %rbx, %rdi
callq 0x30c8
testb %al, %al
je 0x7bfd
leaq 0x1a30(%rip), %rsi      # 0x9625
movq %rbx, %rdi
callq 0x2360
leaq -0x38(%rbp), %r14
pushq $0x3
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x21e0
leaq 0x1a10(%rip), %rsi      # 0x9628
movq %r14, %rdi
callq 0x2d53
movl %eax, %r15d
movq %r14, %rdi
callq 0x2388
testb %r15b, %r15b
je 0x7c55
leaq 0x19f1(%rip), %rsi      # 0x9628
movq %r14, %rdi
movq %rbx, %rdx
callq 0x3de2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2220
movq %r14, %rdi
callq 0x2388
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/soccin[P]BIC-RNAseq/tools/MergeFusion/StandardFusion.cpp
// Function: StandardFusion::operator<(StandardFusion const&) const
bool StandardFusion::operator<(const StandardFusion& other) const
{
    if(chr1 != other.chr1)
        return chr1 < other.chr1;
    if(strand1 != other.strand1)
        return strand1 < other.strand1;
    if(breakpoint1 != other.breakpoint1)
        return breakpoint1 < other.breakpoint1;
    if(chr2 != other.chr2)
        return chr2 < other.chr2;
    if(strand2 != other.strand2)
        return strand2 < other.strand2;
    if(breakpoint2 != other.breakpoint2)
        return breakpoint2 < other.breakpoint2;
    else
        return caller_id < other.caller_id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %r15
leaq 0x8(%rsi), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x85d9
testb %al, %al
jne 0x7fb9
leaq 0x60(%r14), %r15
leaq 0x60(%rbx), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x85d9
testb %al, %al
je 0x7fcc
movq %r15, %rdi
movq %r12, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5999
movl 0x58(%rbx), %eax
cmpl %eax, 0x58(%r14)
jne 0x801e
leaq 0x28(%r14), %r15
leaq 0x28(%rbx), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x85d9
testb %al, %al
jne 0x7fb9
movl $0x80, %r15d
leaq (%r14,%r15), %r12
addq %rbx, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x85d9
testb %al, %al
je 0x8010
movq %r12, %rdi
movq %r15, %rsi
jmp 0x7fbf
movl 0x5c(%rbx), %eax
cmpl %eax, 0x5c(%r14)
jne 0x801e
movl (%r14), %eax
cmpl (%rbx), %eax
setl %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/soccin[P]BIC-RNAseq/tools/MergeFusion/StandardFusion.cpp
// Function: output_fusion_header(std::ostream&)
void output_fusion_header(ostream &output)
{
    output << "CALLER_ID" << "\t" \
    << "GENE1"<< "\t" \
    << "GENE2" << "\t" \
    << "CHR1" << "\t" \
    << "STRAND1" << "\t" \
    << "BREAK_POINT1" << "\t" \
    << "CHR2" << "\t" \
    << "STRAND2" << "\t" \
    << "BREAK_POINT2" << "\t" \
    << "BREAKPOINT_COVERAGE" << "\t" \
    << "SPANNING_COVERAGE" << "\t" \
    << "TOTAL_COVERAGE" << "\t" \
    << "START1" << "\t" \
    << "END1" << "\t" \
    << "START2" << "\t" \
    << "END2" << "\t" \
    << "TRANSCRIPT1" << "\t" \
    << "TRANSCRIPT2" << "\t" \
    << "INFO" \
    << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x1c5b(%rip), %rsi      # 0x9c92
callq 0x21b0
leaq 0x1612(%rip), %rbx      # 0x9655
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21b0
leaq 0x1c47(%rip), %rsi      # 0x9c9c
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21b0
leaq 0x1c33(%rip), %rsi      # 0x9ca2
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21b0
leaq 0x1c1f(%rip), %rsi      # 0x9ca8
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21b0
leaq 0x1c0a(%rip), %rsi      # 0x9cad
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21b0
leaq 0x1bf8(%rip), %rsi      # 0x9cb5
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21b0
leaq 0x1beb(%rip), %rsi      # 0x9cc2
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21b0
leaq 0x1bd6(%rip), %rsi      # 0x9cc7
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21b0
leaq 0x1bc4(%rip), %rsi      # 0x9ccf
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21b0
leaq 0x1303(%rip), %rsi      # 0x9428
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21b0
leaq 0x1b9d(%rip), %rsi      # 0x9cdc
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21b0
leaq 0x1b95(%rip), %rsi      # 0x9cee
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21b0
leaq 0x1b8a(%rip), %rsi      # 0x9cfd
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21b0
leaq 0x1b77(%rip), %rsi      # 0x9d04
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21b0
leaq 0x1b62(%rip), %rsi      # 0x9d09
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21b0
leaq 0x1b4f(%rip), %rsi      # 0x9d10
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21b0
leaq 0x1b3a(%rip), %rsi      # 0x9d15
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21b0
leaq 0x1b2c(%rip), %rsi      # 0x9d21
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21b0
leaq 0x1b1e(%rip), %rsi      # 0x9d2d
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/soccin[P]BIC-RNAseq/tools/MergeFusion/StandardFusion.cpp
// Function: sortByGenomicPos(StandardFusion const&, StandardFusion const&)
bool sortByGenomicPos(const StandardFusion &l, const StandardFusion &r)
{
    if(l.chr1 != r.chr1)
        return l.chr1 < r.chr1;
    if(l.chr2 != r.chr2)
        return l.chr2 < r.chr2;
    if(l.breakpoint1 != r.breakpoint1)
        return l.breakpoint1 < r.breakpoint1;
    if(l.breakpoint2 != r.breakpoint2)
        return l.breakpoint2 < r.breakpoint2;
    if(l.strand1 != r.strand1)
        return l.strand1 < r.strand1;
    else
        return l.strand2 < r.strand2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %r15
leaq 0x8(%rsi), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x85d9
testb %al, %al
jne 0x852b
leaq 0x28(%r14), %r15
leaq 0x28(%rbx), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x85d9
testb %al, %al
je 0x853e
movq %r15, %rdi
movq %r12, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5999
movl 0x58(%rbx), %eax
cmpl %eax, 0x58(%r14)
jne 0x857a
movl 0x5c(%rbx), %eax
cmpl %eax, 0x5c(%r14)
jne 0x857a
leaq 0x60(%r14), %r15
leaq 0x60(%rbx), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x85d9
testb %al, %al
jne 0x852b
movl $0x80, %eax
addq %rax, %r14
addq %rax, %rbx
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x8531
setl %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/soccin[P]BIC-RNAseq/tools/MergeFusion/common.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, bool)
void split(const string& line, char delim, vector<std::string>& parsed_item, bool ignore_empty_item)
{
    stringstream my_ss(line);
    string item;
    while (getline(my_ss, item, delim))
    {
#ifdef _DEBUG
        cout << "[DEBUG]: Parsed item: " << item << endl;
#endif
        if (ignore_empty_item && item.empty())
            continue;// use to skip empty item
        parsed_item.push_back(item);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %rsi
leaq -0x1d0(%rbp), %r15
pushq $0x18
popq %rdx
movq %r15, %rdi
callq 0x22b0
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movsbl %r12b, %r12d
leaq -0x48(%rbp), %r13
movq %r15, %rdi
movq %r13, %rsi
movl %r12d, %edx
callq 0x2330
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x86dc
testb %bl, %bl
je 0x86cf
cmpq $0x0, -0x40(%rbp)
je 0x86a8
movq %r14, %rdi
movq %r13, %rsi
callq 0x8724
jmp 0x86a8
leaq -0x48(%rbp), %rdi
callq 0x2388
leaq -0x1d0(%rbp), %rdi
callq 0x2160
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2388
leaq -0x1d0(%rbp), %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/thanoskoutr[P]Chip-8-Emulator/chip8.cpp
// Function: Chip8::initialize()
void Chip8::initialize()
{

  opcode = 0;   // Reset current Opcode
  I = 0;        // Reset I register
  pc = 0x200;   // Set PC to start at 0x200 (Program Start Adress)
  sp = 0;       // Reset stack pointer

  /* Reset Timers */
  delay_timer = 0;
  sound_timer = 0;

	for (int i = 0; i < SCREEN_SIZE; i++)
    gfx[i] = 0;     // Clear Display

  for (int i = 0; i < KEY_SIZE; i++)
    key[i] = 0;     // Clear Keypad

  for (int i = 0; i < MEMORY_SIZE; i++)
    memory[i] = 0;  // Clear Memory

  for (int i = 0; i < 16; i++)
  {
    V[i] = 0;       // Clear Registers
    stack[i] = 0;   // Clear Stack
  }

  for (int i = 0; i < 80; i++)
    memory[i] = chip8_fontset[i];  // Store Font Set to Memory (0x000-0x050)

  /* Clear screen once */
  drawFlag = true;

  // srand (time(NULL));

}

// Assembly:
andw $0x0, 0x812(%rdi)
movl $0x2000000, 0x1824(%rdi) # imm = 0x2000000
andl $0x0, 0x1848(%rdi)
pushq $0x1
popq %rax
cmpq $0x801, %rax            # imm = 0x801
je 0x24dd
movb $0x0, (%rdi,%rax)
incq %rax
jmp 0x24cc
movl $0x801, %eax            # imm = 0x801
cmpq $0x811, %rax            # imm = 0x811
je 0x24f3
movb $0x0, (%rdi,%rax)
incq %rax
jmp 0x24e2
movl $0x814, %eax            # imm = 0x814
cmpq $0x1814, %rax           # imm = 0x1814
je 0x2509
movb $0x0, (%rdi,%rax)
incq %rax
jmp 0x24f8
movl $0xc14, %eax            # imm = 0xC14
cmpq $0xc24, %rax            # imm = 0xC24
je 0x2528
movb $0x0, 0xc00(%rdi,%rax)
andw $0x0, (%rdi,%rax,2)
incq %rax
jmp 0x250e
xorl %eax, %eax
leaq 0x3c7f(%rip), %rcx      # 0x61b0
cmpq $0x50, %rax
je 0x2546
movb (%rax,%rcx), %dl
movb %dl, 0x814(%rdi,%rax)
incq %rax
jmp 0x2531
movb $0x1, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/thanoskoutr[P]Chip-8-Emulator/chip8.cpp
// Function: Chip8::loadApplication(char const*)
int Chip8::loadApplication(const char * file)
{
	initialize();

  /* Open File */
  FILE *fptr;
  unsigned long file_size;

  if ((fptr = fopen(file,"rb")) == NULL)
  {
    printf("Error! opening program\n");
    return 1;
  }

  /* Check file size */
  fseek(fptr, 0, SEEK_END); // seek to end of file (non-portable !)
  file_size = ftell(fptr);
  fseek(fptr, 0, SEEK_SET); // seek back to beginning of file
  printf("Filesize: %ld bytes\n", file_size);

  /* Allocate memory to contain the whole file */
  char *buffer = (char*) malloc(sizeof(char)*file_size);
  if (buffer == NULL)
  {
    fprintf(stderr, "Memory error! Could not allocate %ld bytes of memory\n", file_size);
    fclose(fptr);
    return 1;
  }

  /* Copy the file into the buffer */
  size_t res = fread(buffer, 1, file_size, fptr);
  if (res != file_size)
  {
    fprintf(stderr, "Read error! Could not read %ld bytes of memory\n", file_size);
    fclose(fptr);
    free(buffer);
    return 1;
  }

  /* Copy buffer to Chip8 memory */
  if (file_size > MEMORY_SIZE - 512) // If file cannot fit into memory
  {
    fprintf(stderr, "Error! Program of %ld bytes too big for memory \n", file_size);
    fclose(fptr);
    free(buffer);
    return 1;
  }
  for(unsigned int i = 0; i < file_size; i++)
    memory[i + 512] = buffer[i];  // Start program at (0x200 == 512)

  /* Close File, Free Buffer */
  fclose(fptr);
  free(buffer);

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x24b0
leaq 0x1b38(%rip), %rsi      # 0x409c
movq %rbx, %rdi
callq 0x2260
testq %rax, %rax
je 0x2612
movq %rax, %rbx
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x2240
movq %rbx, %rdi
callq 0x2030
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2240
leaq 0x1afc(%rip), %rdi      # 0x409f
movq %r15, %rsi
xorl %eax, %eax
callq 0x2060
movq %r15, %rdi
callq 0x2290
testq %rax, %rax
je 0x262d
movq %rax, %r12
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x22c0
cmpq %r15, %rax
jne 0x2652
cmpq $0xe00, %r15            # imm = 0xE00
ja 0x2665
xorl %eax, %eax
cmpl %r15d, %eax
jae 0x25fe
movb (%r12,%rax), %cl
leal 0x200(%rax), %edx
movb %cl, 0x814(%r14,%rdx)
incq %rax
jmp 0x25e2
movq %rbx, %rdi
callq 0x2210
movq %r12, %rdi
callq 0x2270
xorl %eax, %eax
jmp 0x2621
leaq 0x1bae(%rip), %rdi      # 0x41c7
callq 0x22e0
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x39a4(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
leaq 0x1a76(%rip), %rsi      # 0x40b4
movq %r15, %rdx
xorl %eax, %eax
callq 0x22a0
movq %rbx, %rdi
callq 0x2210
jmp 0x261e
movq 0x397f(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
leaq 0x1a87(%rip), %rsi      # 0x40ea
jmp 0x2676
movq 0x396c(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
leaq 0x1aa4(%rip), %rsi      # 0x411a
movq %r15, %rdx
xorl %eax, %eax
callq 0x22a0
movq %rbx, %rdi
callq 0x2210
movq %r12, %rdi
callq 0x2270
jmp 0x261e
// File: /workspace/github_cpp_makefile_star2_O2/jkeys-ecg-nmsu[P]graph-with-search-algorithms/Graph.cpp
// Function: Graph::initEmpty(int)
void Graph::initEmpty(int max_nodes) {
	current_id = 0;
	current_cc = 0;
	m_clock = 0;
	
	m_nodes.clear();
	m_adjList.clear();
	m_edgeList.clear();
	
	m_nodes.reserve(max_nodes); 
	m_adjList.reserve(max_nodes); 
	m_edgeList.reserve(max_nodes);
	set<Node> empty_list;	
	list<Edge> empty_edge_list;	
	for(size_t i = 0; i != max_nodes; i++) {
		m_adjList.push_back(empty_list);
		m_edgeList.push_back(empty_edge_list);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r12
andq $0x0, 0x60(%rdi)
movl %esi, %r15d
andl $0x0, 0x68(%rdi)
callq 0x5192
leaq 0x18(%r12), %rbx
movq %rbx, %rdi
callq 0x51a0
leaq 0x30(%r12), %r14
movq %r14, %rdi
callq 0x51ae
movslq %r15d, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x51bc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5248
movq %r14, %rdi
movq %r15, %rsi
callq 0x52de
leaq -0x68(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x40(%rbp), %r12
movq %r12, 0x8(%r12)
movq %r12, (%r12)
andq $0x0, 0x10(%r12)
leaq -0x70(%rbp), %r13
subq $0x1, %r15
jb 0x2c7d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5374
movq %r14, %rdi
movq %r12, %rsi
callq 0x53b0
jmp 0x2c5f
leaq -0x40(%rbp), %rdi
callq 0x2a4a
leaq -0x70(%rbp), %rdi
callq 0x2aa8
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x2a4a
leaq -0x70(%rbp), %rdi
callq 0x2aa8
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O2/jkeys-ecg-nmsu[P]graph-with-search-algorithms/Graph.cpp
// Function: calculateDistance(Node&, Node&)
double calculateDistance(Node & u, Node & v) {
	const double EARTH_RADIUS = 3961.0;
	const double MY_PI = 3.14159;
	
	double lat_change = (v.latitude() - u.latitude())*MY_PI/180.0; 
	double long_change = (v.longitude() - u.longitude())*MY_PI/180.0;
	
	double a = sin(lat_change/2.0)*sin(lat_change/2.0)  +  (  cos(u.latitude()*MY_PI/180.0)*cos(v.latitude()*MY_PI/180.0)*sin(long_change/2.0)*sin(long_change/2.0) );
	
	double c = 2.0 * atan2(sqrt(a), sqrt(1-a));
	double d = EARTH_RADIUS*c;

	return d;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x6b08
movsd %xmm0, -0x18(%rbp)
movq %r14, %rdi
callq 0x6b08
movsd -0x18(%rbp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x7385(%rip), %xmm1     # 0xb040
divsd 0x7385(%rip), %xmm1     # 0xb048
movsd %xmm1, -0x18(%rbp)
movq %rbx, %rdi
callq 0x6b14
movsd %xmm0, -0x20(%rbp)
movq %r14, %rdi
callq 0x6b14
movsd -0x20(%rbp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x7352(%rip), %xmm1     # 0xb040
divsd 0x7352(%rip), %xmm1     # 0xb048
movsd %xmm1, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
mulsd 0x7348(%rip), %xmm0     # 0xb050
movsd %xmm0, -0x18(%rbp)
callq 0x2080
movsd %xmm0, -0x30(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x2080
movsd %xmm0, -0x18(%rbp)
movq %r14, %rdi
callq 0x6b08
mulsd 0x730a(%rip), %xmm0     # 0xb040
divsd 0x730a(%rip), %xmm0     # 0xb048
callq 0x2380
movsd %xmm0, -0x28(%rbp)
movq %rbx, %rdi
callq 0x6b08
mulsd 0x72e8(%rip), %xmm0     # 0xb040
divsd 0x72e8(%rip), %xmm0     # 0xb048
callq 0x2380
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
mulsd 0x72d4(%rip), %xmm0     # 0xb050
movsd %xmm0, -0x20(%rbp)
callq 0x2080
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x2080
movsd -0x18(%rbp), %xmm1
mulsd -0x28(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm1
addsd %xmm0, %xmm1
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm1
jb 0x3dbd
sqrtsd %xmm1, %xmm2
jmp 0x3dd8
movapd %xmm1, %xmm0
movsd %xmm1, -0x18(%rbp)
callq 0x21b0
xorpd %xmm3, %xmm3
movsd -0x18(%rbp), %xmm1
movapd %xmm0, %xmm2
movsd 0x7278(%rip), %xmm0     # 0xb058
subsd %xmm1, %xmm0
ucomisd %xmm3, %xmm0
jb 0x3df0
sqrtsd %xmm0, %xmm1
jmp 0x3e03
movsd %xmm2, -0x20(%rbp)
callq 0x21b0
movsd -0x20(%rbp), %xmm2
movapd %xmm0, %xmm1
movapd %xmm2, %xmm0
callq 0x2050
addsd %xmm0, %xmm0
mulsd 0x7248(%rip), %xmm0     # 0xb060
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jkeys-ecg-nmsu[P]graph-with-search-algorithms/Graph.cpp
// Function: Graph::sameDistances(std::vector<int, std::allocator<int>>)
bool Graph::sameDistances(vector<int> V) {
	assert(m_nodes.size() == V.size());
	
	for(size_t i = 0; i != V.size(); i++) {
		if(V.at(i) != dist(m_nodes.at(i)))
			return false;
	}
	
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x7, %rax
movq 0x8(%rsi), %rcx
subq (%rsi), %rcx
sarq $0x2, %rcx
cmpq %rcx, %rax
jne 0x43c3
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
movq %rax, %r15
movq 0x8(%rbx), %r12
subq (%rbx), %r12
sarq $0x2, %r12
cmpq %r12, %rax
je 0x43b0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4fac
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4fce
movq %r14, %rdi
movq %rax, %rsi
callq 0x4106
leaq 0x1(%r15), %rax
ucomisd -0x28(%rbp), %xmm0
jne 0x43b0
jnp 0x4366
cmpq %r12, %r15
sete %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6d82(%rip), %rdi      # 0xb14c
leaq 0x6cac(%rip), %rsi      # 0xb07d
leaq 0x6d8f(%rip), %rcx      # 0xb167
movl $0x128, %edx            # imm = 0x128
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O2/jkeys-ecg-nmsu[P]graph-with-search-algorithms/Graph.cpp
// Function: Graph::sameEdges(std::vector<Edge, std::allocator<Edge>>)
bool Graph::sameEdges(vector<Edge> E) {
	assert(m_edges_MST.size() == E.size());	
	
	for(size_t i = 0; i != E.size(); i++) {
		cerr << "in same edges, edge: ";
		m_edges_MST.at(i).print(*this);
		if( !m_edges_MST.at(i).equals(E.at(i)) )
			return false;
	}
	
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x50(%rdi), %rax
subq 0x48(%rdi), %rax
movq 0x8(%rsi), %rcx
subq (%rsi), %rcx
cmpq %rcx, %rax
jne 0x44a5
movq %rsi, %rbx
movq %rdi, %r13
leaq 0x48(%rdi), %rax
movq %rax, -0x30(%rbp)
xorl %ecx, %ecx
movq %rcx, %r12
movq 0x8(%rbx), %r14
subq (%rbx), %r14
sarq $0x4, %r14
cmpq %r14, %rcx
je 0x4490
movq 0xdbbe(%rip), %rdi      # 0x11ff0
leaq 0x6d98(%rip), %rsi      # 0xb1d1
callq 0x2200
movq -0x30(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x4ff0
movq %rax, %rdi
movq %r13, %rsi
callq 0x5012
movq %r15, %rdi
movq %r12, %rsi
callq 0x4ff0
movq %r13, %r15
movq %rax, %r13
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4ff0
movq (%rax), %rsi
movsd 0x8(%rax), %xmm0
movq %r13, %rdi
movq %r15, %r13
callq 0x5114
leaq 0x1(%r12), %rcx
testb %al, %al
jne 0x4418
cmpq %r14, %r12
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6ce2(%rip), %rdi      # 0xb18e
leaq 0x6bca(%rip), %rsi      # 0xb07d
leaq 0x6cf3(%rip), %rcx      # 0xb1ad
movl $0x133, %edx            # imm = 0x133
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O2/jkeys-ecg-nmsu[P]graph-with-search-algorithms/Graph.cpp
// Function: printSet(std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
void printSet(set<string> s) {
	cerr << "printing set of strings already loaded into m_nodes: " << endl;
	for(set<string>::iterator itr = s.begin(); itr != s.end(); itr++)
		cerr << *itr << "_and size of it: " << itr->size() << endl;
	
	cerr << "exit printSet" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0xda97(%rip), %r14      # 0x11ff0
leaq 0x6ca2(%rip), %rsi      # 0xb202
movq %r14, %rdi
callq 0x2200
movq %rax, %rdi
callq 0x2120
movq 0x18(%rbx), %r12
addq $0x8, %rbx
leaq 0x6cb9(%rip), %r15      # 0xb238
cmpq %rbx, %r12
je 0x45be
leaq 0x20(%r12), %rsi
movq %r14, %rdi
callq 0x21e0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2200
movq 0x28(%r12), %rsi
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
callq 0x2120
movq %r12, %rdi
callq 0x2260
movq %rax, %r12
jmp 0x457f
movq 0xda2b(%rip), %rdi      # 0x11ff0
leaq 0x6c7e(%rip), %rsi      # 0xb24a
callq 0x2200
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O2/jkeys-ecg-nmsu[P]graph-with-search-algorithms/Graph.cpp
// Function: Graph::reset()
void Graph::reset() {	
	this->resetClock();
	this->current_cc = 0;
	
  for (size_t i = 0; i != this->m_nodes.size(); i++) { 
	setDist(m_nodes[i], M_INFINITY);
	this->m_nodes[i].resetVisitedFlag();
	setPre(this->m_nodes[i], -1);
	setPost(this->m_nodes[i], -1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x64(%rdi)
xorl %r15d, %r15d
pushq $-0x1
popq %r14
xorl %r12d, %r12d
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
sarq $0x7, %rax
cmpq %rax, %r12
je 0x471a
addq %r15, %rsi
movq %rbx, %rdi
movsd 0x6989(%rip), %xmm0     # 0xb068
callq 0x3fba
movq (%rbx), %rdi
addq %r15, %rdi
callq 0x6a42
movq (%rbx), %rsi
addq %r15, %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x3f66
movq (%rbx), %rsi
addq %r15, %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x3f90
incq %r12
subq $-0x80, %r15
jmp 0x46be
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jkeys-ecg-nmsu[P]graph-with-search-algorithms/Graph.cpp
// Function: Graph::reverse()
Graph Graph::reverse() {
	Graph g_new;
	g_new.initEmpty(75000); //75,000 nodes
	g_new.copyNodes(*this);
			
	for(unsigned int u = 0; u != m_nodes.size(); u++) {
		set<Node> adjNodes = getAdjNodes(m_nodes[u]);
		for(set<Node>::iterator v = adjNodes.begin(); v != adjNodes.end(); v++) {
			g_new.addEdge(*v, m_nodes[u]);
		}
 	}
	
	return g_new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2b5c
movq %rbx, %rdi
movl $0x124f8, %esi          # imm = 0x124F8
callq 0x2bcc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4724
xorl %r13d, %r13d
leaq -0x58(%rbp), %r15
leaq -0x60(%rbp), %r12
movl %r13d, %r13d
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x7, %rax
cmpq %r13, %rax
je 0x4873
movq %r13, -0x30(%rbp)
shlq $0x7, %r13
addq %r13, %rsi
movq %r14, %rdi
callq 0x428a
movq %r12, %rdi
movq %rax, %rsi
callq 0x5516
movq -0x48(%rbp), %r12
cmpq %r15, %r12
je 0x485e
leaq 0x20(%r12), %rsi
movq (%r14), %rdx
addq %r13, %rdx
movq %rbx, %rdi
callq 0x3e22
movq %r12, %rdi
callq 0x2260
movq %rax, %r12
jmp 0x4839
leaq -0x60(%rbp), %r12
movq %r12, %rdi
callq 0x2aa8
movq -0x30(%rbp), %r13
incl %r13d
jmp 0x4801
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4887
movq %rax, %r14
jmp 0x4898
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x2aa8
movq %rbx, %rdi
callq 0x2938
movq %r14, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/jkeys-ecg-nmsu[P]graph-with-search-algorithms/Graph.cpp
// Function: Graph::save(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
void Graph::save(const string & file) const {
	ofstream fs( file.c_str() );
	assert( fs.is_open() );
	
	
	for(unsigned int u = 0; u != m_nodes.size(); u++) {
		set<Node> adjNodes = getAdjNodes(m_nodes[u]);
		list<Edge> uEdges = getEdges(m_nodes[u]);
		//only print to file if this node has children (directed)
		for(list<Edge>::iterator e = uEdges.begin(); e != uEdges.end(); e++) {
			fs << name(e->u_id()) << '\t' << name(e->v_id()) << '\t' << e->weight() << '\n';
		}
 	}
		
	fs.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp            # imm = 0x298
movq %rdi, -0x30(%rbp)
movq (%rsi), %rsi
leaq -0x2c0(%rbp), %rdi
pushq $0x10
popq %rdx
callq 0x2240
leaq -0x250(%rbp), %rdi
callq 0x2090
testb %al, %al
je 0x4a51
xorl %r14d, %r14d
leaq -0xc0(%rbp), %r12
leaq -0x90(%rbp), %r13
movl %r14d, %r14d
movq -0x30(%rbp), %rdi
movq (%rdi), %rsi
movq 0x8(%rdi), %rax
subq %rsi, %rax
sarq $0x7, %rax
cmpq %r14, %rax
je 0x4a27
movq %r14, %r15
shlq $0x7, %r15
addq %r15, %rsi
callq 0x42ac
movq %r12, %rdi
movq %rax, %rsi
callq 0x5516
movq %r14, -0x38(%rbp)
movq -0x30(%rbp), %rdi
addq (%rdi), %r15
movq %r15, %rsi
callq 0x42f0
leaq -0x50(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x53ec
movq %r14, %r12
movq (%r12), %r12
cmpq %r14, %r12
je 0x4a04
leaq 0x10(%r12), %r15
movq %r15, %rdi
callq 0x6b30
movq %r13, %r14
movq %r13, %rdi
movq -0x30(%rbp), %rsi
movl %eax, %edx
callq 0x40b2
leaq -0x2c0(%rbp), %rdi
movq %r14, %rsi
callq 0x21e0
movq %rax, %rdi
pushq $0x9
popq %rsi
callq 0x2270
movq %rax, %r14
movq %r15, %rdi
callq 0x6b38
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
movl %eax, %edx
callq 0x40b2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21e0
movq %rax, %rdi
pushq $0x9
popq %rsi
callq 0x2270
movq %rax, %r14
movq %r15, %rdi
callq 0x6b42
movq %r14, %rdi
callq 0x2320
movq %rax, %rdi
pushq $0xa
popq %rsi
callq 0x2270
leaq -0x70(%rbp), %rdi
callq 0x2110
movq %r13, %rdi
callq 0x2110
leaq -0x50(%rbp), %r14
jmp 0x4954
movq %r14, %rdi
callq 0x2a4a
leaq -0xc0(%rbp), %r12
movq %r12, %rdi
callq 0x2aa8
movq -0x38(%rbp), %r14
incl %r14d
jmp 0x48f7
leaq -0x2c0(%rbp), %rdi
callq 0x22c0
leaq -0x2c0(%rbp), %rdi
callq 0x22f0
addq $0x298, %rsp            # imm = 0x298
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6618(%rip), %rdi      # 0xb070
leaq 0x661e(%rip), %rsi      # 0xb07d
leaq 0x67f2(%rip), %rcx      # 0xb258
movl $0x1b8, %edx            # imm = 0x1B8
callq 0x2170
jmp 0x4a72
movq %rax, %rbx
jmp 0x4ab5
movq %rax, %rbx
jmp 0x4aa9
jmp 0x4a83
movq %rax, %rbx
jmp 0x4aa0
movq %rax, %rbx
jmp 0x4a94
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x2110
leaq -0x90(%rbp), %rdi
callq 0x2110
leaq -0x50(%rbp), %rdi
callq 0x2a4a
leaq -0xc0(%rbp), %rdi
callq 0x2aa8
leaq -0x2c0(%rbp), %rdi
callq 0x22f0
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O2/jkeys-ecg-nmsu[P]graph-with-search-algorithms/Graph.cpp
// Function: Graph::saveUndirected(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
void Graph::saveUndirected(const string & file) const {
	ofstream fs( file.c_str() );
	assert( fs.is_open() );
		
	for(unsigned int u = 0; u != m_nodes.size(); u++) {
		set<Node> adjNodes = getAdjNodes(m_nodes[u]);
		for(set<Node>::iterator v = adjNodes.begin(); v != adjNodes.end(); v++) {
			fs << m_nodes[u].name() << '\t' << m_nodes[v->id()].name() << '\n';
			fs << m_nodes[v->id()].name() << '\t' << m_nodes[u].name() << '\n'; //may print duplicates;		
		}
 	}
	
	
	fs.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdi, %rbx
movq (%rsi), %rsi
leaq -0x260(%rbp), %rdi
pushq $0x10
popq %rdx
callq 0x2240
leaq -0x1f0(%rbp), %rdi
callq 0x2090
testb %al, %al
je 0x4c57
xorl %r13d, %r13d
leaq -0x60(%rbp), %r14
movl %r13d, %r13d
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
sarq $0x7, %rax
cmpq %r13, %rax
je 0x4c2d
movq %r13, -0x30(%rbp)
shlq $0x7, %r13
addq %r13, %rsi
movq %rbx, %rdi
callq 0x42ac
movq %r14, %rdi
movq %rax, %rsi
callq 0x5516
movq -0x48(%rbp), %r14
leaq -0x58(%rbp), %rax
cmpq %rax, %r14
je 0x4c15
movq (%rbx), %rdi
addq %r13, %rdi
callq 0x6aca
leaq -0x260(%rbp), %rdi
movq %rax, %rsi
callq 0x21e0
movq %rax, %rdi
pushq $0x9
popq %rsi
callq 0x2270
movq %rax, %r12
leaq 0x20(%r14), %r15
movq %r15, %rdi
callq 0x6ac0
movslq %eax, %rdi
shlq $0x7, %rdi
addq (%rbx), %rdi
callq 0x6aca
movq %r12, %rdi
movq %rax, %rsi
callq 0x21e0
movq %rax, %rdi
pushq $0xa
popq %rsi
callq 0x2270
movq %r15, %rdi
callq 0x6ac0
movslq %eax, %rdi
shlq $0x7, %rdi
addq (%rbx), %rdi
callq 0x6aca
leaq -0x260(%rbp), %rdi
movq %rax, %rsi
callq 0x21e0
movq %rax, %rdi
pushq $0x9
popq %rsi
callq 0x2270
movq %rax, %r15
movq (%rbx), %rdi
addq %r13, %rdi
callq 0x6aca
movq %r15, %rdi
movq %rax, %rsi
callq 0x21e0
movq %rax, %rdi
pushq $0xa
popq %rsi
callq 0x2270
movq %r14, %rdi
callq 0x2260
movq %rax, %r14
jmp 0x4b4a
leaq -0x60(%rbp), %r14
movq %r14, %rdi
callq 0x2aa8
movq -0x30(%rbp), %r13
incl %r13d
jmp 0x4b0e
leaq -0x260(%rbp), %rdi
callq 0x22c0
leaq -0x260(%rbp), %rdi
callq 0x22f0
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6412(%rip), %rdi      # 0xb070
leaq 0x6418(%rip), %rsi      # 0xb07d
leaq 0x6613(%rip), %rcx      # 0xb27f
movl $0x1c9, %edx            # imm = 0x1C9
callq 0x2170
jmp 0x4c78
movq %rax, %rbx
jmp 0x4c89
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x2aa8
leaq -0x260(%rbp), %rdi
callq 0x22f0
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/jkeys-ecg-nmsu[P]graph-with-search-algorithms/Graph.cpp
// Function: operator<<(std::ostream&, Graph const&)
std::ostream& operator<<(std::ostream & out, const Graph & g) {
	//cout << "in Graph out stream operator, g.m_nodes.size(): " << g.num_nodes() << endl;

	out << "Nodes in the graph: " << endl;
	for (unsigned int i = 0; i < g.num_nodes(); i++) {
	  out << g.getNode(i).name() << " ";
	}

	out << endl;
	out << "Adjacency list of the graph: " << endl;

	for (unsigned int i = 0; i < g.num_nodes(); i++) {
		out << "Node " << g.getNode ( i ).name() << ": ";
		const set<Node> neighbors = g.getAdjNodes(g.getNode(i));
		for (set < Node> :: const_iterator itr = neighbors.begin(); itr != neighbors.end(); ++itr) {
			out << itr->name() << " ";
	}
	  out << endl;
	}

	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x65f5(%rip), %rsi      # 0xb2b0
callq 0x2200
movq %rax, %rdi
callq 0x2120
xorl %eax, %eax
leaq 0x68be(%rip), %r15      # 0xb58f
movl %eax, %r14d
movq (%r12), %rdi
movq 0x8(%r12), %rax
subq %rdi, %rax
sarq $0x7, %rax
cmpq %r14, %rax
jbe 0x4d14
movq %r14, %rax
shlq $0x7, %rax
addq %rax, %rdi
callq 0x6aca
movq %rbx, %rdi
movq %rax, %rsi
callq 0x21e0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2200
leal 0x1(%r14), %eax
jmp 0x4cd1
movq %rbx, %rdi
callq 0x2120
leaq 0x65a2(%rip), %rsi      # 0xb2c5
movq %rbx, %rdi
callq 0x2200
movq %rax, %rdi
callq 0x2120
xorl %r13d, %r13d
leaq -0x68(%rbp), %r14
leaq 0x684e(%rip), %r15      # 0xb58f
movq %r12, -0x30(%rbp)
movl %r13d, %r13d
movq 0x8(%r12), %rax
subq (%r12), %rax
sarq $0x7, %rax
cmpq %r13, %rax
jbe 0x4e12
movq %rbx, %rdi
leaq 0x657b(%rip), %rsi      # 0xb2e3
callq 0x2200
movq %rax, -0x40(%rbp)
movq %r13, -0x38(%rbp)
shlq $0x7, %r13
movq (%r12), %rdi
addq %r13, %rdi
callq 0x6aca
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x21e0
movq %rax, %rdi
leaq 0x6684(%rip), %rsi      # 0xb41f
callq 0x2200
addq (%r12), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x42ac
leaq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x5516
movq -0x58(%rbp), %r12
cmpq %r14, %r12
je 0x4df1
leaq 0x20(%r12), %rdi
callq 0x6aca
movq %rbx, %rdi
movq %rax, %rsi
callq 0x21e0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2200
movq %r12, %rdi
callq 0x2260
movq %rax, %r12
jmp 0x4dbf
movq %rbx, %rdi
callq 0x2120
movq -0x38(%rbp), %r13
leaq -0x70(%rbp), %rdi
callq 0x2aa8
incl %r13d
movq -0x30(%rbp), %r12
jmp 0x4d45
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4e26
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x2aa8
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/jkeys-ecg-nmsu[P]graph-with-search-algorithms/ListPriorityQueue.cpp
// Function: ListPriorityQueue::remove_min(Graph&)
Node ListPriorityQueue::remove_min(Graph & g) {
	std::list<Node>::iterator min_node = this->m_queue.begin();
	for(std::list<Node>::iterator curr = this->m_queue.begin(); curr != this->m_queue.end(); curr++) {
		if(g.dist(*curr) < g.dist(*min_node)) {
			min_node = curr;
		}
	}
	
	Node result = g.getNode(min_node->id());
	this->m_queue.erase(min_node);
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r13
movq %r13, %r15
cmpq %r14, %r13
je 0x6c0b
leaq 0x10(%r13), %rsi
movq %r12, %rdi
callq 0x4106
movsd %xmm0, -0x30(%rbp)
leaq 0x10(%r15), %rsi
movq %r12, %rdi
callq 0x4106
ucomisd -0x30(%rbp), %xmm0
movq %r13, %rax
ja 0x6c02
movq %r15, %rax
movq (%r13), %r13
movq %rax, %r15
jmp 0x6bd3
leaq 0x10(%r15), %rdi
callq 0x6ac0
movslq %eax, %rsi
movq %r12, %rdi
callq 0x36ce
movq %rbx, %rdi
movq %rax, %rsi
callq 0x28ba
movq %r14, %rdi
movq %r15, %rsi
callq 0x6ce0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jkeys-ecg-nmsu[P]graph-with-search-algorithms/Debug.cpp
// Function: trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string trim(const std::string& str, const std::string& whitespace/*=" \t\n\r" */)
{
    const int strBegin = str.find_first_not_of(whitespace);
    if (strBegin == std::string::npos)
        return ""; // no content

    const int strEnd = str.find_last_not_of(whitespace);
    const int strRange = strEnd - strBegin + 1;

    return str.substr(strBegin, strRange);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
xorl %edx, %edx
callq 0x21c0
movq %rax, %r13
movq %rax, %r15
shlq $0x20, %r15
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
cmpq %rax, %r15
jne 0x75c2
leaq 0x3e1b(%rip), %rsi      # 0xb3cf
leaq -0x29(%rbp), %rdx
movq %rbx, %rdi
callq 0x20e0
jmp 0x75ea
sarq $0x20, %r15
pushq $-0x1
popq %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2390
subl %r13d, %eax
incl %eax
movslq %eax, %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2220
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq