LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Crawler995[P]Cpp-Ray-Tracing/libs/phong_material.cpp
// Function: PhongMaterial::sample(Ray3, Vector3, Vector3)
Color PhongMaterial::sample(Ray3 ray, Vector3 position, Vector3 normal) {
    Vector3 light(1, 1, 1);
    double ed = normal.dot(light.normalize());
    Vector3 h = light.normalize().subtract(ray.get_dir()).normalize();
    double es = normal.dot(h);

    ed = (ed >= 0.0) ? ed : 0;
    es = (es >= 0.0) ? es : 0;
    
    Color diffuse = diffuse_color.multiply(diffuse_factor * ed);
    Color specular = specular_color.multiply(specular_factor * pow(es, highlight_factor));
    Color envir = envir_color.multiply(envir_factor);

    Color res = envir.add(specular.add(diffuse));

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq -0xd8(%rbp), %r15
movsd 0x26ba(%rip), %xmm0     # 0x6098
movq %r15, %rdi
movapd %xmm0, %xmm1
movapd %xmm0, %xmm2
callq 0x2838
leaq -0xc0(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x28de
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
leaq 0x58(%rbp), %r12
movq %r12, %rdi
callq 0x2a66
movaps %xmm0, -0x40(%rbp)
leaq -0x60(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x28de
leaq -0x90(%rbp), %r15
leaq 0x10(%rbp), %rsi
movq %r15, %rdi
callq 0x2bb8
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
leaq -0x78(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x29d2
leaq -0xa8(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x28de
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movupd (%r13), %xmm0
movupd %xmm0, (%rsp)
movq %r12, %rdi
callq 0x2a66
movapd %xmm0, %xmm3
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
movapd -0x40(%rbp), %xmm2
cmplesd %xmm2, %xmm0
andpd %xmm2, %xmm0
cmplesd %xmm3, %xmm1
andpd %xmm1, %xmm3
movapd %xmm3, -0x40(%rbp)
leaq 0x2c(%rbx), %rdi
mulsd 0x10(%rbx), %xmm0
callq 0x363e
movq %rax, %r12
movl %edx, %r13d
leaq 0x38(%rbx), %r14
movsd 0x18(%rbx), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd 0x48(%rbx), %xmm1
movapd -0x40(%rbp), %xmm0
callq 0x2180
mulsd -0x48(%rbp), %xmm0
movq %r14, %rdi
callq 0x363e
movq %rax, (%r15)
movl %edx, 0x8(%r15)
movsd 0x8(%rbx), %xmm0
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x363e
leaq -0x60(%rbp), %rcx
movq %rax, (%rcx)
movl %edx, 0x8(%rcx)
leaq -0x78(%rbp), %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x3622
leaq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x3622
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Crawler995[P]Cpp-Ray-Tracing/libs/cook_torrance_material.cpp
// Function: CookTorranceMaterial::CookTorranceMaterial(double, double, double, double, double, Color, Color, Color)
CookTorranceMaterial::CookTorranceMaterial(
    double envir_factor,
    double diffuse_factor,
    double specular_factor,
    double fresnel_factor,
    double roughness,
    Color envir_color,
    Color diffuse_color,
    Color specular_color
) {
    this -> envir_factor = envir_factor;
    this -> diffuse_factor = diffuse_factor;
    this -> specular_factor = specular_factor;
    this -> fresnel_factor = fresnel_factor;
    this -> roughness = roughness;
    this -> envir_color = envir_color;
    this -> diffuse_color = diffuse_color;
    this -> specular_color = specular_color;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movl %edx, %r15d
movq %rsi, %r13
movsd %xmm4, -0x50(%rbp)
movsd %xmm3, -0x48(%rbp)
movsd %xmm2, -0x40(%rbp)
movsd %xmm1, -0x38(%rbp)
movsd %xmm0, -0x30(%rbp)
movq %rdi, %r12
leaq 0x5130(%rip), %rax      # 0x8cd0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x20, %rdi
callq 0x3602
leaq 0x2c(%r12), %rdi
callq 0x3602
leaq 0x38(%r12), %rdi
callq 0x3602
leaq 0x516d(%rip), %rax      # 0x8d38
movq %rax, (%r12)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x8(%r12)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x10(%r12)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, 0x18(%r12)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, 0x48(%r12)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, 0x50(%r12)
movq %r13, 0x20(%r12)
movl %r15d, 0x28(%r12)
movq %r14, 0x2c(%r12)
movl %ebx, 0x34(%r12)
movq 0x10(%rbp), %rax
movq %rax, 0x38(%r12)
movl 0x18(%rbp), %eax
movl %eax, 0x40(%r12)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Crawler995[P]Cpp-Ray-Tracing/libs/cook_torrance_material.cpp
// Function: CookTorranceMaterial::sample(Ray3, Vector3, Vector3)
Color CookTorranceMaterial::sample(Ray3 ray, Vector3 position, Vector3 normal) {
    Vector3 light(1, 1, 1);
    double ed = normal.dot(light.normalize());
    Vector3 h = light.normalize().subtract(ray.get_dir()).normalize();

    ed = (ed >= 0.0) ? ed : 0;
    
    Color diffuse = diffuse_color.multiply(diffuse_factor * ed);
    Color specular = specular_color.multiply(specular_factor * BRDF(ray, normal));
    Color envir = envir_color.multiply(envir_factor);

    Color res = envir.add(specular.add(diffuse));

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
leaq -0xd8(%rbp), %r14
movsd 0x2432(%rip), %xmm0     # 0x6098
movq %r14, %rdi
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
callq 0x2838
leaq -0xc0(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x28de
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
leaq 0x58(%rbp), %rdi
callq 0x2a66
movaps %xmm0, -0x40(%rbp)
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x28de
leaq -0x90(%rbp), %r14
leaq 0x10(%rbp), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x2bb8
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movupd (%r14), %xmm0
movupd %xmm0, (%rsp)
leaq -0x78(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x29d2
leaq -0xa8(%rbp), %rdi
movq %r12, %rsi
callq 0x28de
xorpd %xmm0, %xmm0
movapd -0x40(%rbp), %xmm1
cmplesd %xmm1, %xmm0
andpd %xmm1, %xmm0
leaq 0x2c(%rbx), %rdi
mulsd 0x10(%rbx), %xmm0
callq 0x363e
movq %rax, -0x40(%rbp)
movl %edx, %r15d
leaq 0x38(%rbx), %r14
movsd 0x18(%rbx), %xmm0
movsd %xmm0, -0x48(%rbp)
leaq 0x58(%rbp), %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x40(%rsp)
movups (%rcx), %xmm0
movups %xmm0, 0x30(%rsp)
movapd (%r13), %xmm0
movaps 0x10(%r13), %xmm1
movaps 0x20(%r13), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x3dca
mulsd -0x48(%rbp), %xmm0
movq %r14, %rdi
callq 0x363e
movq %rax, (%r12)
movl %edx, 0x8(%r12)
movsd 0x8(%rbx), %xmm0
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x363e
leaq -0x60(%rbp), %rcx
movq %rax, (%rcx)
movl %edx, 0x8(%rcx)
leaq -0x78(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl %r15d, %edx
callq 0x3622
leaq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x3622
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Crawler995[P]Cpp-Ray-Tracing/libs/cook_torrance_material.cpp
// Function: CookTorranceMaterial::BRDF(Ray3, Vector3)
double CookTorranceMaterial::BRDF(Ray3 ray, Vector3 normal) {
    Vector3 light(1, 1, 1);
    double F = fresnel_reflect(ray);
    double D = shadow_mask(ray, normal);
    double G = normal_distribution(ray, normal);

    double n_dot_v = normal.dot(ray.get_dir().negate());
    double n_dot_l = normal.dot(light.normalize());

    return (F * D * G) / (n_dot_v * n_dot_l * 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r12
leaq -0xa0(%rbp), %rbx
movsd 0x22aa(%rip), %xmm0     # 0x6098
movq %rbx, %rdi
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
callq 0x2838
leaq 0x10(%rbp), %r15
movaps (%r15), %xmm0
movaps 0x10(%r15), %xmm1
movaps 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r12, %rdi
callq 0x3f3e
movsd %xmm0, -0x40(%rbp)
leaq 0x40(%rbp), %r14
movq 0x10(%r14), %rax
movq %rax, 0x40(%rsp)
movaps (%r14), %xmm0
movups %xmm0, 0x30(%rsp)
movaps (%r15), %xmm0
movaps 0x10(%r15), %xmm1
movaps 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r12, %rdi
callq 0x4052
movsd %xmm0, -0x38(%rbp)
movq 0x10(%r14), %rax
movq %rax, 0x40(%rsp)
movaps (%r14), %xmm0
movups %xmm0, 0x30(%rsp)
movaps (%r15), %xmm0
movaps 0x10(%r15), %xmm1
movaps 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x4172
movsd %xmm0, -0x30(%rbp)
leaq -0x70(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2bb8
leaq -0x88(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x2956
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x2a66
movsd %xmm0, -0x28(%rbp)
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x28de
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movupd (%r15), %xmm0
movupd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x2a66
movsd -0x38(%rbp), %xmm1
mulsd -0x40(%rbp), %xmm1
mulsd -0x30(%rbp), %xmm1
mulsd -0x28(%rbp), %xmm0
mulsd 0x223b(%rip), %xmm0     # 0x6160
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq -0xa8(%rbp), %r14
movsd 0x2024(%rip), %xmm0     # 0x6098
movsd %xmm0, -0x20(%rbp)
movq %r14, %rdi
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
callq 0x2838
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x28de
leaq -0x48(%rbp), %r14
leaq 0x10(%rbp), %rsi
movq %r14, %rdi
callq 0x2bb8
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
leaq -0x78(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x29d2
leaq -0x90(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x28de
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movupd (%r15), %xmm0
movupd %xmm0, (%rsp)
leaq 0x40(%rbp), %rdi
callq 0x2a66
movsd %xmm0, -0x30(%rbp)
movsd 0x50(%rbx), %xmm1
mulsd %xmm1, %xmm1
movsd %xmm1, -0x28(%rbp)
movsd 0x2051(%rip), %xmm1     # 0x6160
callq 0x2180
mulsd -0x28(%rbp), %xmm0
mulsd 0x203f(%rip), %xmm0     # 0x6160
movsd -0x20(%rbp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, -0x20(%rbp)
movsd -0x30(%rbp), %xmm2
movapd %xmm2, %xmm0
mulsd %xmm2, %xmm0
addsd 0x202c(%rip), %xmm0     # 0x6170
movsd 0x50(%rbx), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm2, %xmm1
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x21a0
mulsd -0x20(%rbp), %xmm0
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Crawler995[P]Cpp-Ray-Tracing/libs/cook_torrance_material.cpp
// Function: CookTorranceMaterial::normal_distribution(Ray3, Vector3)
double CookTorranceMaterial::normal_distribution(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 v_dot_h = ray.get_dir().negate().dot(h);

    double g1 = 2 * n_dot_h * normal.dot(light.normalize()) / v_dot_h;
    double g2 = 2 * n_dot_h * normal.dot(ray.get_dir().negate()) / v_dot_h;

    return std::min(std::min(1.0, g1), g2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
leaq -0xe8(%rbp), %r14
movsd 0x1f03(%rip), %xmm0     # 0x6098
movq %r14, %rdi
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
callq 0x2838
leaq -0x70(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x28de
leaq -0xb8(%rbp), %r12
leaq 0x10(%rbp), %rbx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2bb8
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
leaq -0x58(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x29d2
leaq -0xd0(%rbp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x28de
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
leaq 0x40(%rbp), %r15
movq %r15, %rdi
callq 0x2a66
movsd %xmm0, -0x30(%rbp)
leaq -0x70(%rbp), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2bb8
leaq -0x58(%rbp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2956
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x2a66
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
addsd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
leaq -0xa0(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28de
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movupd (%rbx), %xmm0
movupd %xmm0, (%rsp)
movq %r15, %rdi
callq 0x2a66
mulsd -0x30(%rbp), %xmm0
divsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
leaq -0x58(%rbp), %rbx
movq %rbx, %rdi
leaq 0x10(%rbp), %rsi
callq 0x2bb8
leaq -0x88(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2956
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movupd (%r14), %xmm0
movupd %xmm0, (%rsp)
movq %r15, %rdi
callq 0x2a66
mulsd -0x30(%rbp), %xmm0
divsd -0x38(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
minsd 0x1d9d(%rip), %xmm1     # 0x6098
minsd %xmm1, %xmm0
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movl %edx, %r15d
movq %rsi, %r12
movsd %xmm4, -0x50(%rbp)
movsd %xmm3, -0x48(%rbp)
movsd %xmm2, -0x40(%rbp)
movsd %xmm1, -0x38(%rbp)
movsd %xmm0, -0x30(%rbp)
movq %rdi, %r13
leaq 0x497c(%rip), %rax      # 0x8cd0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x20, %rdi
callq 0x3602
leaq 0x2c(%r13), %rdi
callq 0x3602
leaq 0x38(%r13), %rdi
callq 0x3602
leaq 0x49eb(%rip), %rax      # 0x8d68
movq %rax, (%r13)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x48(%r13)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x8(%r13)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, 0x10(%r13)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, 0x18(%r13)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, 0x50(%r13)
movq %r12, 0x20(%r13)
movl %r15d, 0x28(%r13)
movq %r14, 0x38(%r13)
movl %ebx, 0x40(%r13)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Crawler995[P]Cpp-Ray-Tracing/libs/plane.cpp
// Function: Plane::intersect(Ray3)
IntersectResult Plane::intersect(Ray3 ray) {
    IntersectResult res(0, 0, Vector3(0, 0, 0), Vector3(0, 0, 0));
    double a = ray.get_dir().dot(normal);

    if(a >= 0) {
        return res;
    }

    double b = normal.dot(ray.get_origin().add(normal.scale(distance)));
    double dis = -b / a;

    res.geometry = this;
    res.distance = dis;
    res.position = ray.get_point(res.distance);
    res.normal = normal;

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq -0xd0(%rbp), %r12
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r12, %rdi
callq 0x2838
leaq -0xb8(%rbp), %r13
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r13, %rdi
callq 0x2838
movq 0x10(%r13), %rax
leaq -0x70(%rbp), %r14
movq %rax, 0x10(%r14)
movups (%r13), %xmm0
movaps %xmm0, (%r14)
movups (%r12), %xmm0
movaps %xmm0, -0x50(%rbp)
movq 0x10(%r12), %rax
movq %rax, -0x40(%rbp)
leaq 0x10(%rbx), %rdi
movq %rdi, -0x38(%rbp)
callq 0x284c
leaq 0x28(%rbx), %r13
movq %r13, %rdi
callq 0x284c
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movaps -0x50(%rbp), %xmm0
movups %xmm0, 0x10(%rbx)
movq -0x40(%rbp), %rax
movq %rax, 0x20(%rbx)
movaps (%r14), %xmm0
movups %xmm0, 0x28(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x38(%rbx)
movq %r14, %rdi
leaq 0x10(%rbp), %rsi
movq %rsi, %r12
callq 0x2bb8
movq 0x20(%r15), %rax
movq %rax, 0x10(%rsp)
movupd 0x10(%r15), %xmm0
movupd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x2a66
ucomisd 0x19e9(%rip), %xmm0     # 0x61a0
jae 0x4878
leaq 0x10(%r15), %r14
leaq -0x70(%rbp), %rdi
movq %r12, %rsi
movsd %xmm0, -0x30(%rbp)
callq 0x2ba0
movsd 0x28(%r15), %xmm0
leaq -0x88(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x2a06
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
leaq -0xa0(%rbp), %r12
movq %r12, %rdi
leaq -0x70(%rbp), %rsi
callq 0x297c
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movupd (%r12), %xmm0
movupd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x2a66
xorpd 0x18ab(%rip), %xmm0     # 0x60e0
divsd -0x30(%rbp), %xmm0
movq %r15, (%rbx)
movsd %xmm0, 0x8(%rbx)
leaq -0x70(%rbp), %r15
movq %r15, %rdi
leaq 0x10(%rbp), %rsi
callq 0x2b52
movq 0x10(%r15), %rax
movq -0x38(%rbp), %rcx
movq %rax, 0x10(%rcx)
movups (%r15), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%r13)
movupd (%r14), %xmm0
movupd %xmm0, (%r13)
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
movl %r8d, 0xc(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zeeev[P]DASVC/fastahack/Fasta.cpp
// Function: FastaReference::getSequence(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string FastaReference::getSequence(string seqname) {
    FastaIndexEntry entry = index->entry(seqname);
    int newlines_in_sequence = entry.length / entry.line_blen;
    int seqlen = newlines_in_sequence  + entry.length;
    char* seq = (char*) calloc (seqlen + 1, sizeof(char));
    fseek64(file, entry.offset, SEEK_SET);
    string s;
    if (fread(seq, sizeof(char), seqlen, file)) {
        seq[seqlen] = '\0';
        char* pbegin = seq;
        char* pend = seq + (seqlen/sizeof(char));
        pend = remove(pbegin, pend, '\n');
        pend = remove(pbegin, pend, '\0');
        s = seq;
        free(seq);
        s.resize((pend - pbegin)/sizeof(char));
    }
    return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x40(%rsi), %r14
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x551c
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x477c
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x4c11
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x32b0
movl 0x50(%rsp), %ecx
movl %ecx, %eax
cltd
idivl 0x60(%rsp)
leal (%rax,%rcx), %ebp
addl %ecx, %eax
incl %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x31c0
movq %rax, %r14
movq 0x28(%r15), %rdi
movq 0x58(%rsp), %rsi
xorl %edx, %edx
callq 0x31a0
leaq 0x10(%rbx), %r13
movq %r13, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movslq %ebp, %r12
movq 0x28(%r15), %rcx
movl $0x1, %esi
movq %r14, %rdi
movq %r12, %rdx
callq 0x3390
testq %rax, %rax
je 0x4cd8
leaq (%r14,%r12), %rsi
movb $0x0, (%r14,%r12)
leaq 0xf(%rsp), %rdx
movb $0xa, (%rdx)
movq %r14, %rdi
callq 0x716c
leaq 0xf(%rsp), %rdx
movb $0x0, (%rdx)
movq %r14, %rdi
movq %rax, %rsi
callq 0x716c
movq %rax, %r15
movq 0x8(%rbx), %r12
movq %r14, %rdi
callq 0x3140
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x33c0
movq %r14, %rdi
callq 0x3320
subq %r14, %r15
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x30e0
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4cf3
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4d13
jmp 0x4d13
movq %rax, %r14
movq 0x10(%rsp), %rdi
jmp 0x4d33
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x4d2a
movq (%r13), %rsi
incq %rsi
callq 0x32b0
leaq 0x40(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x4d44
movq (%r13), %rsi
incq %rsi
callq 0x32b0
movq %r14, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
callq 0x3a7f
leaq -0x88(%rbp), %rdi
callq 0x4600
cmpb $0x1, 0xd3ea(%rip)      # 0x11408
jne 0x4033
movq 0xd3e9(%rip), %rsi      # 0x11410
leaq -0x88(%rbp), %rdi
callq 0x51a6
movq 0xd376(%rip), %rax      # 0x113b0
cmpq %rax, 0xd377(%rip)      # 0x113b8
je 0x40a2
movl $0x20, %r14d
xorl %r15d, %r15d
leaq -0x88(%rbp), %rbx
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
movq -0x20(%rax,%r14), %rsi
movl (%rax,%r14), %edx
movzbl 0xd183(%rip), %ecx      # 0x111f0
movzbl 0xd393(%rip), %r8d      # 0x11408
movq %rbx, %rdi
callq 0x464e
incq %r15
movq 0xd331(%rip), %rcx      # 0x113b8
movq 0xd322(%rip), %rax      # 0x113b0
subq %rax, %rcx
sarq $0x3, %rcx
imulq %r12, %rcx
addq $0x28, %r14
cmpq %rcx, %r15
jb 0x405d
movq 0xd347(%rip), %rdx      # 0x113f0
testq %rdx, %rdx
je 0x40ee
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
movq 0xd32b(%rip), %rsi      # 0x113e8
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x41f8
leaq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4aee
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x40ee
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3200
movq 0xd2d3(%rip), %rsi      # 0x113c8
leaq -0x88(%rbp), %rdi
callq 0x4986
leaq -0x88(%rbp), %rdi
callq 0x462e
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x413b
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3200
jmp 0x413b
jmp 0x4138
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x462e
movq %rbx, %rdi
callq 0x3340
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x228(%rbp), %r15
movq %r15, %rdi
movl $0x10, %edx
callq 0x3240
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x208(%rbp,%rax)
jne 0x4a9c
leaq -0x228(%rbp), %rdi
callq 0xab08
movq (%rbx), %rsi
cmpq %rsi, 0x8(%rbx)
je 0x4a48
xorl %r12d, %r12d
movabsq $-0x30c30c30c30c30c3, %r13 # imm = 0xCF3CF3CF3CF3CF3D
xorl %r14d, %r14d
addq %r12, %rsi
leaq -0x228(%rbp), %rdi
callq 0xaddd
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3150
incq %r14
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
sarq $0x4, %rax
imulq %r13, %rax
addq $0x150, %r12            # imm = 0x150
cmpq %rax, %r14
jb 0x49ee
leaq -0x228(%rbp), %rdi
callq 0x3280
movq 0xc565(%rip), %rax      # 0x10fc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x220(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x228(%rbp,%rcx)
callq 0x31b0
leaq -0x130(%rbp), %rdi
callq 0x30d0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xc54d(%rip), %rdi      # 0x10ff0
leaq 0x7af7(%rip), %rsi      # 0xc5a1
movl $0x21, %edx
callq 0x3250
movq 0xc535(%rip), %rdi      # 0x10ff0
movq %r14, %rsi
callq 0x31e0
movq %rax, %rdi
callq 0x3110
movl $0x1, %edi
callq 0x3260
jmp 0x4ad7
movq %rax, %rbx
leaq -0x228(%rbp), %rdi
callq 0x32a0
movq %rbx, %rdi
callq 0x3340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4dd1
movq %rdx, %r14
leaq 0x78f1(%rip), %rsi      # 0xc606
movq %rdx, %rdi
callq 0x30b0
testl %eax, %eax
je 0x4dd1
leaq 0x78e9(%rip), %rsi      # 0xc615
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x4dfa
xorps %xmm0, %xmm0
leaq -0x70(%rbp), %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
movq %r14, %rdi
movl $0x70, %esi
xorl %ecx, %ecx
callq 0xb466
leaq -0x50(%rbp), %rdx
xorps %xmm0, %xmm0
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
movq -0x70(%rbp), %rdi
movl $0x71, %esi
xorl %ecx, %ecx
callq 0xb466
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
movq -0x50(%rbp), %rdi
movl $0x63, %esi
xorl %ecx, %ecx
callq 0xb466
movq -0x30(%rbp), %rdx
leaq 0x787c(%rip), %rsi      # 0xc628
movq %rbx, %rdi
callq 0x5787
leaq -0x30(%rbp), %rdi
callq 0x581a
leaq -0x50(%rbp), %rdi
callq 0x581a
leaq -0x70(%rbp), %rdi
callq 0x581a
jmp 0x4dee
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x7830(%rip), %rsi      # 0xc60f
leaq 0x782e(%rip), %rdx      # 0xc614
movq %rbx, %rdi
callq 0x4292
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x781a(%rip), %rsi      # 0xc622
leaq 0x7818(%rip), %rdx      # 0xc627
jmp 0x4de6
movq %rax, %rbx
jmp 0x4e27
movq %rax, %rbx
jmp 0x4e30
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x581a
leaq -0x50(%rbp), %rdi
callq 0x581a
leaq -0x70(%rbp), %rdi
callq 0x581a
movq %rbx, %rdi
callq 0x3340
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %r14
addq $0x20, %rbx
cmpq %rbx, %r14
je 0x564f
movq 0xba13(%rip), %r15      # 0x10fc8
leaq 0x7099(%rip), %r12      # 0xc655
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %r15, %rdi
callq 0x3250
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x3250
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
movq %r13, %rdi
callq 0x3250
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x3250
movq 0x88(%r14), %rsi
movq %r13, %rdi
callq 0x3140
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r13, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3150
movq %r14, %rdi
callq 0x3160
movq %rax, %r14
cmpq %rbx, %rax
jne 0x55bc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
pxor %xmm0, %xmm0
leaq -0x30(%rbp), %rdx
movdqa %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
movq %rsi, %rdi
movl $0x9, %esi
xorl %ecx, %ecx
callq 0xb466
movq -0x30(%rbp), %rsi
leaq 0x8(%rbx), %rdi
callq 0x3130
movq -0x30(%rbp), %rsi
addq $0x60, %rsi
leaq 0x28(%rbx), %rdi
callq 0x3130
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x48(%rbx)
movq -0x30(%rbp), %r14
movq 0x20(%r14), %rdi
callq 0x32d0
movl %eax, 0x58(%rbx)
movq 0x80(%r14), %rdi
callq 0x32d0
movl %eax, 0x5c(%rbx)
addq $0x40, %r14
leaq 0x60(%rbx), %rdi
movq %r14, %rsi
callq 0x3130
movl $0xa0, %esi
addq -0x30(%rbp), %rsi
leaq 0x80(%rbx), %rdi
callq 0x3130
movl $0x1, 0xa8(%rbx)
movq $-0x1, 0xa0(%rbx)
leaq 0xb0(%rbx), %rdi
movq 0xb8(%rbx), %rdx
leaq 0x24a0(%rip), %rcx      # 0xc612
movl $0x2, %r8d
xorl %esi, %esi
callq 0x32c0
leaq 0xd0(%rbx), %rdi
movq 0xd8(%rbx), %rdx
leaq 0x247e(%rip), %rcx      # 0xc612
movl $0x2, %r8d
xorl %esi, %esi
callq 0x32c0
leaq 0xf0(%rbx), %rdi
movq 0xf8(%rbx), %rdx
leaq 0x245c(%rip), %rcx      # 0xc612
movl $0x2, %r8d
xorl %esi, %esi
callq 0x32c0
leaq 0x110(%rbx), %rdi
movq 0x118(%rbx), %rdx
leaq 0x243a(%rip), %rcx      # 0xc612
movl $0x2, %r8d
xorl %esi, %esi
callq 0x32c0
movl $0x5, (%rbx)
addq $0x130, %rbx            # imm = 0x130
leaq 0x2a60(%rip), %rsi      # 0xcc59
movq %rbx, %rdi
callq 0x33a0
movq -0x30(%rbp), %rax
movq 0xc0(%rax), %rsi
movq 0xc8(%rax), %rdx
movq %rbx, %rdi
callq 0x30c0
leaq 0x2a46(%rip), %rsi      # 0xcc68
movq %rbx, %rdi
callq 0x33a0
movq -0x30(%rbp), %rax
movq 0xe0(%rax), %rsi
movq 0xe8(%rax), %rdx
movq %rbx, %rdi
callq 0x30c0
leaq 0x2a2b(%rip), %rsi      # 0xcc76
movq %rbx, %rdi
callq 0x33a0
movq -0x30(%rbp), %rax
movq 0x100(%rax), %rsi
movq 0x108(%rax), %rdx
movq %rbx, %rdi
callq 0x30c0
leaq -0x30(%rbp), %rdi
callq 0x581a
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x581a
movq %rbx, %rdi
callq 0x3340
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x233c(%rip), %rsi      # 0xc612
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
je 0xa2f1
leaq 0x8(%r14), %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0xa540
leaq 0xd0(%r14), %r15
leaq 0x2313(%rip), %rsi      # 0xc612
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
je 0xa327
addq $0x28, %r14
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa540
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x282d(%rip), %rsi      # 0xcc88
movq %rbx, %rdi
callq 0x30b0
testl %eax, %eax
je 0xa4a0
leaq 0x281f(%rip), %rsi      # 0xcc8d
movq %rbx, %rdi
callq 0x30b0
testl %eax, %eax
je 0xa4a0
leaq 0x2804(%rip), %rsi      # 0xcc85
movq %rbx, %rdi
callq 0x30b0
testl %eax, %eax
je 0xa4a0
leaq 0x27f6(%rip), %rsi      # 0xcc8a
movq %rbx, %rdi
callq 0x30b0
testl %eax, %eax
jne 0xa4bb
movq 0x8(%rbx), %rdx
leaq 0x217a(%rip), %rcx      # 0xc625
movl $0x2, %r8d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x32c0
leaq -0x38(%rbp), %r15
movl $0x3, %ecx
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3220
leaq 0x2150(%rip), %rsi      # 0xc628
movq %r15, %rdi
callq 0x30b0
movl %eax, %r14d
movq (%r15), %rdi
leaq -0x28(%rbp), %r15
cmpq %r15, %rdi
je 0xa4fb
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3200
testl %r14d, %r14d
je 0xa535
leaq 0x2121(%rip), %rsi      # 0xc628
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x5787
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3270
movq (%r14), %rdi
cmpq %r15, %rdi
je 0xa535
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3200
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0x8(%rdi), %r15
leaq 0x8(%rsi), %r12
movq 0x10(%rdi), %rdx
cmpq 0x10(%rsi), %rdx
jne 0xaa16
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0xaa23
movq (%r12), %rsi
movq (%r15), %rdi
callq 0x3210
testl %eax, %eax
je 0xaa23
movq %r15, %rdi
movq %r12, %rsi
callq 0x3040
jmp 0xaa55
leaq 0x60(%r14), %r15
leaq 0x60(%rbx), %r12
movq 0x68(%r14), %rdx
cmpq 0x68(%rbx), %rdx
jne 0xaa4a
testq %rdx, %rdx
je 0xaa61
movq (%r12), %rsi
movq (%r15), %rdi
callq 0x3210
testl %eax, %eax
je 0xaa61
movq %r15, %rdi
movq %r12, %rsi
callq 0x3040
shrl $0x1f, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x58(%rbx), %eax
cmpl %eax, 0x58(%r14)
jne 0xaaf2
leaq 0x28(%r14), %r15
leaq 0x28(%rbx), %r12
movq 0x30(%r14), %rdx
cmpq 0x30(%rbx), %rdx
jne 0xaa95
testq %rdx, %rdx
je 0xaaa2
movq (%r12), %rsi
movq (%r15), %rdi
callq 0x3210
testl %eax, %eax
je 0xaaa2
movq %r15, %rdi
movq %r12, %rsi
callq 0x3040
jmp 0xaa55
movl $0x80, %r15d
leaq (%r14,%r15), %r12
addq %rbx, %r15
movq 0x88(%r14), %rdx
cmpq 0x88(%rbx), %rdx
jne 0xaad4
testq %rdx, %rdx
je 0xaae4
movq (%r15), %rsi
movq (%r12), %rdi
callq 0x3210
testl %eax, %eax
je 0xaae4
movq %r12, %rdi
movq %r15, %rsi
callq 0x3040
jmp 0xaa55
movl 0x5c(%rbx), %eax
cmpl %eax, 0x5c(%r14)
jne 0xaaf2
movl (%r14), %eax
cmpl (%rbx), %eax
setl %al
jmp 0xaa58
jmp 0xab00
jmp 0xab00
jmp 0xab00
movq %rax, %rdi
callq 0x5a33
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0x8(%rdi), %r15
leaq 0x8(%rsi), %r12
movq 0x10(%rdi), %rdx
cmpq 0x10(%rsi), %rdx
jne 0xb1ea
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0xb1f7
movq (%r12), %rsi
movq (%r15), %rdi
callq 0x3210
testl %eax, %eax
je 0xb1f7
movq %r15, %rdi
movq %r12, %rsi
callq 0x3040
jmp 0xb229
leaq 0x28(%r14), %r15
leaq 0x28(%rbx), %r12
movq 0x30(%r14), %rdx
cmpq 0x30(%rbx), %rdx
jne 0xb21e
testq %rdx, %rdx
je 0xb235
movq (%r12), %rsi
movq (%r15), %rdi
callq 0x3210
testl %eax, %eax
je 0xb235
movq %r15, %rdi
movq %r12, %rsi
callq 0x3040
shrl $0x1f, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x58(%rbx), %eax
cmpl %eax, 0x58(%r14)
jne 0xb27b
movl 0x5c(%rbx), %eax
cmpl %eax, 0x5c(%r14)
jne 0xb27b
leaq 0x60(%r14), %r15
leaq 0x60(%rbx), %r12
movq 0x68(%r14), %rdx
cmpq 0x68(%rbx), %rdx
jne 0xb26e
testq %rdx, %rdx
je 0xb280
movq (%r12), %rsi
movq (%r15), %rdi
callq 0x3210
testl %eax, %eax
je 0xb280
movq %r15, %rdi
movq %r12, %rsi
callq 0x3040
jmp 0xb229
setl %al
jmp 0xb22c
movl $0x80, %eax
addq %rax, %r14
addq %rax, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3040
jmp 0xb229
jmp 0xb29e
jmp 0xb29e
jmp 0xb29e
movq %rax, %rdi
callq 0x5a33
// File: /workspace/github_cpp_makefile_star2_O1/soccin[P]BIC-RNAseq/tools/MergeFusion/StandardFusion.cpp
// Function: sortByGeneSymbol(StandardFusion const&, StandardFusion const&)
bool sortByGeneSymbol(const StandardFusion &l, const StandardFusion &r)
{
    if(l.gene1 != r.gene1)
        return l.gene1 < r.gene1;
    else
        return l.gene2 < r.gene2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0xb0, %r15d
leaq (%rdi,%r15), %r12
addq %rsi, %r15
movq 0xb8(%rdi), %rdx
cmpq 0xb8(%rsi), %rdx
jne 0xb2e9
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0xb2f6
movq (%r15), %rsi
movq (%r12), %rdi
callq 0x3210
testl %eax, %eax
je 0xb2f6
movq %r12, %rdi
movq %r15, %rsi
callq 0x3040
jmp 0xb30c
movl $0xd0, %eax
addq %rax, %r14
addq %rax, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3040
shrl $0x1f, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb31a
movq %rax, %rdi
callq 0x5a33
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %r15, %rdi
movl $0x18, %edx
callq 0x32f0
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movsbl %r12b, %r12d
leaq -0x48(%rbp), %r13
movq %r15, %rdi
movq %r13, %rsi
movl %r12d, %edx
callq 0x3370
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0xb4e8
testb %bl, %bl
je 0xb4db
cmpq $0x0, -0x40(%rbp)
je 0xb4b4
movq %r14, %rdi
movq %r13, %rsi
callq 0xb576
jmp 0xb4b4
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xb501
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3200
movq 0x5a90(%rip), %rsi      # 0x10f98
leaq -0x1d0(%rbp), %rdi
callq 0x3180
leaq -0x150(%rbp), %rdi
callq 0x30d0
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xb54e
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3200
movq 0x5a43(%rip), %rsi      # 0x10f98
leaq -0x1d0(%rbp), %rdi
callq 0x3180
leaq -0x150(%rbp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x3340
nop
// File: /workspace/github_cpp_makefile_star2_O1/thanoskoutr[P]Chip-8-Emulator/./cleanup.h
// Function: void cleanup<SDL_Renderer, SDL_Window*&>(SDL_Renderer*, SDL_Window*&)
void cleanup(T *t, Args&&... args){
	//Cleanup the first item in the list
	cleanup(t);
	//Clean up the remaining arguments
	cleanup(std::forward<Args>(args)...);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0x33db
callq 0x20f0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x33e9
popq %rbx
jmp 0x2040
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
callq 0x90f0
leaq 0xc4db(%rip), %rcx      # 0xf019
leaq 0xc4e6(%rip), %rsi      # 0xf02b
testb %al, %al
cmovneq %rcx, %rsi
movq 0x1247e(%rip), %rbx     # 0x14fd0
movl $0x11, %edx
movq %rbx, %rdi
callq 0x2270
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2180
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x58, %rsp
movl %esi, -0x2c(%rbp)
movq %rdi, %r12
movq $0x0, 0x60(%rdi)
movl $0x0, 0x68(%rdi)
movq (%rdi), %rsi
callq 0x74e0
leaq 0x18(%r12), %rbx
movq 0x18(%r12), %r13
movq 0x20(%r12), %r15
cmpq %r13, %r15
je 0x2fbd
movq %r13, %r14
movq %r14, %rdi
callq 0x2d76
addq $0x30, %r14
cmpq %r15, %r14
jne 0x2fa7
movq %r13, 0x20(%r12)
leaq 0x30(%r12), %r14
movq 0x30(%r12), %rsi
movq %r14, %rdi
callq 0x7510
movslq -0x2c(%rbp), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x62c4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6352
movq %r14, %rdi
movq %r15, %rsi
callq 0x6442
leaq -0x70(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq -0x48(%rbp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq %rcx, 0x10(%rax)
testl %r15d, %r15d
je 0x3047
leaq -0x78(%rbp), %r13
leaq -0x48(%rbp), %r12
movq %rbx, %rdi
movq %r13, %rsi
callq 0x64e4
movq %r14, %rdi
movq %r12, %rsi
callq 0x6520
decq %r15
jne 0x302c
movq -0x48(%rbp), %rdi
leaq -0x48(%rbp), %r14
cmpq %r14, %rdi
je 0x3064
movq (%rdi), %rbx
callq 0x21f0
movq %rbx, %rdi
cmpq %r14, %rbx
jne 0x3054
leaq -0x78(%rbp), %rdi
callq 0x2d76
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x3098
movq (%rdi), %r14
callq 0x21f0
movq %r14, %rdi
cmpq %r12, %r14
jne 0x3088
leaq -0x78(%rbp), %rdi
callq 0x2d76
movq %rbx, %rdi
callq 0x2380
nop