LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Crawler995[P]Cpp-Ray-Tracing/libs/cook_torrance_material.cpp
// Function: CookTorranceMaterial::shadow_mask(Ray3, Vector3)
double CookTorranceMaterial::shadow_mask(Ray3 ray, Vector3 normal) {
    Vector3 light(1, 1, 1);
    Vector3 h = light.normalize().subtract(ray.get_dir()).normalize();
    double n_dot_h = normal.dot(h);
    double a = 1.0 / (roughness * roughness * pow(n_dot_h, 4) * 4);
    double b = (n_dot_h * n_dot_h - 1) / (roughness * roughness * n_dot_h * n_dot_h);
    return a * exp(b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
leaq 0x40(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x20(%rbp), %rdi
movsd 0x300c(%rip), %xmm2     # 0x9098
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x2c50
leaq -0x68(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2d90
movq -0xd8(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x3470
leaq -0x50(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x80(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x2f80
leaq -0x38(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2d90
movq -0xd0(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0xa0(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x30d0
movq -0xc0(%rbp), %rax
movsd %xmm0, -0x88(%rbp)
movsd 0x50(%rax), %xmm0
mulsd 0x50(%rax), %xmm0
movsd %xmm0, -0xc8(%rbp)
movsd -0x88(%rbp), %xmm0
movsd 0x2f6f(%rip), %xmm1     # 0x90d8
callq 0x21d0
movsd -0xc8(%rbp), %xmm1
movq -0xc0(%rbp), %rax
mulsd %xmm0, %xmm1
movsd 0x2f4f(%rip), %xmm0     # 0x90d8
mulsd %xmm0, %xmm1
movsd 0x2f03(%rip), %xmm0     # 0x9098
divsd %xmm1, %xmm0
movsd %xmm0, -0xa8(%rbp)
movsd -0x88(%rbp), %xmm0
movsd -0x88(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x2fa3(%rip), %xmm1     # 0x9160
addsd %xmm1, %xmm0
movsd 0x50(%rax), %xmm1
mulsd 0x50(%rax), %xmm1
mulsd -0x88(%rbp), %xmm1
mulsd -0x88(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0xb0(%rbp)
movsd -0xa8(%rbp), %xmm0
movsd %xmm0, -0xb8(%rbp)
movsd -0xb0(%rbp), %xmm0
callq 0x21f0
movaps %xmm0, %xmm1
movsd -0xb8(%rbp), %xmm0
mulsd %xmm1, %xmm0
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
// File: Crawler995[P]Cpp-Ray-Tracing/libs/checker_material.cpp
// Function: CheckMaterial::CheckMaterial(double, double, double, double, double, Color, Color)
CheckMaterial::CheckMaterial(double sc, double a, double d, double s, double h, Color a_c, Color s_c) {
    scale = sc;
    envir_factor = a;
    diffuse_factor = d;
    specular_factor = s;
    highlight_factor = h;
    envir_color = a_c;
    specular_color = s_c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x1c(%rbp)
movl %edx, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movq %rcx, -0x38(%rbp)
movl %r8d, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x20(%rbp)
movq %rdi, -0x40(%rbp)
movsd %xmm0, -0x48(%rbp)
movsd %xmm1, -0x50(%rbp)
movsd %xmm2, -0x58(%rbp)
movsd %xmm3, -0x60(%rbp)
movsd %xmm4, -0x68(%rbp)
movq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x57c0
movq -0x70(%rbp), %rax
leaq 0x67e8(%rip), %rcx      # 0xcd50
addq $0x10, %rcx
movq %rcx, (%rax)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, 0x48(%rax)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x58(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd -0x60(%rbp), %xmm0
movsd %xmm0, 0x18(%rax)
movsd -0x68(%rbp), %xmm0
movsd %xmm0, 0x50(%rax)
movq -0xc(%rbp), %rcx
movq %rcx, 0x20(%rax)
movl -0x4(%rbp), %ecx
movl %ecx, 0x28(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x38(%rax)
movl -0x20(%rbp), %ecx
movl %ecx, 0x40(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Crawler995[P]Cpp-Ray-Tracing/libs/render_engine.cpp
// Function: RenderEngine::RenderEngine(int, int, int, int)
RenderEngine::RenderEngine(int w, int h, int st, int rt) {
    image_width = w;
    image_height = h;
    sample_times = st;
    max_reflect_times = rt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0xc(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: soccin[P]BIC-RNAseq/tools/MergeFusion/main.cpp
// Function: main
int main(int argc, char* argv[])
{
    parseOption(argc, argv);
    Merger my_merger;
    if(normalize_gene)
        my_merger.loadHugoFile(hugo_data_file.c_str());
    //my_merger.printHugoMap();
    for(size_t i = 0; i < input_files.size(); i++)
    {
        my_merger.loadFusionFile(input_files[i].first.c_str(), input_files[i].second, normalize_chrom, normalize_gene);
    }
    if(!sorting_criteria.empty())
        my_merger.sortBy(sorting_criteria);
    my_merger.outputStandardFusion(output_file.c_str());
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x3ab0
leaq -0x58(%rbp), %rdi
callq 0x5710
testb $0x1, 0x1a103(%rip)     # 0x1e4a8
je 0x43d4
leaq 0x1a102(%rip), %rdi     # 0x1e4b0
callq 0x3120
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0x6550
jmp 0x43c1
jmp 0x43d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x450b
movq $0x0, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq 0x1a062(%rip), %rdi     # 0x1e450
callq 0x47d0
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0x4476
movq -0x70(%rbp), %rsi
leaq 0x1a043(%rip), %rdi     # 0x1e450
movq %rdi, -0xa8(%rbp)
callq 0x4800
movq %rax, %rdi
callq 0x3120
movq -0xa8(%rbp), %rdi
movq %rax, -0xa0(%rbp)
movq -0x70(%rbp), %rsi
callq 0x4800
movq -0xa0(%rbp), %rsi
movl 0x20(%rax), %edx
movzbl 0x1a05e(%rip), %r8d     # 0x1e4a8
movzbl 0x19e3f(%rip), %ecx     # 0x1e290
andl $0x1, %ecx
andl $0x1, %r8d
leaq -0x58(%rbp), %rdi
callq 0x5770
jmp 0x4463
jmp 0x4465
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0x43dc
leaq 0x1a00b(%rip), %rdi     # 0x1e488
callq 0x3440
testb $0x1, %al
jne 0x44d5
leaq 0x19ffb(%rip), %rsi     # 0x1e488
leaq -0x90(%rbp), %rdi
callq 0x3130
jmp 0x449b
leaq -0x58(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x5d30
jmp 0x44ad
leaq -0x90(%rbp), %rdi
callq 0x3508
jmp 0x44d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3508
jmp 0x450b
leaq 0x19f8c(%rip), %rdi     # 0x1e468
callq 0x3120
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0x5b90
jmp 0x44ef
movl $0x0, -0x4(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x5740
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0x5740
movq -0x60(%rbp), %rdi
callq 0x3470
nopl (%rax)
// File: soccin[P]BIC-RNAseq/tools/MergeFusion/Merger.cpp
// Function: Merger::outputStandardFusion(char const*)
void Merger::outputStandardFusion(const char* filename)
{
#ifdef _DEBUG
    cout << "[DEBUG]: Printing result to: " << filename << endl;
#endif
    ofstream output_fs(filename);
    if(!output_fs)
    {
        cerr << "Error: fail to open output file: " << filename << endl;
        exit(1);
    }
    output_fusion_header(output_fs);
    for(size_t i = 0; i < fusion_vec.size(); i++)
        output_fs << fusion_vec[i] << endl;
    output_fs.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x238(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x210(%rbp), %rdi
movl $0x10, %edx
callq 0x32f0
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x3160
movb %al, -0x229(%rbp)
jmp 0x5be3
movb -0x229(%rbp), %al
testb $0x1, %al
jne 0x5bef
jmp 0x5c66
movq 0x183fa(%rip), %rdi     # 0x1dff0
leaq 0xf95b(%rip), %rsi      # 0x15558
callq 0x3270
movq %rax, -0x240(%rbp)
jmp 0x5c0b
movq -0x240(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3270
movq %rax, -0x248(%rbp)
jmp 0x5c24
movq -0x248(%rbp), %rdi
movq 0x1836e(%rip), %rsi     # 0x1dfa0
callq 0x32c0
jmp 0x5c39
movl $0x1, %edi
callq 0x3320
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x33b0
jmp 0x5d21
leaq -0x210(%rbp), %rdi
callq 0x12af0
jmp 0x5c74
movq $0x0, -0x228(%rbp)
movq -0x238(%rbp), %rdi
movq -0x228(%rbp), %rax
movq %rax, -0x250(%rbp)
callq 0x6f70
movq %rax, %rcx
movq -0x250(%rbp), %rax
cmpq %rcx, %rax
jae 0x5cfe
movq -0x238(%rbp), %rdi
movq -0x228(%rbp), %rsi
callq 0x70a0
movq %rax, %rsi
leaq -0x210(%rbp), %rdi
callq 0x12d40
movq %rax, -0x258(%rbp)
jmp 0x5cd3
movq -0x258(%rbp), %rdi
movq 0x182bf(%rip), %rsi     # 0x1dfa0
callq 0x32c0
jmp 0x5ce8
jmp 0x5cea
movq -0x228(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x228(%rbp)
jmp 0x5c7f
leaq -0x210(%rbp), %rdi
callq 0x3390
jmp 0x5d0c
leaq -0x210(%rbp), %rdi
callq 0x33b0
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x3470
nopl (%rax)
// File: 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
subq $0x70, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, %rax
movq -0x68(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq 0xf692(%rip), %rsi      # 0x153f0
callq 0x56e0
testb $0x1, %al
jne 0x5d69
jmp 0x5d9c
movq -0x58(%rbp), %rdi
callq 0x7130
movq -0x58(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x7160
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0xd39e(%rip), %rdx      # 0x13130
callq 0x70e0
jmp 0x5eb7
movq -0x60(%rbp), %rdi
leaq 0xf26f(%rip), %rsi      # 0x15016
callq 0x56e0
testb $0x1, %al
jne 0x5db2
jmp 0x5de5
movq -0x58(%rbp), %rdi
callq 0x7130
movq -0x58(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x7160
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq 0xd375(%rip), %rdx      # 0x13150
callq 0x70e0
jmp 0x5eb5
movq -0x60(%rbp), %rdi
leaq 0xf607(%rip), %rsi      # 0x153f7
callq 0x56e0
testb $0x1, %al
jne 0x5dfb
jmp 0x5e2e
movq -0x58(%rbp), %rdi
callq 0x7130
movq -0x58(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x7160
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq 0xd46c(%rip), %rdx      # 0x13290
callq 0x70e0
jmp 0x5eb3
movq -0x60(%rbp), %rdi
leaq 0xf5c3(%rip), %rsi      # 0x153fc
callq 0x56e0
testb $0x1, %al
jne 0x5e44
jmp 0x5e74
movq -0x58(%rbp), %rdi
callq 0x7130
movq -0x58(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x7160
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq 0xd293(%rip), %rdx      # 0x13100
callq 0x70e0
jmp 0x5eb1
movq 0x18175(%rip), %rdi     # 0x1dff0
leaq 0xf6f8(%rip), %rsi      # 0x1557a
callq 0x3270
movq -0x60(%rbp), %rsi
movq %rax, %rdi
callq 0x3260
movq %rax, %rdi
leaq 0xf706(%rip), %rsi      # 0x155a3
callq 0x3270
movq %rax, %rdi
movq 0x180f4(%rip), %rsi     # 0x1dfa0
callq 0x32c0
jmp 0x5eb3
jmp 0x5eb5
jmp 0x5eb7
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x78c0
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x78e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x7480
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x7910
testb $0x1, %al
jne 0x6c6d
jmp 0x6d08
leaq -0x10(%rbp), %rdi
callq 0x7940
movq %rax, %rsi
movq 0x17340(%rip), %rdi     # 0x1dfc0
callq 0x3260
movq %rax, %rdi
leaq 0xe97d(%rip), %rsi      # 0x1560c
callq 0x3270
movq %rax, -0x40(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x7940
movq -0x40(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x3260
movq %rax, %rdi
leaq 0xe951(%rip), %rsi      # 0x1560c
callq 0x3270
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x7940
movq %rax, %rdi
addq $0x40, %rdi
callq 0x7960
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x30b0
movq %rax, %rdi
movq 0x172b1(%rip), %rsi     # 0x1dfa0
callq 0x32c0
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x7980
movq %rax, -0x28(%rbp)
jmp 0x6c46
addq $0x40, %rsp
popq %rbp
retq
nop
// File: soccin[P]BIC-RNAseq/tools/MergeFusion/StandardFusion.cpp
// Function: StandardFusion::init()
void StandardFusion::init()
{
    start1 = -1;
    start2 = -1;
    end1 = -1;
    end2 = -1;
    breakpoint1 = -1;
    breakpoint2 = -1;
    total_coverage = -1;
    spanning_coverage = -1;
    breakpoint_coverage = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x48(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x4c(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x50(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x54(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x58(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x5c(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0xa0(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0xa4(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0xa8(%rax) # imm = 0xFFFFFFFF
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0xb0, %rdi
leaq 0x33b3(%rip), %rsi      # 0x155c9
callq 0x4750
testb $0x1, %al
jne 0x12221
jmp 0x1223f
movq -0x18(%rbp), %rdi
movq %rdi, %rsi
addq $0x8, %rsi
movq %rdi, %rdx
addq $0xb0, %rdx
movq -0x10(%rbp), %rcx
callq 0x12430
movq -0x18(%rbp), %rdi
addq $0xd0, %rdi
leaq 0x3378(%rip), %rsi      # 0x155c9
callq 0x4750
testb $0x1, %al
jne 0x1225c
jmp 0x1227a
movq -0x18(%rbp), %rdi
movq %rdi, %rsi
addq $0x28, %rsi
movq %rdi, %rdx
addq $0xd0, %rdx
movq -0x10(%rbp), %rcx
callq 0x12430
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x3905(%rip), %rsi      # 0x15c40
callq 0x56e0
testb $0x1, %al
jne 0x12382
movq -0x10(%rbp), %rdi
leaq 0x38f6(%rip), %rsi      # 0x15c45
callq 0x56e0
testb $0x1, %al
jne 0x12382
movq -0x10(%rbp), %rdi
leaq 0x38da(%rip), %rsi      # 0x15c3d
callq 0x56e0
testb $0x1, %al
jne 0x12382
movq -0x10(%rbp), %rdi
leaq 0x38cb(%rip), %rsi      # 0x15c42
callq 0x56e0
testb $0x1, %al
jne 0x12382
jmp 0x12392
movq -0x10(%rbp), %rdi
leaq 0x324f(%rip), %rsi      # 0x155dc
callq 0x3370
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl $0x3, %ecx
callq 0x32a0
movq -0x70(%rbp), %rdi
leaq 0x3228(%rip), %rsi      # 0x155df
callq 0x4750
movb %al, -0x61(%rbp)
jmp 0x123c1
leaq -0x30(%rbp), %rdi
callq 0x3508
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x123d3
jmp 0x12416
movq -0x10(%rbp), %rdx
leaq -0x60(%rbp), %rdi
leaq 0x31fd(%rip), %rsi      # 0x155df
callq 0x71d0
movq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3330
leaq -0x60(%rbp), %rdi
callq 0x3508
jmp 0x12416
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3508
jmp 0x1241c
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3470
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x133d0
testb $0x1, %al
jne 0x1299f
jmp 0x129be
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0xd0e0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x12ad9
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movq -0x18(%rbp), %rsi
addq $0x60, %rsi
callq 0x133d0
testb $0x1, %al
jne 0x129d9
jmp 0x129f8
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movq -0x18(%rbp), %rsi
addq $0x60, %rsi
callq 0xd0e0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x12ad9
movq -0x20(%rbp), %rax
movl 0x58(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x58(%rcx), %eax
je 0x12a23
movq -0x20(%rbp), %rax
movl 0x58(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x58(%rcx), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x12ad9
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
callq 0x133d0
testb $0x1, %al
jne 0x12a3e
jmp 0x12a5a
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
callq 0xd0e0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x12ad9
movq -0x20(%rbp), %rdi
addq $0x80, %rdi
movq -0x18(%rbp), %rsi
addq $0x80, %rsi
callq 0x133d0
testb $0x1, %al
jne 0x12a7b
jmp 0x12a9d
movq -0x20(%rbp), %rdi
addq $0x80, %rdi
movq -0x18(%rbp), %rsi
addq $0x80, %rsi
callq 0xd0e0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x12ad9
movq -0x20(%rbp), %rax
movl 0x5c(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x5c(%rcx), %eax
je 0x12ac5
movq -0x20(%rbp), %rax
movl 0x5c(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x5c(%rcx), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x12ad9
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x133d0
testb $0x1, %al
jne 0x1317b
jmp 0x1319a
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0xd0e0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1327b
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
callq 0x133d0
testb $0x1, %al
jne 0x131b5
jmp 0x131d4
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
callq 0xd0e0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1327b
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x58(%rcx), %eax
je 0x131fc
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x58(%rcx), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1327b
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x5c(%rcx), %eax
je 0x13224
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x5c(%rcx), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1327b
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
movq -0x18(%rbp), %rsi
addq $0x60, %rsi
callq 0x133d0
testb $0x1, %al
jne 0x1323f
jmp 0x1325b
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
movq -0x18(%rbp), %rsi
addq $0x60, %rsi
callq 0xd0e0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1327b
movq -0x10(%rbp), %rdi
addq $0x80, %rdi
movq -0x18(%rbp), %rsi
addq $0x80, %rsi
callq 0xd0e0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x1f0, %rsp            # imm = 0x1F0
movb %cl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x13760
movq -0x1e0(%rbp), %rsi
movl %eax, %edx
leaq -0x1a8(%rbp), %rdi
callq 0x3400
leaq -0x1c8(%rbp), %rdi
callq 0x3380
movsbl -0x9(%rbp), %edx
leaq -0x1a8(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x34b0
movq %rax, -0x1e8(%rbp)
jmp 0x1361b
movq -0x1e8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3350
movb %al, -0x1e9(%rbp)
jmp 0x13639
movb -0x1e9(%rbp), %al
testb $0x1, %al
jne 0x13645
jmp 0x136a2
testb $0x1, -0x19(%rbp)
je 0x1368b
leaq -0x1c8(%rbp), %rdi
callq 0x3440
testb $0x1, %al
jne 0x1365d
jmp 0x1368b
jmp 0x135fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x3508
leaq -0x1a8(%rbp), %rdi
callq 0x3200
jmp 0x136c3
movq -0x18(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x13780
jmp 0x1369d
jmp 0x135fb
leaq -0x1c8(%rbp), %rdi
callq 0x3508
leaq -0x1a8(%rbp), %rdi
callq 0x3200
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1d0(%rbp), %rdi
callq 0x3470
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movw $0x0, 0x812(%rax)
movw $0x0, 0x1824(%rax)
movw $0x200, 0x1826(%rax)    # imm = 0x200
movw $0x0, 0x1848(%rax)
movb $0x0, 0x184a(%rax)
movb $0x0, 0x184b(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x800, -0xc(%rbp)      # imm = 0x800
jge 0x260a
movq -0x28(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, 0x1(%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x25e9
movl $0x0, -0x10(%rbp)
cmpl $0x10, -0x10(%rbp)
jge 0x2632
movq -0x28(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb $0x0, 0x801(%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2611
movl $0x0, -0x14(%rbp)
cmpl $0x1000, -0x14(%rbp)    # imm = 0x1000
jge 0x265d
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, 0x814(%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2639
movl $0x0, -0x18(%rbp)
cmpl $0x10, -0x18(%rbp)
jge 0x2693
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, 0x1814(%rax,%rcx)
movslq -0x18(%rbp), %rcx
movw $0x0, 0x1828(%rax,%rcx,2)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2664
movl $0x0, -0x1c(%rbp)
cmpl $0x50, -0x1c(%rbp)
jge 0x26c8
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rdx
leaq 0x7b51(%rip), %rcx      # 0xa200
movb (%rcx,%rdx), %dl
movslq -0x1c(%rbp), %rcx
movb %dl, 0x814(%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x269a
movq -0x28(%rbp), %rax
movb $0x1, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkeys-ecg-nmsu[P]graph-with-search-algorithms/main.cpp
// Function: main
int main() {
	if(testall()) 
		cout << "All tests PASSED!" << endl;
	else
		cout << "Some test FAILED!" << endl;
	
	// Graph g;
	
	// g.scan_tmg("tmg-master-simple.txt");
	
	// Node s = g.getNode(86257);
	// Node e = g.getNode(38953);
	
	// Dijkstra_tmg(g, s, e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x10bb0
testb $0x1, %al
jne 0x2afa
jmp 0x2b1e
movq 0x244cf(%rip), %rdi     # 0x26fd0
leaq 0x17511(%rip), %rsi     # 0x1a019
callq 0x2240
movq %rax, %rdi
movq 0x244a9(%rip), %rsi     # 0x26fc0
callq 0x2280
jmp 0x2b40
movq 0x244ab(%rip), %rdi     # 0x26fd0
leaq 0x174ff(%rip), %rsi     # 0x1a02b
callq 0x2240
movq %rax, %rdi
movq 0x24485(%rip), %rsi     # 0x26fc0
callq 0x2280
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movl $0x0, 0x60(%rdi)
movl $0x0, 0x64(%rdi)
movl $0x0, 0x68(%rdi)
callq 0x82d0
movq -0x78(%rbp), %rdi
addq $0x18, %rdi
callq 0x82f0
movq -0x78(%rbp), %rdi
addq $0x30, %rdi
callq 0x8310
movq -0x78(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x8330
movq -0x78(%rbp), %rdi
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x8430
movq -0x78(%rbp), %rdi
addq $0x30, %rdi
movslq -0xc(%rbp), %rsi
callq 0x8530
leaq -0x40(%rbp), %rdi
callq 0x8630
leaq -0x58(%rbp), %rdi
callq 0x8650
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
je 0x3d2a
movq -0x78(%rbp), %rdi
addq $0x18, %rdi
leaq -0x40(%rbp), %rsi
callq 0x8670
jmp 0x3ce7
movq -0x78(%rbp), %rdi
addq $0x30, %rdi
leaq -0x58(%rbp), %rsi
callq 0x86e0
jmp 0x3cfa
jmp 0x3cfc
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x3cc7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x30b0
leaq -0x40(%rbp), %rdi
callq 0x3530
jmp 0x3d45
leaq -0x58(%rbp), %rdi
callq 0x30b0
leaq -0x40(%rbp), %rdi
callq 0x3530
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x23e0
nop
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd 0x14795(%rip), %xmm0    # 0x1a040
movsd %xmm0, -0x18(%rbp)
movsd 0x147a8(%rip), %xmm0    # 0x1a060
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xee50
movsd %xmm0, -0x88(%rbp)
movq -0x8(%rbp), %rdi
callq 0xee50
movaps %xmm0, %xmm1
movsd -0x88(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd 0x14772(%rip), %xmm1    # 0x1a060
mulsd %xmm1, %xmm0
movsd 0x1475e(%rip), %xmm1    # 0x1a058
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xee70
movsd %xmm0, -0x80(%rbp)
movq -0x8(%rbp), %rdi
callq 0xee70
movaps %xmm0, %xmm1
movsd -0x80(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd 0x14732(%rip), %xmm1    # 0x1a060
mulsd %xmm1, %xmm0
movsd 0x1471e(%rip), %xmm1    # 0x1a058
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
movsd 0x146f8(%rip), %xmm1    # 0x1a048
divsd %xmm1, %xmm0
callq 0x2090
movsd %xmm0, -0x58(%rbp)
movsd -0x28(%rbp), %xmm0
movsd 0x146dd(%rip), %xmm1    # 0x1a048
divsd %xmm1, %xmm0
callq 0x2090
movsd %xmm0, -0x60(%rbp)
movq -0x8(%rbp), %rdi
callq 0xee50
movsd 0x146d6(%rip), %xmm1    # 0x1a060
mulsd %xmm1, %xmm0
movsd 0x146c2(%rip), %xmm1    # 0x1a058
divsd %xmm1, %xmm0
callq 0x2410
movsd %xmm0, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0xee50
movsd 0x146ab(%rip), %xmm1    # 0x1a060
mulsd %xmm1, %xmm0
movsd 0x14697(%rip), %xmm1    # 0x1a058
divsd %xmm1, %xmm0
callq 0x2410
movaps %xmm0, %xmm1
movsd -0x78(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x70(%rbp)
movsd -0x30(%rbp), %xmm0
movsd 0x14660(%rip), %xmm1    # 0x1a048
divsd %xmm1, %xmm0
callq 0x2090
movaps %xmm0, %xmm1
movsd -0x70(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x30(%rbp), %xmm0
movsd 0x14639(%rip), %xmm1    # 0x1a048
divsd %xmm1, %xmm0
callq 0x2090
movsd -0x68(%rbp), %xmm1
movsd -0x60(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x58(%rbp), %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x21d0
movsd %xmm0, -0x50(%rbp)
movsd 0x145fe(%rip), %xmm0    # 0x1a050
subsd -0x38(%rbp), %xmm0
callq 0x21d0
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
callq 0x2060
movaps %xmm0, %xmm1
movsd 0x145d4(%rip), %xmm0    # 0x1a048
mulsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0x145bb(%rip), %xmm0    # 0x1a040
mulsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x7ca0
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x7ea0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jne 0x646c
jmp 0x648b
leaq 0x13cd9(%rip), %rdi     # 0x1a14c
leaq 0x13c03(%rip), %rsi     # 0x1a07d
movl $0x128, %edx            # imm = 0x128
leaq 0x13ce1(%rip), %rcx     # 0x1a167
callq 0x2190
movq $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x7ea0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
je 0x6507
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7ec0
movq -0x38(%rbp), %rdi
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x20(%rbp), %rsi
callq 0x7f00
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x5fe0
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x64f1
jp 0x64f1
jmp 0x64f7
movb $0x0, -0x1(%rbp)
jmp 0x650b
jmp 0x64f9
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6493
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x48, %rdi
callq 0x7f40
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x7f40
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jne 0x6560
jmp 0x657f
leaq 0x13c27(%rip), %rdi     # 0x1a18e
leaq 0x13b0f(%rip), %rsi     # 0x1a07d
movl $0x133, %edx            # imm = 0x133
leaq 0x13c33(%rip), %rcx     # 0x1a1ad
callq 0x2190
movq $0x0, -0x20(%rbp)
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x7f40
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
je 0x6638
movq 0x20a41(%rip), %rdi     # 0x26ff0
leaq 0x13c1b(%rip), %rsi     # 0x1a1d1
callq 0x2240
movq -0x48(%rbp), %rdi
addq $0x48, %rdi
movq -0x20(%rbp), %rsi
callq 0x7f60
movq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0x7fa0
movq -0x48(%rbp), %rdi
addq $0x48, %rdi
movq -0x20(%rbp), %rsi
callq 0x7f60
movq -0x40(%rbp), %rdi
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rsi
callq 0x7f60
movq -0x58(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rsi
movsd -0x28(%rbp), %xmm0
callq 0x8150
testb $0x1, %al
jne 0x6625
movb $0x0, -0x1(%rbp)
jmp 0x663c
jmp 0x6627
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6587
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x208e9(%rip), %rdi     # 0x26ff0
leaq 0x13af4(%rip), %rsi     # 0x1a202
callq 0x2240
movq %rax, %rdi
movq 0x208a3(%rip), %rsi     # 0x26fc0
callq 0x2280
movq -0x28(%rbp), %rdi
callq 0x81f0
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
callq 0x77c0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x8220
testb $0x1, %al
jne 0x674f
jmp 0x67ba
leaq -0x10(%rbp), %rdi
callq 0x8250
movq %rax, %rsi
movq 0x2088e(%rip), %rdi     # 0x26ff0
callq 0x2220
movq %rax, %rdi
leaq 0x13ac7(%rip), %rsi     # 0x1a238
callq 0x2240
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x8270
movq %rax, %rdi
callq 0x21a0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x20a0
movq %rax, %rdi
movq 0x2081f(%rip), %rsi     # 0x26fc0
callq 0x2280
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x8290
movq %rax, -0x20(%rbp)
jmp 0x672f
movq 0x2082f(%rip), %rdi     # 0x26ff0
leaq 0x13a82(%rip), %rsi     # 0x1a24a
callq 0x2240
movq %rax, %rdi
movq 0x207e9(%rip), %rsi     # 0x26fc0
callq 0x2280
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x67f0
movq -0x18(%rbp), %rax
movl $0x0, 0x64(%rax)
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x7ca0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
je 0x6a00
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7b30
movq -0x18(%rbp), %rdi
movq %rax, %rsi
movsd 0x136cf(%rip), %xmm0    # 0x1a068
callq 0x5d50
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7b30
movq %rax, %rdi
callq 0xec00
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7b30
movq -0x18(%rbp), %rdi
movq %rax, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5cb0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7b30
movq -0x18(%rbp), %rdi
movq %rax, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5d00
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x695c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3b90
movq -0x78(%rbp), %rdi
movl $0x124f8, %esi          # imm = 0x124F8
callq 0x3c30
jmp 0x6b52
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x6a10
jmp 0x6b61
movl $0x0, -0x28(%rbp)
movq -0x80(%rbp), %rdi
movl -0x28(%rbp), %eax
movq %rax, -0x90(%rbp)
callq 0x7ca0
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
je 0x6c72
movq -0x80(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x7b30
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x62e0
movq %rax, -0x98(%rbp)
jmp 0x6bb1
movq -0x98(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x8750
jmp 0x6bc3
leaq -0x58(%rbp), %rdi
callq 0x8780
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x87e0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x87b0
testb $0x1, %al
jne 0x6bf0
jmp 0x6c5b
leaq -0x60(%rbp), %rdi
callq 0x8810
movq -0x80(%rbp), %rdi
movq %rax, -0xa0(%rbp)
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x7b30
movq -0x78(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq %rax, %rdx
callq 0x5aa0
jmp 0x6c23
jmp 0x6c25
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
callq 0x8830
movq %rax, -0x70(%rbp)
jmp 0x6bd0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x6c95
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3530
jmp 0x6c95
leaq -0x58(%rbp), %rdi
callq 0x3530
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x6b68
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x6c85
movq -0x78(%rbp), %rdi
callq 0x2c00
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x2c00
movq -0x20(%rbp), %rdi
callq 0x23e0
nopw (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xf2c0
movq -0x58(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0xf2c0
movq %rax, -0x28(%rbp)
movq -0x58(%rbp), %rdi
callq 0xf320
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xf2f0
testb $0x1, %al
jne 0xf020
jmp 0xf088
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xf350
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x5fe0
movsd %xmm0, -0x70(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xf350
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x5fe0
movsd -0x70(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0xf072
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xf074
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0xf370
movq %rax, -0x38(%rbp)
jmp 0xf000
movb $0x0, -0x39(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xf3a0
movq %rax, %rdi
callq 0xed80
movq -0x88(%rbp), %rdi
movslq %eax, %rsi
callq 0x5040
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x2b50
leaq -0x48(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xf410
movq -0x58(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xf3c0
movq %rax, -0x50(%rbp)
movb $0x1, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
jne 0xf0f4
movq -0x68(%rbp), %rdi
callq 0x2bd0
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2200
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq $-0x1, %rax
jne 0x10b62
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x23f0
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x988e(%rip), %rsi      # 0x1a3c7
callq 0x2310
jmp 0x10b40
leaq -0x1d(%rbp), %rdi
callq 0x2290
jmp 0x10b9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x2290
jmp 0x10ba4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq $-0x1, %rdx
callq 0x2420
movq -0x48(%rbp), %rdi
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
subl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
movslq -0x34(%rbp), %rcx
callq 0x2260
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x23e0
nopl (%rax)