LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x288, %rsp            # imm = 0x288
movq %rdx, 0x18(%rsp)
movq %rsi, %rax
movq 0x18(%rsp), %rsi
movq %rdi, 0x28(%rsp)
movq %rdi, %rcx
movq %rcx, 0x20(%rsp)
movq %rdi, 0x280(%rsp)
movq %rax, 0x278(%rsp)
movq %rsi, 0x270(%rsp)
leaq 0x68(%rsp), %rdi
movl $0x8, %edx
callq 0x4530
leaq 0x48(%rsp), %rdi
callq 0x4490
movq 0x28(%rsp), %rdi
movb $0x0, 0x47(%rsp)
callq 0x17cc0
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x4090
movq %rax, 0x10(%rsp)
jmp 0x17147
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x4440
movb %al, 0xf(%rsp)
jmp 0x17161
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x1716b
jmp 0x171c1
leaq 0x48(%rsp), %rdi
callq 0x4260
cmpq $0xa, %rax
jbe 0x171bc
movq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x17cd0
jmp 0x1718c
jmp 0x171bc
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x17b70
leaq 0x48(%rsp), %rdi
callq 0x4200
leaq 0x68(%rsp), %rdi
callq 0x40c0
jmp 0x171f8
jmp 0x17131
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x171d7
movq 0x28(%rsp), %rdi
callq 0x17b70
leaq 0x48(%rsp), %rdi
callq 0x4200
leaq 0x68(%rsp), %rdi
callq 0x40c0
movq 0x20(%rsp), %rax
addq $0x288, %rsp            # imm = 0x288
retq
movq 0x38(%rsp), %rdi
callq 0x45e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xe8, %rsp
movq %rcx, 0x20(%rsp)
movq %rdi, 0xe0(%rsp)
movl %esi, 0xdc(%rsp)
movl %edx, 0xd8(%rsp)
movq %rcx, 0xd0(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0xd8(%rsp), %eax
subl 0xdc(%rsp), %eax
movl %eax, 0xcc(%rsp)
cmpl $0x0, 0xcc(%rsp)
jne 0x1726b
jmp 0x17434
movq 0x20(%rsp), %rsi
cvtsi2sdl 0xcc(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x98(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x17a50
movq 0x28(%rsp), %rsi
movsd 0x10(%rsp), %xmm0
movq 0x18(%rsp), %rdx
leaq 0xb0(%rsp), %rdi
callq 0x17450
jmp 0x172b0
leaq 0x98(%rsp), %rdi
callq 0x116d0
movl $0x1, 0x88(%rsp)
movl 0x88(%rsp), %eax
movl 0xcc(%rsp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x17427
leaq 0x60(%rsp), %rdi
callq 0x17bd0
movl 0xdc(%rsp), %edx
movl 0x88(%rsp), %eax
movl %eax, %ecx
movl %edx, %eax
leal -0x1(%rax,%rcx), %eax
movl %eax, 0x60(%rsp)
cvtsi2sdl 0x88(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x17a50
jmp 0x17328
movsd 0x8(%rsp), %xmm0
movq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x17570
jmp 0x17344
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
movq %rsi, (%rsp)
callq 0x17bf0
movq (%rsp), %rdi
callq 0x116d0
leaq 0x30(%rsp), %rdi
callq 0x116d0
movq 0x28(%rsp), %rdi
movl 0x88(%rsp), %eax
movl 0xcc(%rsp), %ecx
subl %ecx, %eax
sete 0x80(%rsp)
addq $0x30, %rdi
leaq 0x60(%rsp), %rsi
callq 0x17c30
jmp 0x17397
leaq 0x60(%rsp), %rdi
callq 0x116b0
movl 0x88(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x88(%rsp)
jmp 0x172c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x116d0
jmp 0x1743c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x1740e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x116d0
leaq 0x60(%rsp), %rdi
callq 0x116b0
leaq 0xb0(%rsp), %rdi
callq 0x116d0
jmp 0x1743c
leaq 0xb0(%rsp), %rdi
callq 0x116d0
addq $0xe8, %rsp
retq
movq 0x90(%rsp), %rdi
callq 0x45e0
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdx, (%rsp)
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movsd %xmm0, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movb $0x0, 0x37(%rsp)
callq 0x179d0
movl $0x0, 0x30(%rsp)
cmpl $0x8, 0x30(%rsp)
jge 0x1753d
movq (%rsp), %rdi
movslq 0x30(%rsp), %rsi
callq 0x17ca0
movsd (%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
cmpl $0x4, 0x30(%rsp)
jne 0x174e0
movsd 0x28(%rsp), %xmm1
movsd 0x45b44(%rip), %xmm0    # 0x5d008
subsd %xmm0, %xmm1
divsd 0x40(%rsp), %xmm1
movsd 0x45b32(%rip), %xmm0    # 0x5d008
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
cmpl $0x4, 0x30(%rsp)
jg 0x174ee
cmpl $0x3, 0x30(%rsp)
jne 0x17500
movsd 0x28(%rsp), %xmm0
divsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x179e0
jmp 0x17511
jmp 0x17513
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x1748c
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x116d0
jmp 0x1755d
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x17553
movq 0x8(%rsp), %rdi
callq 0x116d0
movq 0x10(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x45e0
nopw (%rax,%rax)
// File: IsaacLaw12[P]RayTracer/./src/AnimatedObject.cpp
// Function: AnimatedObject::advance_frame()
void AnimatedObject::advance_frame(){
    // Load the next model in the directory if there are any left
    if (has_next_frame()){
        frame_setting this_transform = frame_steps[current_frame];
        Transformation frame_transform(this_transform.transform_floats);
        delete current_obj;
        current_obj = new Model(*original_obj);
        frame_transform.transform_object(current_obj);
        if (this_transform.set_as_new_base_model){
            delete original_obj;
            original_obj = new Model(*current_obj);
        }

        current_frame++;
    }
}

// Assembly:
subq $0x388, %rsp            # imm = 0x388
movq %rdi, 0x380(%rsp)
movq 0x380(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x178b0
testb $0x1, %al
jne 0x176ca
jmp 0x1789c
movq 0x20(%rsp), %rax
movq %rax, %rdi
addq $0x30, %rdi
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x17d40
movq %rax, %rsi
leaq 0x358(%rsp), %rdi
callq 0x17d60
leaq 0x360(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x17a50
jmp 0x17704
leaq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x45290
jmp 0x17715
leaq 0x38(%rsp), %rdi
callq 0x116d0
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x1773e
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x258, %edi            # imm = 0x258
callq 0x4370
movq %rax, 0x10(%rsp)
jmp 0x1774f
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rsi
callq 0x1ab00
jmp 0x17764
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x50(%rax)
movq 0x50(%rax), %rsi
leaq 0x50(%rsp), %rdi
callq 0x45580
jmp 0x17782
testb $0x1, 0x378(%rsp)
je 0x1785c
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x177af
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x258, %edi            # imm = 0x258
callq 0x4370
movq %rax, (%rsp)
jmp 0x177bf
movq (%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rsi
callq 0x1ab00
jmp 0x177d3
movq 0x20(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x48(%rax)
jmp 0x1785c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x1788d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x116d0
jmp 0x1788d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x17883
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl $0x258, %esi            # imm = 0x258
callq 0x4380
jmp 0x17883
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl $0x258, %esi            # imm = 0x258
callq 0x4380
jmp 0x17883
movq 0x20(%rsp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
leaq 0x50(%rsp), %rdi
callq 0x17db0
leaq 0x358(%rsp), %rdi
callq 0x116b0
jmp 0x1789c
leaq 0x50(%rsp), %rdi
callq 0x17db0
leaq 0x358(%rsp), %rdi
callq 0x116b0
jmp 0x178a4
addq $0x388, %rsp            # imm = 0x388
retq
movq 0x30(%rsp), %rdi
callq 0x45e0
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1b1a0
movq 0x8(%rsp), %rdi
callq 0x1b330
movq 0x8(%rsp), %rdx
movl $0x8, 0x1c(%rsp)
movq %rdx, %rsi
addq $0x198, %rsi            # imm = 0x198
addq $0x1b0, %rdx            # imm = 0x1B0
leaq 0x10(%rsp), %rdi
leaq 0x1c(%rsp), %rcx
callq 0x1dbc0
movq 0x8(%rsp), %rdi
addq $0x190, %rdi            # imm = 0x190
leaq 0x10(%rsp), %rsi
callq 0x1dc50
leaq 0x10(%rsp), %rdi
callq 0x1d360
movq 0x8(%rsp), %rdi
callq 0x1b5f0
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x198, %rdi            # imm = 0x198
callq 0x6d50
movl %eax, 0x6c(%rsp)
movslq 0x6c(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x1d9b0
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0x1d9c0
jmp 0x1b1f2
leaq 0x4f(%rsp), %rdi
callq 0x1da40
movq 0x18(%rsp), %rdi
addq $0x1e0, %rdi            # imm = 0x1E0
leaq 0x50(%rsp), %rsi
callq 0x1d430
jmp 0x1b214
movl $0x0, 0x38(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x1b0, %rdi            # imm = 0x1B0
callq 0x1da50
movq %rax, 0x10(%rsp)
jmp 0x1b23e
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq %rcx, %rax
jge 0x1b30d
movl $0x0, 0x34(%rsp)
cmpl $0x3, 0x34(%rsp)
jge 0x1b2fb
movq 0x18(%rsp), %rdi
addq $0x1b0, %rdi            # imm = 0x1B0
movslq 0x34(%rsp), %rsi
movslq 0x38(%rsp), %rdx
callq 0x1da60
movq %rax, (%rsp)
jmp 0x1b285
movq 0x18(%rsp), %rdi
movq (%rsp), %rax
movl (%rax), %eax
movl %eax, 0x30(%rsp)
addq $0x1e0, %rdi            # imm = 0x1E0
movl 0x30(%rsp), %eax
decl %eax
movslq %eax, %rsi
callq 0x1db30
movq %rax, %rdi
leaq 0x38(%rsp), %rsi
callq 0x1db50
jmp 0x1b2b8
jmp 0x1b2ba
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x1b259
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x4f(%rsp), %rdi
callq 0x1da40
jmp 0x1b31c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1d2f0
jmp 0x1b31c
jmp 0x1b2fd
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x1b21c
leaq 0x50(%rsp), %rdi
callq 0x1d2f0
addq $0x78, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x45e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movl %esi, 0xac(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rcx, 0x98(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, (%rsp)
movl $0x1, 0x94(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x11e20
movq (%rsp), %rdi
addq $0x1e0, %rdi            # imm = 0x1E0
movl 0xac(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x1db30
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x1e390
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rdi
callq 0x1e3c0
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x1e3f0
testb $0x1, %al
jne 0x1bacf
jmp 0x1bb87
leaq 0x68(%rsp), %rdi
callq 0x1e430
movq (%rsp), %rsi
movl (%rax), %eax
movl %eax, 0x5c(%rsp)
movl 0x5c(%rsp), %edx
leaq 0x40(%rsp), %rdi
callq 0x1b990
leaq 0x78(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x9d10
movq 0xa0(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0x1e440
movsd %xmm0, 0x38(%rsp)
movsd 0x414e8(%rip), %xmm0    # 0x5d008
ucomisd 0x38(%rsp), %xmm0
jb 0x1bb76
movsd 0x38(%rsp), %xmm0
movsd 0x465ba(%rip), %xmm1    # 0x620f0
ucomisd %xmm1, %xmm0
jb 0x1bb76
movq 0x98(%rsp), %rsi
leaq 0x20(%rsp), %rdi
leaq 0x78(%rsp), %rdx
callq 0x1e4b0
movq 0x98(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1e520
movl 0x94(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x94(%rsp)
jmp 0x1bb78
leaq 0x68(%rsp), %rdi
callq 0x1e550
jmp 0x1bab7
movq 0x98(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x9d50
movq 0x98(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x9e50
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x248, %rsp            # imm = 0x248
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x240(%rsp)
movq %rsi, 0x238(%rsp)
movl %edx, 0x234(%rsp)
movsd %xmm0, 0x228(%rsp)
movsd %xmm1, 0x220(%rsp)
movq 0x238(%rsp), %rax
movq %rax, (%rsp)
leaq 0x208(%rsp), %rdi
callq 0x11e20
leaq 0x1f0(%rsp), %rdi
callq 0x11e20
leaq 0x1d8(%rsp), %rdi
callq 0x11e20
movq (%rsp), %rsi
movl 0x234(%rsp), %edx
leaq 0x1c0(%rsp), %rdi
xorl %ecx, %ecx
callq 0x1bd80
leaq 0x208(%rsp), %rdi
leaq 0x1c0(%rsp), %rsi
callq 0x9d10
movq (%rsp), %rsi
movl 0x234(%rsp), %edx
leaq 0x1a8(%rsp), %rdi
movl $0x1, %ecx
callq 0x1bd80
leaq 0x1f0(%rsp), %rdi
leaq 0x1a8(%rsp), %rsi
callq 0x9d10
movq (%rsp), %rsi
movl 0x234(%rsp), %edx
leaq 0x190(%rsp), %rdi
movl $0x2, %ecx
callq 0x1bd80
leaq 0x1d8(%rsp), %rdi
leaq 0x190(%rsp), %rsi
callq 0x9d10
movsd 0x4133d(%rip), %xmm0    # 0x5d008
subsd 0x228(%rsp), %xmm0
subsd 0x220(%rsp), %xmm0
movsd %xmm0, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x208(%rsp), %rdx
callq 0xa310
leaq 0x40(%rsp), %rdi
leaq 0x228(%rsp), %rsi
leaq 0x1f0(%rsp), %rdx
callq 0xa310
leaq 0x98(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x1e570
leaq 0x18(%rsp), %rdi
leaq 0x220(%rsp), %rsi
leaq 0x1d8(%rsp), %rdx
callq 0xa310
leaq 0xf8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x1e5e0
movq 0x8(%rsp), %rdi
leaq 0xf8(%rsp), %rsi
callq 0x1e650
movq 0x10(%rsp), %rax
addq $0x248, %rsp            # imm = 0x248
retq
nop
// File: 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:
subq $0x188, %rsp            # imm = 0x188
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x180(%rsp)
movq %rsi, 0x178(%rsp)
movq %rdx, 0x170(%rsp)
movq %rcx, 0x168(%rsp)
movq %r8, 0x160(%rsp)
movq 0x178(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x148(%rsp), %rdi
callq 0x11e20
leaq 0x130(%rsp), %rdi
callq 0x11e20
movq 0x8(%rsp), %rdi
callq 0x430c0
movsd %xmm0, 0x128(%rsp)
movl $0xffffffff, 0xe4(%rsp) # imm = 0xFFFFFFFF
movq 0x170(%rsp), %rdi
callq 0x5cba0
movq %rax, %rdx
leaq 0xe8(%rsp), %rdi
leaq 0xe4(%rsp), %rsi
callq 0x12100
leaq 0x110(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0x1ec70
movq 0x8(%rsp), %rsi
movq 0x160(%rsp), %rcx
movsd 0x128(%rsp), %xmm1
leaq 0xc8(%rsp), %rdi
leaq 0x110(%rsp), %rdx
movsd 0x4051f(%rip), %xmm0    # 0x5d008
callq 0x42ef0
leaq 0x148(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x9d10
leaq 0xb0(%rsp), %rdi
callq 0x11e20
leaq 0x98(%rsp), %rdi
callq 0x11e20
movq 0x8(%rsp), %rdi
movq 0x168(%rsp), %rsi
leaq 0x148(%rsp), %rdx
leaq 0xb0(%rsp), %rcx
leaq 0x98(%rsp), %r8
callq 0x1cc00
movl $0xffffffff, 0x6c(%rsp) # imm = 0xFFFFFFFF
leaq 0x70(%rsp), %rdi
leaq 0x6c(%rsp), %rsi
leaq 0x148(%rsp), %rdx
callq 0x12100
leaq 0x148(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x121c0
movq 0x8(%rsp), %rsi
movsd 0x128(%rsp), %xmm0
leaq 0x50(%rsp), %rdi
leaq 0x148(%rsp), %rdx
leaq 0x98(%rsp), %rcx
movsd 0x40465(%rip), %xmm1    # 0x5d008
callq 0x42ef0
leaq 0x130(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x9d10
leaq 0x38(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0xa4f0
leaq 0x20(%rsp), %rdi
leaq 0x130(%rsp), %rsi
callq 0xa4f0
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x5ca90
movq 0x18(%rsp), %rax
addq $0x188, %rsp            # imm = 0x188
retq
nop
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movl %edx, 0x84(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x30(%rsp)
movb $0x0, 0x83(%rsp)
callq 0x31960
movq 0x30(%rsp), %rax
movq (%rax), %rdi
callq 0x3f610
movq %rax, 0x38(%rsp)
jmp 0x302e9
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x7c(%rsp)
movq (%rax), %rdi
callq 0x3f610
movq %rax, 0x18(%rsp)
jmp 0x30308
movq 0x18(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x68(%rsp)
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
cmpl 0x7c(%rsp), %eax
jge 0x30420
movl $0x0, 0x60(%rsp)
movl 0x60(%rsp), %eax
cmpl 0x68(%rsp), %eax
jge 0x3040a
movl 0x7c(%rsp), %eax
movl 0x64(%rsp), %ecx
subl %ecx, %eax
movl %eax, 0x58(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x84(%rsp), %rsi
callq 0x13cb0
movq %rax, 0x10(%rsp)
jmp 0x30367
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x5c(%rsp)
movl 0x68(%rsp), %eax
movl 0x60(%rsp), %ecx
subl %ecx, %eax
movl %eax, 0x50(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x84(%rsp), %rsi
callq 0x13cb0
movq %rax, 0x8(%rsp)
jmp 0x30399
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x54(%rsp)
movl 0x64(%rsp), %esi
movl 0x60(%rsp), %edx
movl 0x5c(%rsp), %ecx
movl 0x54(%rsp), %r8d
callq 0x304e0
movq 0x20(%rsp), %rdi
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
leaq 0x40(%rsp), %rsi
callq 0x319d0
jmp 0x303da
jmp 0x303dc
movl 0x84(%rsp), %eax
addl 0x60(%rsp), %eax
movl %eax, 0x60(%rsp)
jmp 0x30332
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
callq 0x148a0
jmp 0x30449
jmp 0x3040c
movl 0x84(%rsp), %eax
addl 0x64(%rsp), %eax
movl %eax, 0x64(%rsp)
jmp 0x3031c
movb $0x1, 0x83(%rsp)
testb $0x1, 0x83(%rsp)
jne 0x3043c
movq 0x20(%rsp), %rdi
callq 0x148a0
movq 0x28(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x45e0
nopw %cs:(%rax,%rax)
// File: IsaacLaw12[P]RayTracer/./src/RenderImage.cpp
// Function: RenderImage::build_image_tile(int, int, int, int)
image_tile RenderImage::build_image_tile(int x, int y, int x_len, int y_len){
    image_tile result;
    result.x = x;
    result.y = y;
    result.x_len = x_len;
    result.y_len = y_len;
    return result;
}

// Assembly:
movq %rdi, -0x18(%rsp)
movl %esi, -0x1c(%rsp)
movl %edx, -0x20(%rsp)
movl %ecx, -0x24(%rsp)
movl %r8d, -0x28(%rsp)
movl -0x1c(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0x20(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0x24(%rsp), %eax
movl %eax, -0x8(%rsp)
movl -0x28(%rsp), %eax
movl %eax, -0x4(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rdx
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movb $0x0, 0x2f(%rsp)
movb 0x2f(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x30556
jmp 0x305fe
movq (%rsp), %rdi
addq $0x60, %rdi
callq 0x31a00
movq (%rsp), %rdi
xorl %r8d, %r8d
movl %r8d, %esi
movl %r8d, %edx
movl %r8d, %ecx
callq 0x304e0
movq (%rsp), %rdi
movq %rax, 0x1c(%rsp)
movq %rdx, 0x24(%rsp)
addq $0x10, %rdi
callq 0x31a30
testb $0x1, %al
jne 0x305c0
movq (%rsp), %rdi
addq $0x10, %rdi
callq 0x31a50
movq (%rsp), %rdi
movq (%rax), %rcx
movq %rcx, 0x1c(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x24(%rsp)
addq $0x10, %rdi
callq 0x31a60
jmp 0x305c5
movb $0x1, 0x2f(%rsp)
movq (%rsp), %rdi
addq $0x60, %rdi
callq 0x31a70
movq (%rsp), %rdi
movq 0x1c(%rsp), %rax
movq %rax, 0xc(%rsp)
movq 0x24(%rsp), %rax
movq %rax, 0x14(%rsp)
movq 0xc(%rsp), %rsi
movq 0x14(%rsp), %rdx
callq 0x30610
jmp 0x30547
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movl %r8d, 0x44(%rsp)
movq %r9, 0x38(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq (%rax), %rdi
callq 0x3f5f0
movq %rax, %rdi
callq 0x31ae0
cmpq $0x0, %rax
jne 0x30aa7
jmp 0x30b27
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x3f5f0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x31b00
movq (%rax), %rax
movq %rax, 0x30(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x11e20
movq 0x10(%rsp), %rdi
movq 0x58(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x18(%rsp), %rcx
callq 0x30b30
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x58(%rsp), %rsi
movq 0x38(%rsp), %rax
movsd (%rax), %xmm0
movq 0x30(%rsp), %rdx
movq 0x50(%rsp), %r8
movq 0x48(%rsp), %r9
movl 0x44(%rsp), %eax
leaq 0x18(%rsp), %rcx
movl %eax, (%rsp)
callq 0x30c60
addq $0x68, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x70(%rsp), %rax
movq %rax, (%rsp)
movsd 0x360ff(%rip), %xmm0    # 0x66c58
movsd %xmm0, 0x50(%rsp)
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x48(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x11e20
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x3f5f0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x31b20
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x31b50
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x31b80
testb $0x1, %al
jne 0x30bbb
jmp 0x30c47
leaq 0x20(%rsp), %rdi
callq 0x31bc0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq (%rdi), %rax
leaq 0x30(%rsp), %rdx
callq *0x10(%rax)
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm1
movsd 0x50(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x30bfc
jmp 0x30c38
movsd 0x8(%rsp), %xmm1
movsd 0x48(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x30c36
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
movq 0x10(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, (%rax)
movq 0x58(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x9e50
jmp 0x30c38
leaq 0x20(%rsp), %rdi
callq 0x31bd0
jmp 0x30ba3
movsd 0x48(%rsp), %xmm0
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x148, %rsp            # imm = 0x148
movq %rdx, 0x8(%rsp)
movq %rdi, 0x138(%rsp)
movq %rsi, 0x130(%rsp)
movq %rdx, 0x128(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x108(%rsp), %rdi
callq 0x11e20
movq 0x130(%rsp), %rsi
leaq 0xd0(%rsp), %rdi
callq 0x11db0
movq 0x8(%rsp), %rdx
leaq 0xe8(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x9e80
leaq 0xe8(%rsp), %rdi
callq 0x32400
movsd %xmm0, 0x100(%rsp)
movq 0x130(%rsp), %rsi
leaq 0x88(%rsp), %rdi
callq 0x11db0
movq 0x8(%rsp), %rdx
leaq 0xa0(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x9e80
leaq 0xb8(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x9ef0
movq 0x8(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0xa4f0
leaq 0x20(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0xa4f0
leaq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x5ca90
movq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x120(%rsp), %rdx
leaq 0x108(%rsp), %rcx
callq 0x30b30
movq 0x10(%rsp), %rax
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
ucomisd 0x8(%rax), %xmm0
jne 0x31897
jp 0x31897
jmp 0x318ac
movsd 0x100(%rsp), %xmm1
movsd 0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x318b6
movb $0x1, 0x147(%rsp)
jmp 0x318be
movb $0x0, 0x147(%rsp)
movb 0x147(%rsp), %al
andb $0x1, %al
addq $0x148, %rsp            # imm = 0x148
retq
nop
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x1b8, %rax            # imm = 0x1B8
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rdi
callq 0x5cb90
movq 0x8(%rsp), %rsi
movq %rax, %rdx
leaq 0x40(%rsp), %rdi
callq 0x9e80
movq 0x60(%rsp), %rdi
callq 0x5cba0
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
callq 0x3ce10
movq 0x18(%rsp), %rax
movsd %xmm0, 0x58(%rsp)
addq $0x1b8, %rax            # imm = 0x1B8
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rdi
callq 0x5cb90
movq 0x10(%rsp), %rsi
movq %rax, %rdx
leaq 0x20(%rsp), %rdi
callq 0x9e80
leaq 0x20(%rsp), %rdi
callq 0x32400
movq 0x18(%rsp), %rax
movsd %xmm0, 0x38(%rsp)
movsd 0x190(%rax), %xmm0
mulsd 0x190(%rax), %xmm0
movsd 0x38(%rsp), %xmm1
movsd 0x38(%rsp), %xmm3
movsd 0x58(%rsp), %xmm2
mulsd 0x58(%rsp), %xmm2
movq %xmm2, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x3cd51
movb $0x1, 0x77(%rsp)
jmp 0x3cd56
movb $0x0, 0x77(%rsp)
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: IsaacLaw12[P]RayTracer/./src/Scene.cpp
// Function: Scene::advance_frame()
bool Scene::advance_frame(){
    // Call to make the necessary changes to the scene before rendering the next frame
    if (has_next_frame()){
        std::cout << "current frame: " << current_frame << " out of: " << number_frames << "\n";
        render_objects.clear();
        for (auto ao:animated_objects){
            ao->advance_frame();
            render_objects.push_back(ao->get_object());
        }
        for (auto ss:scene_objects){
            render_objects.push_back(ss);
        }
        current_frame++;
        return true;
    }
    return false;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3f8f0
testb $0x1, %al
jne 0x3f741
jmp 0x3f8d3
movq 0x5b878(%rip), %rdi     # 0x9afc0
leaq 0x2c820(%rip), %rsi     # 0x6bf6f
callq 0x4360
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x234(%rax), %esi
callq 0x45c0
movq %rax, %rdi
leaq 0x2c80e(%rip), %rsi     # 0x6bf7f
callq 0x4360
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x230(%rax), %esi
callq 0x45c0
movq %rax, %rdi
leaq 0x2266a(%rip), %rsi     # 0x61dfd
callq 0x4360
movq 0x8(%rsp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
callq 0x40e90
movq 0x8(%rsp), %rax
addq $0x1e8, %rax            # imm = 0x1E8
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x40eb0
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x40ee0
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x40f10
testb $0x1, %al
jne 0x3f7ec
jmp 0x3f841
leaq 0x48(%rsp), %rdi
callq 0x40f50
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x1d0, %rax            # imm = 0x1D0
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%rsp), %rdi
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x40f60
leaq 0x48(%rsp), %rdi
callq 0x40f90
jmp 0x3f7d7
movq 0x8(%rsp), %rax
addq $0x1b8, %rax            # imm = 0x1B8
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x31b20
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x31b50
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x31b80
testb $0x1, %al
jne 0x3f884
jmp 0x3f8b8
leaq 0x20(%rsp), %rdi
callq 0x31bc0
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x10(%rsp)
addq $0x1d0, %rdi            # imm = 0x1D0
leaq 0x10(%rsp), %rsi
callq 0x40fb0
leaq 0x20(%rsp), %rdi
callq 0x31bd0
jmp 0x3f86f
movq 0x8(%rsp), %rax
movl 0x234(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x234(%rax)
movb $0x1, 0x67(%rsp)
jmp 0x3f8d8
movb $0x0, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x258, %edi            # imm = 0x258
callq 0x4370
movq 0x10(%rsp), %rsi
movq %rax, 0x18(%rsp)
movb $0x1, 0x33(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x4130
jmp 0x3f9e2
movq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x1a1b0
jmp 0x3f9f3
movb $0x0, 0x33(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x4200
movq 0x18(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0x1be10
testb $0x1, %al
jne 0x3fa1f
jmp 0x3fad8
movl $0x58, %edi
callq 0x4370
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x60(%rsp), %rsi
callq 0x16bc0
jmp 0x3fa3f
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl 0x234(%rax), %esi
callq 0x17650
movq 0x8(%rsp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
leaq 0x28(%rsp), %rsi
callq 0x41020
jmp 0x3faf8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x3faa0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x4200
testb $0x1, 0x33(%rsp)
jne 0x3faa9
jmp 0x3fab8
movq 0x18(%rsp), %rdi
movl $0x258, %esi            # imm = 0x258
callq 0x4380
jmp 0x3fafd
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl $0x58, %esi
callq 0x4380
jmp 0x3fafd
movq 0x8(%rsp), %rdi
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
addq $0x1b8, %rdi            # imm = 0x1B8
leaq 0x20(%rsp), %rsi
callq 0x40fb0
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x45e0
nopw (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x1d0, %edi            # imm = 0x1D0
callq 0x4370
movq 0x18(%rsp), %rsi
movq %rax, 0x20(%rsp)
movb $0x1, 0x43(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x4130
jmp 0x3fb5b
movq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x3bc10
jmp 0x3fb6c
movb $0x0, 0x43(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x4200
movq 0x20(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x3cd70
testb $0x1, %al
jne 0x3fb98
jmp 0x3fc5e
movl $0x78, %edi
callq 0x4370
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rsi
callq 0x55ad0
jmp 0x3fbb9
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl 0x234(%rax), %esi
callq 0x17650
movq 0x10(%rsp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x41090
jmp 0x3fc7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x3fc25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x4200
testb $0x1, 0x43(%rsp)
jne 0x3fc2e
jmp 0x3fc3d
movq 0x20(%rsp), %rdi
movl $0x1d0, %esi            # imm = 0x1D0
callq 0x4380
jmp 0x3fc86
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
movl $0x78, %esi
callq 0x4380
jmp 0x3fc86
movq 0x10(%rsp), %rdi
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
addq $0x1b8, %rdi            # imm = 0x1B8
leaq 0x28(%rsp), %rsi
callq 0x40fb0
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x45e0
// File: 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:
subq $0x248, %rsp            # imm = 0x248
movq %rsi, 0x28(%rsp)
movq %rdi, 0x240(%rsp)
movq %rsi, 0x238(%rsp)
movq 0x240(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x11e40
movq 0x28(%rsp), %rsi
movl %eax, %edx
leaq 0xb0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x4520
leaq 0x90(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x4490
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x4450
movq %rax, 0x40(%rsp)
jmp 0x3fd09
movq 0x40(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x42e0
movq %rax, 0x18(%rsp)
jmp 0x3fd22
movq 0x18(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x42e0
movq %rax, 0x10(%rsp)
jmp 0x3fd3b
movq 0x10(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x42e0
jmp 0x3fd4c
movq 0x20(%rsp), %rsi
addq $0x218, %rsi            # imm = 0x218
leaq 0x48(%rsp), %rdi
leaq 0x88(%rsp), %rdx
callq 0x11f20
jmp 0x3fd6c
leaq 0x48(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x11f60
movq %rax, 0x8(%rsp)
jmp 0x3fd85
movq 0x8(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x11f60
jmp 0x3fd96
leaq 0x48(%rsp), %rdi
callq 0x120e0
leaq 0x90(%rsp), %rdi
callq 0x4200
leaq 0xb0(%rsp), %rdi
callq 0x4290
addq $0x248, %rsp            # imm = 0x248
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x3fdea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x120e0
leaq 0x90(%rsp), %rdi
callq 0x4200
leaq 0xb0(%rsp), %rdi
callq 0x4290
movq 0x70(%rsp), %rdi
callq 0x45e0
nop
// File: 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:
subq $0x28, %rsp
movq %rsi, (%rsp)
movq %rdi, %rax
movq (%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq %rax, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movb $0x1, 0x17(%rsp)
callq 0x4260
cmpq $0x0, %rax
jne 0x3ff35
movb $0x0, 0x17(%rsp)
jmp 0x3ff76
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4680
movsbl (%rax), %edi
callq 0x4050
cmpl $0x0, %eax
je 0x3ff57
movb $0x0, 0x17(%rsp)
jmp 0x3ff74
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4680
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x3ff72
movb $0x0, 0x17(%rsp)
jmp 0x3ff74
jmp 0x3ff76
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %rdx, 0x110(%rsp)
movq %rcx, 0x108(%rsp)
movsd %xmm0, 0x100(%rsp)
movsd %xmm1, 0xf8(%rsp)
movsd 0x100(%rsp), %xmm0
divsd 0xf8(%rsp), %xmm0
movsd %xmm0, 0xf0(%rsp)
movsd 0xf0(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0xe8(%rsp)
movq 0x110(%rsp), %rdi
movq 0x108(%rsp), %rsi
callq 0x1e440
movsd %xmm0, 0xe0(%rsp)
movsd 0xf0(%rsp), %xmm0
mulsd 0xf0(%rsp), %xmm0
movsd 0xe0(%rsp), %xmm1
movsd 0xe0(%rsp), %xmm2
mulsd %xmm2, %xmm1
movsd 0x1ae98(%rip), %xmm2    # 0x5de60
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd 0x1a030(%rip), %xmm1    # 0x5d008
addsd %xmm1, %xmm0
movsd %xmm0, 0xd8(%rsp)
movsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xe0(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0xd8(%rsp), %xmm0
callq 0x42c0
movsd (%rsp), %xmm2
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0xd0(%rsp)
movq 0x110(%rsp), %rdx
leaq 0x48(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0xa310
movq 0x108(%rsp), %rdx
leaq 0x20(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0xa310
leaq 0x70(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x1e570
movq 0x10(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x43c10
movq 0x18(%rsp), %rax
addq $0x128, %rsp            # imm = 0x128
retq
nopw (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rsi, (%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1d060
movq 0x18(%rsp), %rdi
leaq 0x4be77(%rip), %rax     # 0x9ad08
movq %rax, (%rdi)
movq $0x0, 0x190(%rdi)
addq $0x198, %rdi            # imm = 0x198
movq %rdi, 0x8(%rsp)
callq 0x508d0
movq 0x18(%rsp), %rdi
addq $0x1a0, %rdi            # imm = 0x1A0
movq %rdi, 0x10(%rsp)
callq 0x50900
movq 0x18(%rsp), %rdi
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x1b8(%rdi)
movabsq $0x3fe0000000000000, %rax # imm = 0x3FE0000000000000
movq %rax, 0x1c0(%rdi)
movl $0x1, 0x1c8(%rdi)
movl $0x1, 0x1cc(%rdi)
movq $0x0, 0x1d0(%rdi)
movq $0x0, 0x1d8(%rdi)
addq $0x1e0, %rdi            # imm = 0x1E0
callq 0x11e20
jmp 0x4ef25
movq 0x18(%rsp), %rdi
addq $0x1f8, %rdi            # imm = 0x1F8
callq 0x11e20
jmp 0x4ef38
movq 0x18(%rsp), %rdi
addq $0x210, %rdi            # imm = 0x210
callq 0x11e20
jmp 0x4ef4b
movq 0x18(%rsp), %rdi
addq $0x228, %rdi            # imm = 0x228
callq 0x11e20
jmp 0x4ef5e
movq 0x18(%rsp), %rdi
addq $0x240, %rdi            # imm = 0x240
callq 0x11e20
jmp 0x4ef71
movq 0x18(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0x4f030
jmp 0x4ef81
movq (%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x4130
jmp 0x4ef91
movq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x4f050
jmp 0x4efa2
leaq 0x20(%rsp), %rdi
callq 0x4200
movq 0x18(%rsp), %rdi
callq 0x4f640
jmp 0x4efb8
movq 0x18(%rsp), %rdi
movl 0x1c8(%rdi), %esi
movl 0x1cc(%rdi), %edx
callq 0x4f6d0
jmp 0x4efd0
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x4effd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x4200
movq 0x10(%rsp), %rdi
callq 0x50910
movq 0x8(%rsp), %rdi
callq 0x50970
movq 0x18(%rsp), %rdi
callq 0x1f000
movq 0x48(%rsp), %rdi
callq 0x45e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rsi
movq %rsi, (%rsp)
addq $0x1e0, %rsi            # imm = 0x1E0
leaq 0x28(%rsp), %rdi
callq 0xa4f0
movq (%rsp), %rsi
addq $0x1e0, %rsi            # imm = 0x1E0
leaq 0x10(%rsp), %rdi
callq 0xa4f0
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x50350
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x50ab0
movq (%rsp), %rdi
addq $0x198, %rdi            # imm = 0x198
leaq 0x8(%rsp), %rsi
callq 0x50b60
leaq 0x8(%rsp), %rdi
callq 0x50970
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)