LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./src/BoundingBox.cpp
// Function: BoundingBox::ray_intersects(Ray&, double&, double&)
bool BoundingBox::ray_intersects(Ray& ray, double &tmin, double &tmax){
    const Eigen::Vector3d& ray_pt = ray.get_point();
    const Eigen::Vector3d& ray_dir = ray.get_dir();
    tmin = (min_corner(0) - ray_pt(0)) / ray_dir(0);
    tmax = (max_corner(0) - ray_pt(0)) / ray_dir(0);

    if (tmin > tmax) std::swap(tmin, tmax);

    double tymin = (min_corner(1) - ray_pt(1)) / ray_dir(1);
    double tymax = (max_corner(1) - ray_pt(1)) / ray_dir(1);

    if (tymin > tymax) std::swap(tymin, tymax);

    if ((tmin > tymax) || (tymin > tmax))
        return false;

    if (tymin > tmin)
        tmin = tymin;

    if (tymax < tmax)
        tmax = tymax;

    double tzmin = (min_corner(2) - ray_pt(2)) / ray_dir(2);
    double tzmax = (max_corner(2) - ray_pt(2)) / ray_dir(2);

    if (tzmin > tzmax) std::swap(tzmin, tzmax);

    if ((tmin > tzmax) || (tzmin > tmax))
        return false;

    if (tzmin > tmin)
        tmin = tzmin;

    if (tzmax < tmax)
        tmax = tzmax;

    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
movq %rsi, %rdi
callq 0x15cb4
movq %rax, %r12
movq %r13, %rdi
callq 0x15cba
movsd (%r15), %xmm0
subsd (%r12), %xmm0
divsd (%rax), %xmm0
movsd %xmm0, (%r14)
movsd 0x18(%r15), %xmm0
subsd (%r12), %xmm0
divsd (%rax), %xmm0
movsd %xmm0, (%rbx)
movsd (%r14), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x6ee6
movsd %xmm0, (%r14)
movsd %xmm1, (%rbx)
movupd 0x8(%r15), %xmm1
movupd 0x8(%r12), %xmm0
movupd 0x8(%rax), %xmm2
movhpd 0x20(%r15), %xmm1       # xmm1 = xmm1[0],mem[0]
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
subpd %xmm0, %xmm1
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
divpd %xmm2, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
movapd %xmm1, %xmm0
maxsd %xmm2, %xmm0
movsd (%r14), %xmm3
xorl %ecx, %ecx
ucomisd %xmm0, %xmm3
ja 0x6fc0
minsd %xmm1, %xmm2
ucomisd (%rbx), %xmm2
ja 0x6fc0
ucomisd %xmm3, %xmm2
jbe 0x6f48
movsd %xmm2, (%r14)
movsd (%rbx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x6f56
movsd %xmm0, (%rbx)
movupd 0x10(%r15), %xmm1
movhpd 0x28(%r15), %xmm1       # xmm1 = xmm1[0],mem[0]
movsd 0x10(%r12), %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
subpd %xmm0, %xmm1
movsd 0x10(%rax), %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
divpd %xmm0, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
movapd %xmm1, %xmm0
maxsd %xmm2, %xmm0
movsd (%r14), %xmm3
xorl %ecx, %ecx
ucomisd %xmm0, %xmm3
ja 0x6fc0
minsd %xmm1, %xmm2
ucomisd (%rbx), %xmm2
ja 0x6fc0
ucomisd %xmm3, %xmm2
jbe 0x6fb0
movsd %xmm2, (%r14)
movsd (%rbx), %xmm1
movb $0x1, %cl
ucomisd %xmm0, %xmm1
jbe 0x6fc0
movsd %xmm0, (%rbx)
movl %ecx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./src/AnimatedObject.cpp
// Function: AnimatedObject::AnimatedObject(Model*)
AnimatedObject::AnimatedObject(Model* animated_asset){
     original_obj = animated_asset;
     current_obj = new Model(*original_obj);
     animation_file = animated_asset->get_animation_file();
     load_animation();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18c32(%rip), %rax     # 0x1fc18
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
leaq 0x10(%rdi), %r14
leaq 0x20(%rdi), %r13
movq %r13, 0x10(%rdi)
leaq 0xfc71(%rip), %rdx      # 0x16c74
movq %r14, %rdi
movq %rdx, %rsi
callq 0x5be2
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movq $0x0, 0x40(%rbx)
movq %r15, 0x48(%rbx)
movl $0x258, %edi            # imm = 0x258
callq 0x32c0
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x8b4c
movq %r12, 0x50(%rbx)
movq %rsp, %rdi
movq %r15, %rsi
callq 0x9c08
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3330
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x7070
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32d0
movq %rbx, %rdi
callq 0x70c6
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x709a
movq %rax, %r15
movl $0x258, %esi            # imm = 0x258
movq %r12, %rdi
callq 0x32d0
jmp 0x709d
movq %rax, %r15
addq $0x30, %rbx
movq %rbx, %rdi
callq 0x5712
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x70bd
movq (%r13), %rsi
incq %rsi
callq 0x32d0
movq %r15, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./src/AnimatedObject.cpp
// Function: AnimatedObject::extract_file_lines(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::vector<std::string> AnimatedObject::extract_file_lines(std::string file_name){
    std::ifstream in(file_name);
    std::string driver_line;
    std::vector<std::string> result;

    while (std::getline(in, driver_line)){
        // An arbitrary check to make sure the line has contents
        if (driver_line.size() > 10){
            result.push_back(driver_line);
        }
    }
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
movl $0x8, %edx
callq 0x3420
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rsp, %r15
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x34e0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x746e
cmpq $0xb, 0x8(%rsp)
jb 0x7427
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7bbe
jmp 0x7427
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x7484
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32d0
leaq 0x20(%rsp), %rdi
callq 0x30a0
movq %rbx, %rax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7b16
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x74c1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32d0
leaq 0x20(%rsp), %rdi
callq 0x30a0
movq %r14, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./src/AnimatedObject.cpp
// Function: AnimatedObject::add_animation_section(int, int, std::vector<double, std::allocator<double>>)
void AnimatedObject::add_animation_section(int section_start, int section_end,  std::vector<double> transform_floats){
    int number_frames = section_end - section_start;
    if (number_frames == 0){
        return;
    }
    std::vector<double> single_frame_transform = fraction_of_transform(number_frames, transform_floats);
    for (int i=1; i<number_frames+1; i++){
        frame_setting current;
        current.frame_number = section_start + i - 1;
        current.transform_floats = multiple_of_transform(i, single_frame_transform);
        current.set_as_new_base_model = (i == number_frames);
        frame_steps.push_back(current);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %edx, %ebp
subl %esi, %ebp
je 0x766f
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
leaq 0x90(%rsp), %r13
cvtsi2sd %ebp, %xmm0
movsd %xmm0, (%rsp)
leaq 0x80(%rsp), %r12
movq %r12, %rdi
movq %rcx, %rsi
callq 0x7a96
leaq 0x50(%rsp), %rdi
movsd (%rsp), %xmm0
movq %r12, %rdx
callq 0x76ec
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x754a
movq 0x90(%rsp), %rsi
subq %rdi, %rsi
callq 0x32d0
testl %ebp, %ebp
jle 0x7658
leaq 0x60(%rsp), %rax
movq %rax, (%rsp)
leaq 0x10(%rsp), %rbp
addq $0x30, %r15
negl %ebx
movl $0x1, %r13d
leaq 0x68(%rsp), %r12
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbp)
movq $0x0, 0x10(%rbp)
movl %r14d, 0x8(%rsp)
movq %r12, %rdi
leaq 0x50(%rsp), %rsi
callq 0x7a96
xorps %xmm0, %xmm0
cvtsi2sd %r13d, %xmm0
leaq 0x30(%rsp), %rdi
movq %r12, %rdx
callq 0x77d4
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movapd 0x30(%rsp), %xmm0
movupd %xmm0, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
testq %rdi, %rdi
je 0x75e9
subq %rdi, %rsi
callq 0x32d0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x7600
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x32d0
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x7617
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x32d0
leal (%rbx,%r14), %eax
cmpl $-0x1, %eax
sete 0x28(%rsp)
movq %r15, %rdi
leaq 0x8(%rsp), %rsi
callq 0x7b72
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x7647
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x32d0
incl %r13d
incl %r14d
movl %ebx, %eax
addl %r14d, %eax
jne 0x7571
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x766f
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x32d0
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, (%rsp)
movq %rax, %rbx
movq 0x80(%rsp), %rdi
jmp 0x76cf
jmp 0x76b0
movq %rax, %rbx
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x76b3
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x32d0
jmp 0x76b3
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x76ca
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x32d0
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x76e3
movq (%rsp), %rax
movq (%rax), %rsi
subq %rdi, %rsi
callq 0x32d0
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./src/AnimatedObject.cpp
// Function: AnimatedObject::fraction_of_transform(double, std::vector<double, std::allocator<double>>)
std::vector<double> AnimatedObject::fraction_of_transform(double divide_by, std::vector<double> transform_floats){
    // transform_floats should be 8 long
    std::vector<double> result;
    for (int i=0; i<8; i++){
        double temp = transform_floats[i];
        // Scale value defaults to 1
        if (i==4){
            temp = 1 + (temp-1) / divide_by;
        }
        // Transform values default to 0
        if (i>4 || i==3){
            temp = temp / divide_by;
        }
        result.push_back(temp);
    }
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %r12d, %r12d
leaq 0x10(%rsp), %r15
movq (%r14), %rax
movsd (%rax,%r12,8), %xmm1
movapd %xmm1, %xmm0
addsd 0xf788(%rip), %xmm0     # 0x16eb8
divsd 0x8(%rsp), %xmm0
addsd 0xe8f2(%rip), %xmm0     # 0x16030
cmpq $0x4, %r12
je 0x7748
movapd %xmm1, %xmm0
movapd %xmm0, %xmm1
divsd 0x8(%rsp), %xmm1
movapd %xmm1, %xmm2
cmpq $0x3, %r12
je 0x7760
movapd %xmm0, %xmm2
cmpq $0x5, %r12
jae 0x776a
movapd %xmm2, %xmm1
movsd %xmm1, 0x10(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x778e
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x7799
movq %rbx, %rdi
movq %r15, %rdx
callq 0x7c5c
incq %r12
cmpq $0x8, %r12
jne 0x771b
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x77cc
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x32d0
movq %r14, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./src/Model.cpp
// Function: Model::on_model_load()
void Model::on_model_load(){
    map_vertices_faces();
    calculate_face_normals();
    int recursion_depth = 8;
    bounding_box = std::make_unique<OctTree>(Vertices, Faces, recursion_depth);
    calculate_vertex_normals();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x92f2
movq %rbx, %rdi
callq 0x9426
leaq 0x198(%rbx), %r15
leaq 0x1b0(%rbx), %r12
movl $0xa8, %edi
callq 0x32c0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl $0x8, %ecx
callq 0x14648
leaq 0x190(%rbx), %rdi
movq %r14, %rsi
callq 0xb11a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x964c
movq %rax, %rbx
movl $0xa8, %esi
movq %r14, %rdi
callq 0x32d0
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./src/Model.cpp
// Function: Model::map_vertices_faces()
void Model::map_vertices_faces(){
    int num_verts = Vertices.cols();
    std::vector<std::vector<int>> temp(num_verts);
    vertex_to_faces = temp;

    for (int face_num=0; face_num<Faces.cols(); face_num++){
        for (int j=0; j<3; j++){
            int vert = Faces(j, face_num);
            vertex_to_faces[vert-1].push_back(face_num);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movslq 0x1a8(%rdi), %rsi
leaq 0x8(%rsp), %r14
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
callq 0xac88
leaq 0x1e0(%rbx), %rdi
movq %r14, %rsi
callq 0xa9a6
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x1c0(%rbx)
jle 0x93db
xorl %r15d, %r15d
leaq 0x4(%rsp), %r14
movslq 0x4(%rsp), %rax
testq %rax, %rax
js 0x93ef
movq 0x1b8(%rbx), %rcx
cmpq %r15, %rcx
jle 0x93ef
cmpq %rax, 0x1c0(%rbx)
jle 0x93ef
imulq %rax, %rcx
shlq $0x2, %rcx
addq 0x1b0(%rbx), %rcx
movslq (%rcx,%r15,4), %rcx
movq 0x1e0(%rbx), %rdx
leaq (%rcx,%rcx,2), %rcx
leaq (%rdx,%rcx,8), %rdi
movq -0x10(%rdi), %rsi
cmpq -0x8(%rdi), %rsi
je 0x93a7
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x10(%rdi)
jmp 0x93b3
addq $-0x18, %rdi
movq %r14, %rdx
callq 0xb66e
incq %r15
cmpq $0x3, %r15
jne 0x9344
movslq 0x4(%rsp), %rax
incq %rax
movl %eax, 0x4(%rsp)
movl $0x0, %r15d
cmpq %rax, 0x1c0(%rbx)
jg 0x9344
leaq 0x8(%rsp), %rdi
callq 0xa958
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xd09d(%rip), %rdi      # 0x16493
leaq 0xd0cb(%rip), %rsi      # 0x164c8
leaq 0xdbec(%rip), %rcx      # 0x16ff0
movl $0x16d, %edx            # imm = 0x16D
callq 0x31a0
jmp 0x9410
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa958
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./src/Model.cpp
// Function: Model::calculate_vertex_normals()
void Model::calculate_vertex_normals(){
    /* Assumes that calculate_face_normals was called first
      For every face calculate and store the vertex normal for its three vertices
    */
    int num_vert_norms = Faces.cols()*3;
    std::vector<Eigen::Vector3d> temp(num_vert_norms);
    vertex_normals = temp;
    Eigen::Vector3d original, average;
    for (int face_num=0; face_num<Faces.cols(); face_num++){
        original = get_face_normal(face_num);
        for (int f_vert=0; f_vert<3; f_vert++){
            int vertex_num = Faces(f_vert, face_num);
            average = get_face_normal(face_num);
            calc_vertex_normal(vertex_num, original, average);
            vertex_normals[3*face_num + f_vert] = average;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x1c0(%rdi), %rax
shlq $0x20, %rax
leaq (%rax,%rax,2), %rsi
sarq $0x20, %rsi
leaq 0x38(%rsp), %r14
leaq 0x50(%rsp), %rdx
movq %r14, %rdi
callq 0xaf08
leaq 0x1f8(%rbx), %rdi
movq %r14, %rsi
callq 0xab1e
cmpq $0x0, 0x1c0(%rbx)
jle 0x9785
movl $0x10, %r12d
xorl %r15d, %r15d
xorl %r13d, %r13d
movq %rsp, %rdi
movq %rbx, %rsi
movl %r13d, %edx
callq 0x99a8
movaps (%rsp), %xmm0
movaps %xmm0, 0x50(%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x60(%rsp)
movq %r12, 0x18(%rsp)
xorl %r14d, %r14d
movq 0x1b8(%rbx), %rax
cmpq %r14, %rax
jle 0x97ab
cmpq %r13, 0x1c0(%rbx)
jle 0x97ab
imulq %r15, %rax
addq 0x1b0(%rbx), %rax
movl (%rax,%r14,4), %ebp
movq %rsp, %rdi
movq %rbx, %rsi
movl %r13d, %edx
callq 0x99a8
movaps (%rsp), %xmm0
movaps %xmm0, 0x20(%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
leaq 0x50(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq 0x9a12
movq 0x1f8(%rbx), %rax
movaps 0x20(%rsp), %xmm0
movups %xmm0, -0x10(%rax,%r12)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, (%rax,%r12)
incq %r14
addq $0x18, %r12
cmpq $0x3, %r14
jne 0x96d6
incq %r13
movq 0x18(%rsp), %r12
addq $0x48, %r12
addq $0x4, %r15
cmpq %r13, 0x1c0(%rbx)
jg 0x96ab
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x979c
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x32d0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcce1(%rip), %rdi      # 0x16493
leaq 0xcd0f(%rip), %rsi      # 0x164c8
leaq 0xd830(%rip), %rcx      # 0x16ff0
movl $0x16d, %edx            # imm = 0x16D
callq 0x31a0
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x97e4
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x32d0
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./src/Model.cpp
// Function: Model::calc_vertex_normal(int, Eigen::Matrix<double, 3, 1, 0, 3, 1> const&, Eigen::Matrix<double, 3, 1, 0, 3, 1>&)
void Model::calc_vertex_normal(int vertex_num, const Eigen::Vector3d& original_face, Eigen::Vector3d& average){
    int num_to_average = 1;
    Eigen::Vector3d conn_face_normal;
    for (auto connected_face:vertex_to_faces[vertex_num-1]){
        conn_face_normal = get_face_normal(connected_face);
        double angle = conn_face_normal.dot(original_face);
        // If angle between face normals is less than 22.5 degrees then smooth between them
        if (angle <= 1 && angle >=.9239){
            average = average + conn_face_normal;
            num_to_average++;
        }
    }
    average = average.normalized();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq 0x1e0(%rdi), %rax
movslq %esi, %rcx
leaq (%rcx,%rcx,2), %rcx
movq -0x18(%rax,%rcx,8), %r13
movq -0x10(%rax,%rcx,8), %rbp
cmpq %rbp, %r13
je 0x9abd
movq %rdx, %r14
movq %rdi, %r15
movq %rsp, %r12
movl (%r13), %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x99a8
movapd (%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
movupd (%r14), %xmm2
mulpd %xmm1, %xmm2
movapd %xmm2, %xmm3
unpckhpd %xmm2, %xmm3            # xmm3 = xmm3[1],xmm2[1]
addsd %xmm2, %xmm3
movsd 0x10(%r14), %xmm2
mulsd %xmm0, %xmm2
addsd %xmm3, %xmm2
movsd 0xc5a2(%rip), %xmm3     # 0x16030
ucomisd %xmm2, %xmm3
jb 0x9ab4
ucomisd 0xd48c(%rip), %xmm2     # 0x16f28
jb 0x9ab4
movupd (%rbx), %xmm2
addpd %xmm2, %xmm1
movupd %xmm1, (%rbx)
addsd 0x10(%rbx), %xmm0
movsd %xmm0, 0x10(%rbx)
addq $0x4, %r13
cmpq %rbp, %r13
jne 0x9a49
movupd (%rbx), %xmm0
movapd %xmm0, %xmm1
mulpd %xmm0, %xmm1
movapd %xmm1, %xmm3
unpckhpd %xmm1, %xmm3            # xmm3 = xmm3[1],xmm1[1]
addsd %xmm1, %xmm3
movsd 0x10(%rbx), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm3, %xmm2
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm2
jbe 0x9b04
movq %xmm2, %xmm2            # xmm2 = xmm2[0],zero
sqrtpd %xmm2, %xmm2
divsd %xmm2, %xmm1
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
divpd %xmm2, %xmm0
movupd %xmm0, (%rbx)
movsd %xmm1, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./src/Model.cpp
// Function: Model::get_smooth_face_normal(int, double, double)
Eigen::Vector3d Model::get_smooth_face_normal(int face_num, double beta, double gamma){
    Eigen::Vector3d normal_one, normal_two, normal_three;
    normal_one = get_vertex_normal(face_num, 0);
    normal_two = get_vertex_normal(face_num, 1);
    normal_three = get_vertex_normal(face_num, 2);
    return ((1-beta-gamma) * normal_one + beta*normal_two + gamma*normal_three).normalized();
}

// Assembly:
movq %rdi, %rax
leal (%rdx,%rdx,2), %ecx
movslq %ecx, %rdx
movq 0x1f8(%rsi), %rcx
leaq (%rdx,%rdx,2), %rdx
movupd (%rcx,%rdx,8), %xmm2
movupd 0x18(%rcx,%rdx,8), %xmm3
movupd 0x30(%rcx,%rdx,8), %xmm4
movsd 0xc4e7(%rip), %xmm5     # 0x16030
subsd %xmm0, %xmm5
subsd %xmm1, %xmm5
movapd %xmm5, %xmm6
unpcklpd %xmm5, %xmm6            # xmm6 = xmm6[0],xmm5[0]
mulpd %xmm2, %xmm6
movapd %xmm0, %xmm7
unpcklpd %xmm0, %xmm7            # xmm7 = xmm7[0],xmm0[0]
mulpd %xmm3, %xmm7
addpd %xmm6, %xmm7
movapd %xmm1, %xmm2
unpcklpd %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
mulpd %xmm4, %xmm2
mulsd 0x10(%rcx,%rdx,8), %xmm5
mulsd 0x28(%rcx,%rdx,8), %xmm0
addpd %xmm7, %xmm2
addsd %xmm5, %xmm0
mulsd 0x40(%rcx,%rdx,8), %xmm1
addsd %xmm0, %xmm1
movapd %xmm2, %xmm0
mulpd %xmm2, %xmm0
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3            # xmm3 = xmm3[1],xmm0[1]
addsd %xmm0, %xmm3
movapd %xmm1, %xmm0
mulsd %xmm1, %xmm0
addsd %xmm3, %xmm0
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm0
jbe 0x9bd5
movq %xmm0, %xmm0            # xmm0 = xmm0[0],zero
sqrtpd %xmm0, %xmm0
divsd %xmm0, %xmm1
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
divpd %xmm0, %xmm2
movupd %xmm2, (%rax)
movsd %xmm1, 0x10(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./src/Model.cpp
// Function: Model::get_refracted_ray(Ray&, Eigen::Matrix<double, 3, 1, 0, 3, 1>&, Eigen::Matrix<double, 3, 1, 0, 3, 1>&)
Ray Model::get_refracted_ray(Ray &orig_ray, Eigen::Vector3d &intersect_pos, Eigen::Vector3d &normal){
    Eigen::Vector3d T1, T2;
    double this_eta = get_eta();
    Eigen::Vector3d W = -1 * orig_ray.get_dir();
    T1 = refract_ray(W, normal, 1.0, this_eta);
    Eigen::Vector3d exit, Nin;
    get_refract_exit(intersect_pos, T1, exit, Nin);
    T1 = -1 * T1;
    T2 = refract_ray(T1, Nin, this_eta, 1.0);
    Ray exit_ray = Ray(exit, T2);
    return exit_ray;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %r8, %r12
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x10892
movsd %xmm0, 0x8(%rsp)
movq %r13, %rdi
callq 0x15cba
movups (%rax), %xmm0
movaps 0xcafc(%rip), %xmm1     # 0x16f10
xorps %xmm1, %xmm0
leaq 0xb0(%rsp), %rdx
movaps %xmm0, (%rdx)
movsd 0x10(%rax), %xmm0
xorps %xmm1, %xmm0
movlps %xmm0, 0x10(%rdx)
leaq 0x30(%rsp), %r13
movsd 0xbbf5(%rip), %xmm0     # 0x16030
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rcx
movsd 0x8(%rsp), %xmm1
callq 0x10794
movaps (%r13), %xmm0
leaq 0xd0(%rsp), %r12
movaps %xmm0, (%r12)
movsd 0x10(%r13), %xmm0
movsd %xmm0, 0x10(%r12)
movups (%r15), %xmm0
leaq 0x110(%rsp), %rsi
movaps %xmm0, (%rsi)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsi)
movapd (%r12), %xmm0
leaq 0xf0(%rsp), %rdx
movapd %xmm0, (%rdx)
movq 0x10(%r12), %rax
movq %rax, 0x10(%rdx)
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
callq 0x15c24
movq (%r14), %rax
leaq 0x130(%rsp), %r13
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq *0x10(%rax)
movupd (%r15), %xmm2
movapd (%r12), %xmm1
movapd %xmm0, %xmm3
unpcklpd %xmm0, %xmm3            # xmm3 = xmm3[0],xmm0[0]
mulpd %xmm1, %xmm3
addpd %xmm2, %xmm3
movapd %xmm3, 0x20(%rsp)
movsd 0x10(%r12), %xmm3
mulsd %xmm3, %xmm0
addsd 0x10(%r15), %xmm0
movapd %xmm0, 0x10(%rsp)
movapd 0xca0c(%rip), %xmm2     # 0x16f10
xorpd %xmm2, %xmm1
movapd %xmm1, (%r12)
xorpd %xmm2, %xmm3
movlpd %xmm3, 0x10(%r12)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
movsd 0x8(%rsp), %xmm0
movsd 0xbaf8(%rip), %xmm1     # 0x16030
callq 0x10794
movaps (%r15), %xmm0
movsd 0x10(%r15), %xmm1
leaq 0x90(%rsp), %rsi
movaps 0x20(%rsp), %xmm2
movaps %xmm2, (%rsi)
movaps 0x10(%rsp), %xmm2
movsd %xmm2, 0x10(%rsi)
leaq 0x70(%rsp), %rdx
movaps %xmm0, (%rdx)
movsd %xmm1, 0x10(%rdx)
movq %rbx, %rdi
callq 0x15c24
movq %rbx, %rax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./src/RenderImage.cpp
// Function: RenderImage::tile_images(int)
std::queue<image_tile> RenderImage::tile_images(int tile_size){
  std::queue<image_tile> results;
  int width = scene->get_camera().pixel_width;
  int height = scene->get_camera().pixel_height;
  for (int i=0; i<width; i+=tile_size){
      for (int j=0; j<height; j+=tile_size){
          int x_len = std::min(width-i, tile_size);
          int y_len = std::min(height-j, tile_size);
          image_tile ir = build_image_tile(i, j, x_len, y_len);
          results.push(ir);
      }
  }
  return results;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %esi, %esi
callq 0xd5ca
movq (%r14), %rdi
callq 0xee34
movl (%rax), %r15d
movq (%r14), %rdi
callq 0xee34
testl %r15d, %r15d
jle 0xc1b1
movl 0x4(%rax), %eax
movl %eax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl %r15d, 0x14(%rsp)
cmpl $0x0, 0x10(%rsp)
jle 0xc199
movl 0x14(%rsp), %eax
movl %eax, %r15d
movl 0xc(%rsp), %eax
subl %eax, %r15d
cmpl %ebp, %r15d
cmovgel %ebp, %r15d
movl %eax, %r14d
xorl %r13d, %r13d
movl 0x10(%rsp), %r12d
movl %r12d, %eax
subl %ebp, %r12d
cmovgel %ebp, %eax
movq %r13, %rcx
shlq $0x20, %rcx
orq %r14, %rcx
shlq $0x20, %rax
orq %r15, %rax
movq %rcx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq 0x30(%rbx), %rax
movq 0x40(%rbx), %rcx
addq $-0x10, %rcx
cmpq %rcx, %rax
je 0xc182
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rax)
addq $0x10, 0x30(%rbx)
jmp 0xc18f
movq %rbx, %rdi
leaq 0x18(%rsp), %rsi
callq 0xd742
addl %ebp, %r13d
cmpl 0x10(%rsp), %r13d
jl 0xc13e
movl 0xc(%rsp), %eax
addl %ebp, %eax
movl 0x14(%rsp), %r15d
movl %eax, 0xc(%rsp)
cmpl %r15d, %eax
jl 0xc117
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc1c7
jmp 0xc1c7
movq %rax, %r14
movq %rbx, %rdi
callq 0x6bfa
movq %r14, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./src/RenderImage.cpp
// Function: RenderImage::render_tiles()
void RenderImage::render_tiles(){
    // Might be called by multiple threads, so image_tiles needs to be populated
    //   before this function is used
    bool queue_empty = false;
    while (!queue_empty){
        image_tiles_mutex.lock();
        image_tile current_tile = build_image_tile(0,0,0,0);
        if (!image_tiles.empty()){
            current_tile = image_tiles.front();
            image_tiles.pop();
        } else{
            queue_empty = true;
        }
        image_tiles_mutex.unlock();
        // If the queue was empty, current_tile covers no area and will not cause any rendering
        render_tile(current_tile);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x60(%rdi), %r14
leaq 0x10(%rdi), %r15
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x33b0
testl %eax, %eax
jne 0xc2e3
movq 0x20(%rbx), %rax
cmpq %rax, 0x40(%rbx)
je 0xc2af
movq (%rax), %r12
movq 0x8(%rax), %r13
movq %r15, %rdi
callq 0xd958
jmp 0xc2b8
movb $0x1, %bpl
xorl %r12d, %r12d
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x3220
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xc2ea
testb $0x1, %bpl
je 0xc288
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x31c0
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./src/RenderImage.cpp
// Function: RenderImage::ray_trace(Ray&, Eigen::Matrix<double, 3, 1, 0, 3, 1>&, Eigen::Matrix<double, 3, 1, 0, 3, 1>&, int, double&)
void RenderImage::ray_trace(Ray& ray, Eigen::Vector3d& accum, Eigen::Vector3d& ampl, int level, double &t_value){
    if (scene->get_rendered_objects().size() == 0){
        return;
    }
    SceneObject* hit_obj = scene->get_rendered_objects()[0];
    Eigen::Vector3d hit_normal;
    t_value = find_intersection(ray, hit_obj, hit_normal);

    calculate_color(ray, t_value, hit_obj, hit_normal, accum, ampl, level);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r13
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rdi
callq 0xee2c
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0xc6e4
movq (%r12), %rdi
callq 0xee2c
movq (%rax), %rax
movq (%rax), %rax
movq %rbx, 0x10(%rsp)
leaq 0x18(%rsp), %rbx
movq %rax, (%rbx)
leaq 0x20(%rsp), %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xc6f4
movsd %xmm0, (%r13)
movq (%rbx), %rdx
movl %ebp, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
leaq 0x20(%rsp), %rcx
movq %r14, %r8
movq 0x10(%rsp), %r9
callq 0xc79a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./src/RenderImage.cpp
// Function: RenderImage::find_intersection(Ray&, SceneObject*&, Eigen::Matrix<double, 3, 1, 0, 3, 1>&)
double RenderImage::find_intersection(Ray& ray, SceneObject*& md, Eigen::Vector3d &hit_normal){
    double epsilon = .0000000001;
    double intersect_t = MISSED_T_VALUE;
    Eigen::Vector3d hit_s_normal;
    for (auto so : scene->get_rendered_objects()){
        double t_value = so->intersect_ray(ray, hit_s_normal);
        if (t_value <= epsilon){
            continue;
        }
        if ((t_value < intersect_t) ){
            intersect_t = t_value;
            md = so;
            hit_normal = hit_s_normal;
        }
    }
    return intersect_t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movsd 0x8(%rdi), %xmm0
movsd %xmm0, (%rsp)
movq (%rdi), %rdi
callq 0xee2c
movq (%rax), %rbp
movq 0x8(%rax), %r14
cmpq %r14, %rbp
je 0xc786
leaq 0x10(%rsp), %r12
movq (%rbp), %r13
movq (%r13), %rax
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x10(%rax)
movsd 0xb5bc(%rip), %xmm1     # 0x17d08
ucomisd %xmm0, %xmm1
jae 0xc77d
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xc77d
movq 0x8(%rsp), %rax
movq %r13, (%rax)
movaps 0x10(%rsp), %xmm1
movups %xmm1, (%rbx)
movsd 0x20(%rsp), %xmm1
movsd %xmm1, 0x10(%rbx)
movsd %xmm0, (%rsp)
addq $0x8, %rbp
cmpq %r14, %rbp
jne 0xc730
movsd (%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./src/RenderImage.cpp
// Function: RenderImage::lightReachesObject(Light&, Eigen::Matrix<double, 3, 1, 0, 3, 1>)
bool RenderImage::lightReachesObject(Light& light, Eigen::Vector3d intersect_pos){
    SceneObject* unused_so;
    Eigen::Vector3d unused_norm;

    double distance_to_light = (light.get_pos() - intersect_pos).norm();
    Eigen::Vector3d vector_to_light = (light.get_pos() - intersect_pos).normalized();
    Ray ray_to_light = Ray(intersect_pos, vector_to_light);
    double t_value = find_intersection(ray_to_light, unused_so, unused_norm);
    if (t_value == MISSED_T_VALUE || (distance_to_light < t_value)){
        return true;
    }
    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x50(%rsp), %r12
movq %r12, %rdi
callq 0x5afa
movaps (%r12), %xmm0
movaps %xmm0, 0x30(%rsp)
movups (%r14), %xmm0
movaps %xmm0, 0x20(%rsp)
movsd 0x10(%r12), %xmm0
movaps %xmm0, (%rsp)
movsd 0x10(%r14), %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0x50(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5afa
movapd (%r12), %xmm0
movupd (%r14), %xmm1
subpd %xmm1, %xmm0
movapd %xmm0, %xmm1
mulpd %xmm0, %xmm1
movapd %xmm1, %xmm3
unpckhpd %xmm1, %xmm3            # xmm3 = xmm3[1],xmm1[1]
addsd %xmm1, %xmm3
movsd 0x10(%r12), %xmm1
subsd 0x10(%r14), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm3, %xmm2
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm2
jbe 0xd458
movq %xmm2, %xmm2            # xmm2 = xmm2[0],zero
sqrtpd %xmm2, %xmm2
divsd %xmm2, %xmm1
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
divpd %xmm2, %xmm0
movapd 0x30(%rsp), %xmm3
subpd 0x20(%rsp), %xmm3
mulpd %xmm3, %xmm3
movapd %xmm3, %xmm2
unpckhpd %xmm3, %xmm2            # xmm2 = xmm2[1],xmm3[1]
addsd %xmm3, %xmm2
movapd (%rsp), %xmm3
subsd 0x18(%rsp), %xmm3
mulsd %xmm3, %xmm3
addsd %xmm2, %xmm3
movq %xmm3, %xmm2            # xmm2 = xmm3[0],zero
sqrtpd %xmm2, %xmm2
movapd %xmm2, (%rsp)
movups (%r14), %xmm2
leaq 0xb0(%rsp), %rsi
movaps %xmm2, (%rsi)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsi)
leaq 0x90(%rsp), %rdx
movapd %xmm0, (%rdx)
movsd %xmm1, 0x10(%rdx)
leaq 0x50(%rsp), %r14
movq %r14, %rdi
callq 0x15c24
leaq 0x48(%rsp), %rdx
leaq 0xd0(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc6f4
movsd 0x8(%rbx), %xmm1
cmpeqpd %xmm0, %xmm1
movapd (%rsp), %xmm2
cmpltpd %xmm0, %xmm2
orpd %xmm1, %xmm2
movd %xmm2, %eax
andb $0x1, %al
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./src/Sphere.cpp
// Function: Sphere::ray_intersects(Ray&)
bool Sphere::ray_intersects(Ray& ray){
    double v = (sphere_center - ray.get_point()).dot(ray.get_dir());
    double c = (sphere_center - ray.get_point()).norm();
    if ((radius*radius) > (c*c - v*v)){
        return true;
    } else{
        return false;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x15cb4
movq %rax, %r15
movq %r14, %rdi
callq 0x15cba
movupd 0x1b8(%rbx), %xmm0
movupd (%r15), %xmm1
subpd %xmm1, %xmm0
movupd (%rax), %xmm1
mulpd %xmm0, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
movsd 0x1c8(%rbx), %xmm2
subsd 0x10(%r15), %xmm2
addsd %xmm1, %xmm0
mulsd 0x10(%rax), %xmm2
addsd %xmm0, %xmm2
movsd %xmm2, 0x8(%rsp)
movq %r14, %rdi
callq 0x15cb4
movupd 0x1b8(%rbx), %xmm0
movupd (%rax), %xmm1
subpd %xmm1, %xmm0
mulpd %xmm0, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x1c8(%rbx), %xmm0
subsd 0x10(%rax), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
movsd 0x190(%rbx), %xmm1
mulsd %xmm1, %xmm1
movsd 0x8(%rsp), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm0, %xmm0
subsd %xmm2, %xmm0
ucomisd %xmm0, %xmm1
seta %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./src/Scene.cpp
// Function: Scene::add_model(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Scene::add_model(std::string driver_line){
    Model* mo = new Model(driver_line);
    if (mo->is_animated()){
        AnimatedObject* ao = new AnimatedObject(mo);
        ao->set_start_frame(current_frame);
        animated_objects.push_back(ao);
    } else{
        SceneObject* so = (SceneObject*) mo;
        scene_objects.push_back(so);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x258, %edi            # imm = 0x258
callq 0x32c0
movq %rax, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x5760
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x8220
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xf22e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32d0
movq %r14, %rdi
callq 0x9c32
testb %al, %al
je 0xf285
movl $0x58, %edi
callq 0x32c0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x6fcc
movq %r15, (%rsp)
movl 0x234(%rbx), %esi
movq %r15, %rdi
callq 0x785c
movq 0x1f0(%rbx), %rsi
cmpq 0x1f8(%rbx), %rsi
je 0xf2ba
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x1f0(%rbx)
jmp 0xf2cc
movq %r14, (%rsp)
movq 0x1c0(%rbx), %rsi
cmpq 0x1c8(%rbx), %rsi
je 0xf2a6
movq %r14, (%rsi)
addq $0x8, 0x1c0(%rbx)
jmp 0xf2cc
addq $0x1b8, %rbx            # imm = 0x1B8
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x10230
jmp 0xf2cc
addq $0x1e8, %rbx            # imm = 0x1E8
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x1030c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x58, %esi
movq %r15, %rdi
jmp 0xf30c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xf304
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32d0
jmp 0xf304
movq %rax, %rbx
movl $0x258, %esi            # imm = 0x258
movq %r14, %rdi
callq 0x32d0
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./src/Scene.cpp
// Function: Scene::add_sphere(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Scene::add_sphere(std::string driver_line){
    Sphere* sp = new Sphere(driver_line);
    if (sp->is_animated()){
        AnimatedSphere* as = new AnimatedSphere(sp);
        as->set_start_frame(current_frame);
        animated_objects.push_back(as);
    } else{
        SceneObject* so = (SceneObject*) sp;
        scene_objects.push_back(so);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x1d0, %edi            # imm = 0x1D0
callq 0x32c0
movq %rax, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x5760
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xdae4
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xf37a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32d0
movq %rbx, %rdi
callq 0xe4de
testb %al, %al
je 0xf3c4
movl $0x78, %edi
callq 0x32c0
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x13e1c
movl 0x234(%r14), %esi
movq %r15, %rdi
callq 0x785c
addq $0x1e8, %r14            # imm = 0x1E8
movq %rsp, %rsi
movq %r15, (%rsi)
movq %r14, %rdi
callq 0x10448
jmp 0xf3f7
movq %rbx, (%rsp)
movq 0x1c0(%r14), %rsi
cmpq 0x1c8(%r14), %rsi
je 0xf3e5
movq %rbx, (%rsi)
addq $0x8, 0x1c0(%r14)
jmp 0xf3f7
addq $0x1b8, %r14            # imm = 0x1B8
movq %rsp, %rdx
movq %r14, %rdi
callq 0x10230
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x78, %esi
movq %r15, %rdi
jmp 0xf437
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xf42f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32d0
jmp 0xf42f
movq %rax, %r14
movl $0x1d0, %esi            # imm = 0x1D0
movq %rbx, %rdi
callq 0x32d0
movq %r14, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./src/Scene.cpp
// Function: Scene::edit_ambient(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Scene::edit_ambient(std::string driver_line){
    std::stringstream ambient_read(driver_line);
    std::string line_type;
    double red, green, blue;
    ambient_read >> line_type >> red >> green >> blue;
    ambient << red, green, blue;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, %rbx
leaq 0x58(%rsp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x3400
leaq 0x48(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x38(%rsp), %rsi
movq %r14, %rdi
callq 0x3340
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x31b0
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x31b0
movq %rsp, %rsi
movq %rax, %rdi
callq 0x31b0
leaq 0x218(%rbx), %rax
leaq 0x18(%rsp), %rdi
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x1, %eax
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x218(%rbx)
leaq 0x8(%rsp), %rsi
callq 0x5b26
movq %rsp, %rsi
movq %rax, %rdi
callq 0x5b26
movq 0x30(%rsp), %rax
addq 0x20(%rsp), %rax
cmpq $0x3, %rax
jne 0xf54d
cmpq $0x1, 0x28(%rsp)
jne 0xf54d
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0xf522
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x32d0
movq 0x10a6f(%rip), %rsi     # 0x1ff98
leaq 0x58(%rsp), %rdi
callq 0x3210
leaq 0xd8(%rsp), %rdi
callq 0x30e0
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x73f4(%rip), %rdi      # 0x16948
leaq 0x748b(%rip), %rsi      # 0x169e6
leaq 0x74ae(%rip), %rcx      # 0x16a10
movl $0x78, %edx
callq 0x31a0
movq %rax, %rbx
movq 0x30(%rsp), %rax
addq 0x20(%rsp), %rax
cmpq $0x3, %rax
jne 0xf587
cmpq $0x1, 0x28(%rsp)
je 0xf58f
callq 0x365e
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0xf5a6
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x32d0
movq 0x109eb(%rip), %rsi     # 0x1ff98
leaq 0x58(%rsp), %rdi
callq 0x3210
leaq 0xd8(%rsp), %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./src/Scene.cpp
// Function: Scene::valid_driver_line(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Scene::valid_driver_line(std::string driver_line){
    bool is_valid = true;
    if(driver_line.size() == 0){
        is_valid = false;
    } else if(isspace(driver_line[0])){
        is_valid = false;
    } else if(driver_line[0] == '#'){
        is_valid = false;
    }
    return is_valid;
}

// Assembly:
cmpq $0x0, 0x8(%rsi)
je 0xf6c8
pushq %rbx
movq (%rsi), %rax
movsbl (%rax), %edi
cmpl $0x23, %edi
setne %bl
callq 0x3050
testl %eax, %eax
sete %al
andb %bl, %al
popq %rbx
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./src/SceneObject.cpp
// Function: SceneObject::refract_ray(Eigen::Matrix<double, 3, 1, 0, 3, 1>&, Eigen::Matrix<double, 3, 1, 0, 3, 1>&, double, double)
Eigen::Vector3d SceneObject::refract_ray(Eigen::Vector3d &w, Eigen::Vector3d &normal, double first_eta, double second_eta){
    double etar = first_eta / second_eta;
    double a = - etar;
    double wn = w.dot(normal);
    double radsq = etar*etar * (wn*wn -1) + 1;
    double b = (etar * wn) - std::sqrt(radsq);
    Eigen::Vector3d T = a * w + b * normal;
    return T;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movapd %xmm0, %xmm3
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
divsd %xmm1, %xmm3
movapd 0x675a(%rip), %xmm2     # 0x16f10
movupd (%rdx), %xmm0
movupd (%rcx), %xmm1
mulpd %xmm0, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movsd 0x10(%rdx), %xmm4
mulsd 0x10(%rcx), %xmm4
addsd %xmm0, %xmm4
movapd %xmm3, %xmm1
movapd %xmm4, %xmm0
mulsd %xmm4, %xmm0
addsd 0x66c8(%rip), %xmm0     # 0x16eb8
mulsd %xmm3, %xmm1
mulsd %xmm1, %xmm0
addsd 0x5830(%rip), %xmm0     # 0x16030
xorpd %xmm3, %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x10814
sqrtsd %xmm0, %xmm0
jmp 0x1083b
movapd %xmm3, 0x20(%rsp)
movapd %xmm4, 0x10(%rsp)
movapd %xmm2, (%rsp)
callq 0x3240
movapd (%rsp), %xmm2
movapd 0x10(%rsp), %xmm4
movapd 0x20(%rsp), %xmm3
mulsd %xmm3, %xmm4
subsd %xmm0, %xmm4
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
movupd (%r14), %xmm0
mulpd %xmm2, %xmm0
movapd %xmm4, %xmm1
unpcklpd %xmm4, %xmm1            # xmm1 = xmm1[0],xmm4[0]
movupd (%r15), %xmm2
mulpd %xmm1, %xmm2
addpd %xmm0, %xmm2
movupd %xmm2, (%rbx)
mulsd 0x10(%r15), %xmm4
mulsd 0x10(%r14), %xmm3
subsd %xmm3, %xmm4
movsd %xmm4, 0x10(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./Eigen/Eigen/src/Core/ProductEvaluators.h
// Function: Eigen::internal::Assignment<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Product<Eigen::Matrix<double, 4, 4, 0, 4, 4>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0>, Eigen::internal::assign_op<double, double>, Eigen::internal::Dense2Dense, void>::run(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::Product<Eigen::Matrix<double, 4, 4, 0, 4, 4>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0> const&, Eigen::internal::assign_op<double, double> const&)
static EIGEN_STRONG_INLINE
  void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
  {
    Index dstRows = src.rows();
    Index dstCols = src.cols();
    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
      dst.resize(dstRows, dstCols);
    // FIXME shall we handle nested_eval here?
    generic_product_impl<Lhs, Rhs>::evalTo(dst, src.lhs(), src.rhs());
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq 0x10(%rax), %rcx
cmpq $0x4, 0x8(%rdi)
jne 0x1212c
cmpq %rcx, 0x10(%rbx)
je 0x12153
testq %rcx, %rcx
js 0x121a1
movq %rcx, %rax
shrq $0x3d, %rax
jne 0x121c0
leaq (,%rcx,4), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x5216
movq 0x8(%r14), %rax
cmpq $0x4, 0x8(%rax)
jne 0x12182
movq (%r14), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq %rax, 0x8(%rsi)
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x121ee
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x5fc6(%rip), %rdi      # 0x1814f
leaq 0x604b(%rip), %rsi      # 0x181db
leaq 0x6662(%rip), %rcx      # 0x187f9
movl $0x61, %edx
callq 0x31a0
leaq 0x4505(%rip), %rdi      # 0x166ad
leaq 0x468d(%rip), %rsi      # 0x1683c
leaq 0x46af(%rip), %rcx      # 0x16865
movl $0x11d, %edx            # imm = 0x11D
callq 0x31a0
movl $0x8, %edi
callq 0x3130
movq 0xddef(%rip), %rcx      # 0x1ffc0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xddf1(%rip), %rsi      # 0x1ffd0
movq 0xddc2(%rip), %rdx      # 0x1ffa8
movq %rax, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./src/WaveObject.cpp
// Function: WaveObject::WaveObject(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
WaveObject::WaveObject(std::string driver_line, int current_time){
    set_time(current_time);
    extract_wave_info(driver_line);
    set_bounding_box();
    generate_waves(num_waves, random_seed);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xd727(%rip), %rax      # 0x1fca0
movq %rax, (%rdi)
movaps 0x495d(%rip), %xmm0     # 0x16ee0
movups %xmm0, 0x8(%rdi)
movl $0x0, 0x18(%rdi)
addq $0x20, %rdi
xorl %r15d, %r15d
movl $0xd8, %edx
xorl %esi, %esi
callq 0x3170
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0xf8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x100(%rbx)
movq %r15, 0x110(%rbx)
movq %rax, 0x118(%rbx)
movups %xmm0, 0x120(%rbx)
movq %r15, 0x130(%rbx)
movaps 0x4911(%rip), %xmm1     # 0x16ef0
movups %xmm1, 0x138(%rbx)
movups %xmm0, 0x148(%rbx)
movq %r15, 0x158(%rbx)
movq %rax, 0x160(%rbx)
movups %xmm0, 0x168(%rbx)
movq %r15, 0x178(%rbx)
movaps 0x48f0(%rip), %xmm1     # 0x16f00
movups %xmm1, 0x180(%rbx)
leaq 0xd6fa(%rip), %rax      # 0x1fd18
movq %rax, (%rbx)
movups %xmm0, 0x190(%rbx)
movups %xmm0, 0x1a0(%rbx)
movq %r15, 0x1b0(%rbx)
movaps 0x6283(%rip), %xmm1     # 0x188c0
movups %xmm1, 0x1b8(%rbx)
movabsq $0x100000001, %rax      # imm = 0x100000001
xorps %xmm1, %xmm1
cvtsi2sd %ebp, %xmm1
movq %rax, 0x1c8(%rbx)
movups %xmm0, 0x1d0(%rbx)
movsd %xmm1, 0x190(%rbx)
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x5760
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x12744
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x126ac
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32d0
movq %rbx, %rdi
callq 0x12c12
movl 0x1c8(%rbx), %esi
movl 0x1cc(%rbx), %edx
movq %rbx, %rdi
callq 0x12ce2
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x126f2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32d0
jmp 0x126f2
movq %rax, %r14
movq 0x1a0(%rbx), %rdi
testq %rdi, %rdi
je 0x1270d
movq 0x1b0(%rbx), %rsi
subq %rdi, %rsi
callq 0x32d0
movq 0x198(%rbx), %rdi
testq %rdi, %rdi
je 0x12723
movl $0x30, %esi
callq 0x32d0
movq $0x0, 0x198(%rbx)
movq %r14, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O1/IsaacLaw12[P]RayTracer/./src/WaveObject.cpp
// Function: WaveObject::set_bounding_box()
void WaveObject::set_bounding_box(){
    // Find the coordinates bounding the the wave surface
    Eigen::Vector3d min = first_corner;
    Eigen::Vector3d max = first_corner;
    find_min_max(min, max);

    bounding_box = std::make_unique<BoundingBox>(min, max);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq 0x1f0(%rdi), %rax
leaq 0x20(%rsp), %r15
movq %rax, 0x10(%r15)
movups 0x1e0(%rdi), %xmm0
movaps %xmm0, (%r15)
movq 0x1f0(%rdi), %rax
movq %rsp, %r12
movq %rax, 0x10(%r12)
movups 0x1e0(%rdi), %xmm0
movaps %xmm0, (%r12)
movq %r15, %rsi
movq %r12, %rdx
callq 0x136ca
movl $0x30, %edi
callq 0x32c0
movq %rax, %r14
movaps (%r15), %xmm0
leaq 0x60(%rsp), %rsi
movaps %xmm0, (%rsi)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsi)
movaps (%r12), %xmm0
leaq 0x40(%rsp), %rdx
movaps %xmm0, (%rdx)
movq 0x10(%r12), %rax
movq %rax, 0x10(%rdx)
movq %r14, %rdi
callq 0x6e20
movq 0x198(%rbx), %rdi
movq %r14, 0x198(%rbx)
testq %rdi, %rdi
je 0x12cbd
movl $0x30, %esi
callq 0x32d0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x30, %esi
movq %r14, %rdi
callq 0x32d0
movq %rbx, %rdi
callq 0x34b0
nop