LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/IsaacLaw12[P]RayTracer/./src/Image.cpp
// Function: Image::apply_focus_blur()
void Image::apply_focus_blur(){
    post_red_pixels = Eigen::MatrixXd(red_pixels);
    post_green_pixels = Eigen::MatrixXd(green_pixels);
    post_blue_pixels = Eigen::MatrixXd(blue_pixels);

    for (int x=0; x<image_width; x++){
        for (int y=0; y<image_height; y++){
            int blur = get_pixel_blur(x, y);
            blur_pixel(x, y, blur);
        }
    }
    red_pixels = Eigen::MatrixXd(post_red_pixels);
    green_pixels = Eigen::MatrixXd(post_green_pixels);
    blue_pixels = Eigen::MatrixXd(post_blue_pixels);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x4c18
leaq 0x60(%rbx), %r14
movq (%r15), %rax
movq 0x60(%rbx), %rdi
movq %rdi, (%r15)
movq %rax, 0x60(%rbx)
movups 0x68(%rbx), %xmm0
movups 0x8(%r15), %xmm1
movups %xmm0, 0x8(%r15)
movups %xmm1, 0x68(%rbx)
callq 0x3300
leaq 0x30(%rbx), %rsi
movq %rsp, %r12
movq %r12, %rdi
callq 0x4c18
leaq 0x78(%rbx), %r15
movq (%r12), %rax
movq 0x78(%rbx), %rdi
movq %rdi, (%r12)
movq %rax, 0x78(%rbx)
movups 0x8(%r12), %xmm0
movups 0x80(%rbx), %xmm1
movups %xmm1, 0x8(%r12)
movups %xmm0, 0x80(%rbx)
callq 0x3300
leaq 0x48(%rbx), %rsi
movq %rsp, %r13
movq %r13, %rdi
callq 0x4c18
leaq 0x90(%rbx), %r12
movq (%r13), %rax
movq 0x90(%rbx), %rdi
movq %rdi, (%r13)
movq %rax, 0x90(%rbx)
movups 0x8(%r13), %xmm0
movups 0x98(%rbx), %xmm1
movups %xmm1, 0x8(%r13)
movups %xmm0, 0x98(%rbx)
callq 0x3300
xorl %ebp, %ebp
cmpl 0x10(%rbx), %ebp
jge 0x3efb
xorl %r13d, %r13d
cmpl 0x14(%rbx), %r13d
jge 0x3ef7
movq %rbx, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x426a
movq %rbx, %rdi
movl %ebp, %esi
movl %r13d, %edx
movl %eax, %ecx
callq 0x42d4
incl %r13d
jmp 0x3ed0
incl %ebp
jmp 0x3ec8
movq %rsp, %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x4c18
movq (%r13), %rax
movq 0x18(%rbx), %rdi
movq %rdi, (%r13)
movq %rax, 0x18(%rbx)
movups 0x20(%rbx), %xmm0
movups 0x8(%r13), %xmm1
movups %xmm0, 0x8(%r13)
movups %xmm1, 0x20(%rbx)
callq 0x3300
movq %rsp, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x4c18
movq (%r14), %rax
movq 0x30(%rbx), %rdi
movq %rdi, (%r14)
movq %rax, 0x30(%rbx)
movups 0x8(%r14), %xmm0
movups 0x38(%rbx), %xmm1
movups %xmm1, 0x8(%r14)
movups %xmm0, 0x38(%rbx)
callq 0x3300
movq %rsp, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x4c18
movq (%r14), %rax
movq 0x48(%rbx), %rdi
movq %rdi, (%r14)
movq %rax, 0x48(%rbx)
movups 0x8(%r14), %xmm0
movups 0x50(%rbx), %xmm1
movups %xmm1, 0x8(%r14)
movups %xmm0, 0x50(%rbx)
callq 0x3300
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/IsaacLaw12[P]RayTracer/./src/Image.cpp
// Function: Image::convert_255(double)
int Image::convert_255(double value){
    // Convert a 0-1 double value to 0-255 int value
    if (value > 1)
        value = 1;
    if (value < 0)
        value = 0;
    value = value * 255.0;
    return int(value);
}

// Assembly:
movsd 0x13e0c(%rip), %xmm1    # 0x18030
minsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
maxsd %xmm1, %xmm0
mulsd 0x13e00(%rip), %xmm0    # 0x18038
cvttsd2si %xmm0, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/IsaacLaw12[P]RayTracer/./src/Image.cpp
// Function: Image::get_pixel_blur(int, int)
int Image::get_pixel_blur(int index_x, int index_y){
    // Calculates how close to the focal center this pixel was found. Blur progressively from there
    // Returns blur_number, which represents the number of pixels out from center to average
    double blur_number = 0;
    double t_value = t_values(index_x, index_y);
    double dist_from_center = abs(focus_distance - t_value);
    if (dist_from_center > focus_length){
        double dist_into_blur = dist_from_center - focus_length;
        blur_number = dist_into_blur * focus_strength / 100;
        int max_blur = image_width / 50;
        if (blur_number > max_blur)
            blur_number = max_blur;
    }
    return (int) blur_number;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0xa8, %rdi
movslq %esi, %rsi
movslq %edx, %rdx
callq 0x4544
cvtsi2sdl 0xc0(%rbx), %xmm0
subsd (%rax), %xmm0
andpd 0x13d8c(%rip), %xmm0    # 0x18020
cvtsi2sdl 0xc8(%rbx), %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
jbe 0x42d1
cvtsi2sdl 0xc4(%rbx), %xmm2
subsd %xmm1, %xmm0
mulsd %xmm0, %xmm2
divsd 0x13d84(%rip), %xmm2    # 0x18040
movl 0x10(%rbx), %eax
pushq $0x32
popq %rcx
cltd
idivl %ecx
cvtsi2sd %eax, %xmm0
minsd %xmm2, %xmm0
cvttsd2si %xmm0, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/IsaacLaw12[P]RayTracer/./src/Image.cpp
// Function: Image::get_anti_alias_val(int, int, int, Eigen::Matrix<double, -1, -1, 0, -1, -1>*)
double Image::get_anti_alias_val(int index_x, int index_y, int scale, Eigen::MatrixXd* cur_color){
    double pixel_total = 0;
    int count = 0;
    for (int x=index_x*scale; x<(index_x+1)*scale; x++){
        for (int y=index_y*scale; y<(index_y+1)*scale; y++){
           pixel_total += (*cur_color)(x, y);
           count++;
        }
    }
    return pixel_total / count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movl %ecx, %eax
imull %esi, %eax
incl %esi
imull %ecx, %esi
movl %ecx, %edi
imull %edx, %edi
incl %edx
imull %ecx, %edx
movslq %edi, %rcx
movq %rcx, 0x10(%rsp)
movslq %edx, %r13
movslq %eax, %r14
movslq %esi, %r12
xorl %ebp, %ebp
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
cmpq %r12, %r14
jge 0x4527
movq 0x10(%rsp), %r15
cmpq %r13, %r15
jge 0x4522
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4544
movsd 0x8(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
incl %ebp
incq %r15
jmp 0x44f8
incq %r14
jmp 0x44ee
cvtsi2sd %ebp, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/IsaacLaw12[P]RayTracer/./Eigen/Eigen/src/Core/PlainObjectBase.h
// Function: Eigen::internal::conservative_resize_like_impl<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, false>::run(Eigen::DenseBase<Eigen::Matrix<double, -1, -1, 0, -1, -1>>&, long, long)
static void run(DenseBase<Derived>& _this, Index rows, Index cols)
  {
    if (_this.rows() == rows && _this.cols() == cols) return;
    EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)

    if ( ( Derived::IsRowMajor && _this.cols() == cols) || // row-major and we change only the number of rows
         (!Derived::IsRowMajor && _this.rows() == rows) )  // column-major and we change only the number of columns
    {
      internal::check_rows_cols_for_overflow<Derived::MaxSizeAtCompileTime>::run(rows, cols);
      _this.derived().m_storage.conservativeResize(rows*cols,rows,cols);
    }
    else
    {
      // The storage order does not allow us to use reallocation.
      typename Derived::PlainObject tmp(rows,cols);
      const Index common_rows = numext::mini(rows, _this.rows());
      const Index common_cols = numext::mini(cols, _this.cols());
      tmp.block(0,0,common_rows,common_cols) = _this.block(0,0,common_rows,common_cols);
      _this.derived().swap(tmp);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
cmpq %rsi, 0x8(%rdi)
jne 0x4693
movq %rdx, %r14
cmpq %rdx, 0x10(%rbx)
je 0x472f
movq %rsi, %r15
testq %rsi, %rsi
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x4672
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
idivq %r14
cmpq %r15, %rax
jge 0x4672
callq 0x47bc
movq %r14, %rsi
imulq %r15, %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x4754
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %r14
leaq 0x20(%rsp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x4784
movq (%r14), %r14
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
cmpq %r14, %rax
cmovlq %rax, %r14
movq (%r15), %r15
cmpq %r15, %rcx
cmovlq %rcx, %r15
leaq 0x68(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r8
movq %r15, %r9
callq 0x486c
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r8
movq %r15, %r9
callq 0x486c
leaq 0x30(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x4970
movq (%rbx), %rdi
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
movq %rdi, 0x8(%rsp)
movups 0x10(%rsp), %xmm0
movups 0x8(%rbx), %xmm1
movups %xmm0, 0x8(%rbx)
movups %xmm1, 0x10(%rsp)
callq 0x3300
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x473e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x3300
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/IsaacLaw12[P]RayTracer/./Eigen/Eigen/src/Core/util/Memory.h
// Function: double* Eigen::internal::conditional_aligned_realloc_new_auto<double, true>(double*, unsigned long, unsigned long)
inline T* conditional_aligned_realloc_new_auto(T* pts, std::size_t new_size, std::size_t old_size)
{
  check_size_for_overflow<T>(new_size);
  check_size_for_overflow<T>(old_size);
  if(NumTraits<T>::RequireInitialization && (new_size < old_size))
    destruct_elements_of_array(pts+new_size, old_size-new_size);
  T *result = reinterpret_cast<T*>(conditional_aligned_realloc<Align>(reinterpret_cast<void*>(pts), sizeof(T)*new_size, sizeof(T)*old_size));
  if(NumTraits<T>::RequireInitialization && (new_size > old_size))
  {
    EIGEN_TRY
    {
      construct_elements_of_array(result+old_size, new_size-old_size);
    }
    EIGEN_CATCH(...)
    {
      conditional_aligned_free<Align>(result);
      EIGEN_THROW;
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movabsq $0x1fffffffffffffff, %r12 # imm = 0x1FFFFFFFFFFFFFFF
movq %rsi, %rax
shrq $0x3d, %rax
je 0x4812
callq 0x47bc
cmpq %r12, %rbx
jbe 0x481c
callq 0x47bc
shlq $0x3, %r14
shlq $0x3, %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x483d
// File: /workspace/github_cpp_makefile_star2_O2/IsaacLaw12[P]RayTracer/./Eigen/Eigen/src/Core/util/Memory.h
// Function: Eigen::internal::aligned_realloc(void*, unsigned long, unsigned long)
inline void* aligned_realloc(void *ptr, std::size_t new_size, std::size_t old_size)
{
  EIGEN_UNUSED_VARIABLE(old_size);

  void *result;
#if (EIGEN_DEFAULT_ALIGN_BYTES==0) || EIGEN_MALLOC_ALREADY_ALIGNED
  result = std::realloc(ptr,new_size);
#else
  result = handmade_aligned_realloc(ptr,new_size,old_size);
#endif

  if (!result && new_size)
    throw_std_bad_alloc();

  return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
callq 0x3430
movq %rax, %rbx
testq %rax, %rax
setne %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x4861
callq 0x47bc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/IsaacLaw12[P]RayTracer/./src/Camera.cpp
// Function: Camera::get_pixel_position(int, int)
Eigen::Vector3d Camera::get_pixel_position(int x_pixel, int y_pixel){

    double px = x_pixel / (pixel_width-1.0) * (near_bounding_right - near_bounding_left) + near_bounding_left;
    double py = y_pixel / (pixel_height-1.0) * (near_bounding_top - near_bounding_bottom) + near_bounding_bottom;

    Eigen::Vector3d pixpt = eye + (-1 * focal_length * z_axis) + (px * x_axis) + (py * y_axis);
    return pixpt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %r14
movq %rdi, %rbx
cvtsi2sd %edx, %xmm0
cvtsi2sdl (%rsi), %xmm1
movsd 0x138b9(%rip), %xmm2    # 0x18a30
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd 0xa8(%rsi), %xmm1
movsd 0xb0(%rsi), %xmm3
subsd %xmm1, %xmm3
mulsd %xmm0, %xmm3
addsd %xmm1, %xmm3
leaq 0x20(%rsp), %r12
movsd %xmm3, (%r12)
cvtsi2sd %ecx, %xmm0
cvtsi2sdl 0x4(%rsi), %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd 0xb8(%rsi), %xmm1
movsd 0xc0(%rsi), %xmm2
subsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
leaq 0x10(%rsp), %rax
movsd %xmm2, (%rax)
movsd 0x98(%rsi), %xmm0
xorps 0x13855(%rip), %xmm0    # 0x18a40
leaq 0x8(%rsi), %rbp
leaq 0x18(%rsp), %rsi
movlps %xmm0, (%rsi)
leaq 0x80(%r14), %rdx
leaq 0x78(%rsp), %r13
movq %r13, %rdi
callq 0x5423
movsd 0x10(%r13), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x18(%r13), %r15
leaq 0x50(%r14), %rdx
leaq 0x50(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x5423
leaq 0xa0(%rsp), %r12
movq %rbp, 0x8(%r12)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%r12)
movq %r15, 0x28(%r12)
movsd 0x10(%r13), %xmm0
movsd %xmm0, 0x50(%r12)
movq 0x18(%r13), %rax
movq %rax, 0x58(%r12)
addq $0x68, %r14
leaq 0x28(%rsp), %r13
movq %r13, %rdi
leaq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x5423
leaq 0x110(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x5470
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5ba4
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/IsaacLaw12[P]RayTracer/./Eigen/Eigen/src/Core/Dot.h
// Function: Eigen::MatrixBase<Eigen::Matrix<double, 3, 1, 0, 3, 1>>::normalized() const
EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::PlainObject
MatrixBase<Derived>::normalized() const
{
  typedef typename internal::nested_eval<Derived,2>::type _Nested;
  _Nested n(derived());
  RealScalar z = n.squaredNorm();
  // NOTE: after extensive benchmarking, this conditional does not impact performance, at least on recent x86 CPU
  if(z>RealScalar(0))
    return n / numext::sqrt(z);
  else
    return n;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movupd (%rsi), %xmm0
mulpd %xmm0, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x10(%rsi), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x535e
sqrtsd %xmm0, %xmm0
movq %rsp, %rdx
movsd %xmm0, (%rdx)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5674
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5728
jmp 0x536e
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rbx)
movupd (%rsi), %xmm0
movupd %xmm0, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/IsaacLaw12[P]RayTracer/./src/Light.cpp
// Function: Light::Light(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Light::Light(std::string driver_line){
    // Light string: "light x_loc y_loc z_loc w r g b"
    std::stringstream driver(driver_line);
    double light_obj_doubles[8] = {};
    light_obj_doubles[7] = 0;
    std::string driver_type = "";
    driver >> driver_type;

    double temp = 0;
    int counter = 0;
    while (driver >> temp){
        light_obj_doubles[counter++] = temp;
    }
    if (counter < 7 || counter > 8){
        // The correct number of numbers were not found
        load_successful = false;
        return;
    }
    assign_values(light_obj_doubles);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdi, %rbx
andl $0x0, (%rdi)
movb $0x1, 0x40(%rdi)
leaq 0x70(%rsp), %rdi
pushq $0x18
popq %rdx
callq 0x33e0
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
leaq 0x13207(%rip), %rsi     # 0x191ce
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x61f6
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3320
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
xorl %r12d, %r12d
leaq 0x70(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x31b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x6021
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp,%r12,8)
incq %r12
jmp 0x5ff6
addl $-0x9, %r12d
cmpl $-0x3, %r12d
ja 0x6031
movb $0x0, 0x40(%rbx)
jmp 0x603e
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x608a
leaq 0x10(%rsp), %rdi
callq 0x3100
leaq 0x70(%rsp), %rdi
callq 0x3200
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x606a
jmp 0x606a
movq %rax, %rbx
jmp 0x6077
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3100
leaq 0x70(%rsp), %rdi
callq 0x3200
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/IsaacLaw12[P]RayTracer/./src/Light.cpp
// Function: Light::assign_values(double*)
void Light::assign_values(double spec_nums[]){
    double x_cord = spec_nums[0];
    double y_cord = spec_nums[1];
    double z_cord = spec_nums[2];
    w_value = spec_nums[3];
    double red_color = spec_nums[4];
    double green_color = spec_nums[5];
    double blue_color = spec_nums[6];
    lighting_group = spec_nums[7];
    light_pos << x_cord, y_cord, z_cord;
    if (w_value == 0){
        light_pos = 1000000000 * light_pos;
    }
    light_color << red_color, green_color, blue_color;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm1
leaq 0x50(%rsp), %rax
movsd %xmm1, (%rax)
movsd 0x10(%rsi), %xmm1
movsd %xmm1, 0x18(%rsp)
movsd 0x18(%rsi), %xmm1
movsd %xmm1, 0x8(%rdi)
movsd 0x20(%rsi), %xmm1
movsd %xmm1, (%rsp)
movsd 0x28(%rsi), %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x30(%rsi), %xmm1
movsd %xmm1, 0x8(%rsp)
cvttsd2si 0x38(%rsi), %ecx
movl %ecx, (%rdi)
leaq 0x10(%rdi), %r14
leaq 0x28(%rsp), %rdi
movq %r14, (%rdi)
andq $0x0, 0x8(%rdi)
pushq $0x1
popq %r12
movq %r12, 0x10(%rdi)
movq %r12, 0x18(%rdi)
movsd %xmm0, 0x10(%rbx)
movq %rax, %rsi
callq 0x6232
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x6232
leaq 0x28(%rsp), %rdi
callq 0x62da
movsd 0x8(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x615e
jp 0x615e
leaq 0x24(%rsp), %rsi
movl $0x3b9aca00, (%rsi)     # imm = 0x3B9ACA00
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x62ea
movq %r14, %rdi
movq %r15, %rsi
callq 0x6403
leaq 0x28(%rbx), %rax
leaq 0x28(%rsp), %rdi
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %r12, 0x10(%rdi)
movq %r12, 0x18(%rdi)
movsd (%rsp), %xmm0
movsd %xmm0, 0x28(%rbx)
leaq 0x10(%rsp), %rsi
callq 0x6232
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x6232
leaq 0x28(%rsp), %rdi
callq 0x62da
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x61b0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x62da
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/IsaacLaw12[P]RayTracer/./src/raytracer.cpp
// Function: create_directory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void create_directory(std::string save_folder){
    //   ***** THIS USES LINUX SYSTEM CALLS, TO RUN ON WINDOWS REWRITE ******
    // Clear the saved render folder of previous contents
    char remove_command[80] = "rm -r ";
    strcat(remove_command, save_folder.c_str());
    if (0 == system(remove_command)){
        // The result of this command does not need to be handled as the following system command
        //   properly alerts to the same potential problem set.
        ;
    }

    char create_command[80] = "mkdir ";
    strcat(create_command, save_folder.c_str());
    if (0 == system(create_command)){
        std::cout << save_folder << " directory created successfully\n";
    } else{
        std::cout << save_folder << " directory creation failed\n";
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %r14
movaps %xmm0, (%r14)
movaps %xmm0, 0x40(%r14)
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movl $0x2d206d72, (%r14)     # imm = 0x2D206D72
movw $0x2072, %bp            # imm = 0x2072
movw %bp, 0x4(%r14)
movq (%rdi), %rsi
movq %r14, %rdi
callq 0x34a0
movq %r14, %rdi
callq 0x3250
movq %rsp, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movaps %xmm0, 0x40(%r14)
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movl $0x69646b6d, (%r14)     # imm = 0x69646B6D
movw %bp, 0x4(%r14)
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x34a0
movq %r14, %rdi
callq 0x3250
movl %eax, %ebp
movq 0x23a81(%rip), %rdi     # 0x29fc0
movq %rbx, %rsi
callq 0x3280
testl %ebp, %ebp
leaq 0x12be4(%rip), %rcx     # 0x19134
leaq 0x12bfe(%rip), %rsi     # 0x19155
cmoveq %rcx, %rsi
movq %rax, %rdi
callq 0x32a0
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/IsaacLaw12[P]RayTracer/./src/raytracer.cpp
// Function: parse_int(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int&)
int parse_int(std::string str, int &status){
    int result = 0;
    try {
        result = stoi(str);
    }
    catch(std::invalid_argument& e){
        status = 1;
    }
    return result;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x6c9f
popq %rbx
retq
movq %rax, %rdi
cmpl $0x1, %edx
jne 0x659b
callq 0x30e0
movl $0x1, (%rbx)
callq 0x3420
xorl %eax, %eax
jmp 0x657d
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/IsaacLaw12[P]RayTracer/./src/raytracer.cpp
// Function: parse_folder_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string parse_folder_name(std::string name){
    std::string result = "";
    for (auto c: name){
        if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')){
            result += c;
        }
    }
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x12c19(%rip), %rsi     # 0x191ce
leaq 0x7(%rsp), %rdx
callq 0x61f6
movq (%r14), %r15
movq 0x8(%r14), %r14
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x65ef
movb (%r15,%r12), %al
movl %eax, %ecx
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x19, %cl
ja 0x65ea
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3260
incq %r12
jmp 0x65c9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3100
movq %r14, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/IsaacLaw12[P]RayTracer/./src/raytracer.cpp
// Function: image_name(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string image_name(int frame_number, std::string save_folder){
    std::string padded_frame_num = std::to_string(frame_number);
    while (padded_frame_num.size() < 4){
        padded_frame_num = "0" + padded_frame_num;
    }
    std::string result = save_folder + "/output" + padded_frame_num + ".ppm";
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x6cc8
leaq 0x12a45(%rip), %r12     # 0x192d7
movq %rsp, %r13
cmpq $0x3, 0x28(%rsp)
ja 0x68c0
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x6d21
movq %r15, %rdi
movq %r13, %rsi
callq 0x3310
movq %r13, %rdi
callq 0x3100
jmp 0x6895
leaq 0x12a12(%rip), %rdx     # 0x192d9
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x6dd5
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x6db6
leaq 0x129f4(%rip), %rdx     # 0x192e1
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6d97
movq %rsp, %rdi
callq 0x3100
leaq 0x40(%rsp), %rdi
callq 0x3100
leaq 0x20(%rsp), %rdi
callq 0x3100
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3100
jmp 0x6935
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x3100
jmp 0x6946
jmp 0x6943
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/IsaacLaw12[P]RayTracer/./src/raytracer.cpp
// Function: multi_thread_render(RenderImage&, int)
void multi_thread_render(RenderImage &ri, int number_threads){
    std::vector<std::thread> render_threads;
    for (int i=0; i<number_threads; i++)
        render_threads.push_back(std::thread(&RenderImage::render_tiles, &ri));

    for (std::thread & t : render_threads)
        t.join();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
xorl %ebp, %ebp
testl %esi, %esi
cmovgl %esi, %ebp
leaq 0x6901(%rip), %r14      # 0xd286
leaq 0x20(%rsp), %r15
leaq 0x28(%rsp), %r12
leaq 0x18(%rsp), %r13
subl $0x1, %ebp
jb 0x69cc
movq %r14, 0x28(%rsp)
andq $0x0, 0x30(%rsp)
movq %rbx, 0x18(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x6e0e
movq %rsp, %rdi
movq %r15, %rsi
callq 0x724e
movq %r15, %rdi
callq 0x6e8c
jmp 0x6994
movq (%rsp), %rbx
movq 0x8(%rsp), %r14
cmpq %r14, %rbx
je 0x69e8
movq %rbx, %rdi
callq 0x3450
addq $0x8, %rbx
jmp 0x69d5
movq %rsp, %rdi
callq 0x6e9a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6a01
movq %rax, %rbx
jmp 0x6a13
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6e8c
movq %rsp, %rdi
callq 0x6e9a
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/IsaacLaw12[P]RayTracer/./src/raytracer.cpp
// Function: render_scene(Scene&, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void render_scene(Scene &sc, int number_threads, std::string save_folder){
    RenderImage ri = RenderImage(&sc);
    while (sc.advance_frame()){
        ri.reset();
        if (number_threads > 1)
            multi_thread_render(ri, number_threads);
        else
            ri.render_tiles();
        ri.save_image(image_name(sc.get_current_frame(), save_folder));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, 0x8(%rsp)
movl %esi, %ebp
movq %rdi, %r14
leaq 0x50(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xd0ac
leaq 0x10(%rsp), %r12
leaq 0x30(%rsp), %r13
movq %r14, %rdi
callq 0x1049c
testb %al, %al
je 0x6ac6
movq %r15, %rdi
callq 0xd10a
cmpl $0x2, %ebp
jl 0x6a7d
movq %r15, %rdi
movl %ebp, %esi
callq 0x6958
jmp 0x6a85
movq %r15, %rdi
callq 0xd286
movq %r14, %rdi
callq 0x1043a
movl %eax, %ebx
movq %r12, %rdi
movq 0x8(%rsp), %rsi
callq 0x3360
movq %r13, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x686b
movq %r15, %rdi
movq %r13, %rsi
callq 0xd21c
movq %r13, %rdi
callq 0x3100
movq %r12, %rdi
callq 0x3100
jmp 0x6a58
leaq 0x60(%rsp), %rdi
callq 0x7062
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3100
jmp 0x6af4
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3100
jmp 0x6b03
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x7062
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/IsaacLaw12[P]RayTracer/./src/raytracer.cpp
// Function: main
int main(int argc, char*argv[]){
    int number_threads = 1;
    std::string driver_file = "";
    std::string save_folder = "";
    int valid_args = parse_args(argc, argv, number_threads, driver_file, save_folder);
    if (valid_args != 0){
        return valid_args;
    }

    create_directory(save_folder);
    Scene sc(driver_file);
    render_scene(sc, number_threads, save_folder);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x2f0, %rsp            # imm = 0x2F0
movq %rsi, %rbx
movl %edi, %ebp
movl $0x1, 0xc(%rsp)
leaq 0x1269a(%rip), %r14     # 0x191ce
leaq 0x30(%rsp), %rdi
leaq 0xb0(%rsp), %rdx
movq %r14, %rsi
callq 0x61f6
leaq 0x10(%rsp), %rdi
leaq 0xb0(%rsp), %rdx
movq %r14, %rsi
callq 0x61f6
leaq 0xc(%rsp), %rdx
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movl %ebp, %edi
movq %rbx, %rsi
callq 0x6611
testl %eax, %eax
je 0x6b83
pushq $0x1
popq %rbx
jmp 0x6c1a
leaq 0x90(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3360
leaq 0x90(%rsp), %rdi
callq 0x64a8
leaq 0x90(%rsp), %rdi
callq 0x3100
leaq 0x70(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x3360
leaq 0xb0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xff14
leaq 0x70(%rsp), %rdi
callq 0x3100
movl 0xc(%rsp), %ebx
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3360
leaq 0xb0(%rsp), %rdi
leaq 0x50(%rsp), %rdx
movl %ebx, %esi
callq 0x6a23
leaq 0x50(%rsp), %rdi
callq 0x3100
leaq 0xb0(%rsp), %rdi
callq 0x6ebc
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x3100
leaq 0x30(%rsp), %rdi
callq 0x3100
movl %ebx, %eax
addq $0x2f0, %rsp            # imm = 0x2F0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3100
jmp 0x6c4e
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x6ebc
jmp 0x6c83
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x6c74
jmp 0x6c80
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x3100
jmp 0x6c83
movq %rax, %rbx
jmp 0x6c8d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3100
leaq 0x30(%rsp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/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 0x17da4
movq %rax, %r12
movq %r13, %rdi
callq 0x17daa
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 0x74f3
movsd %xmm0, (%r14)
movsd %xmm1, (%rbx)
movapd %xmm1, %xmm0
movsd (%r14), %xmm1
movupd 0x8(%r15), %xmm3
movupd 0x8(%r12), %xmm2
movhpd 0x20(%r15), %xmm3       # xmm3 = xmm3[0],mem[0]
movupd 0x8(%rax), %xmm4
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
subpd %xmm2, %xmm3
unpcklpd %xmm4, %xmm4            # xmm4 = xmm4[0,0]
divpd %xmm4, %xmm3
movapd %xmm3, %xmm4
unpckhpd %xmm3, %xmm4            # xmm4 = xmm4[1],xmm3[1]
movapd %xmm3, %xmm2
maxsd %xmm4, %xmm2
xorl %ecx, %ecx
ucomisd %xmm2, %xmm1
ja 0x75d0
minsd %xmm3, %xmm4
ucomisd %xmm0, %xmm4
ja 0x75d0
ucomisd %xmm1, %xmm4
jbe 0x7558
movsd %xmm4, (%r14)
movsd (%rbx), %xmm0
movapd %xmm4, %xmm1
ucomisd %xmm2, %xmm0
jbe 0x756b
movsd %xmm2, (%rbx)
movsd (%r14), %xmm1
movapd %xmm2, %xmm0
movupd 0x10(%r15), %xmm3
movhpd 0x28(%r15), %xmm3       # xmm3 = xmm3[0],mem[0]
movsd 0x10(%r12), %xmm2
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
subpd %xmm2, %xmm3
movsd 0x10(%rax), %xmm2
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
divpd %xmm2, %xmm3
movapd %xmm3, %xmm4
unpckhpd %xmm3, %xmm4            # xmm4 = xmm4[1],xmm3[1]
movapd %xmm3, %xmm2
maxsd %xmm4, %xmm2
xorl %ecx, %ecx
ucomisd %xmm2, %xmm1
ja 0x75d0
minsd %xmm3, %xmm4
ucomisd %xmm0, %xmm4
ja 0x75d0
ucomisd %xmm1, %xmm4
jbe 0x75c4
movsd %xmm4, (%r14)
movsd (%rbx), %xmm0
movb $0x1, %cl
ucomisd %xmm2, %xmm0
jbe 0x75d0
movsd %xmm2, (%rbx)
movl %ecx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x2262c(%rip), %rax     # 0x29c20
movq %rax, (%rdi)
andl $0x0, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x11bc8(%rip), %rsi     # 0x191ce
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x61f6
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r14)
andq $0x0, 0x40(%r14)
movq %r15, 0x48(%r14)
movl $0x258, %edi            # imm = 0x258
callq 0x32b0
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x8ae2
movq %r12, 0x50(%r14)
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x9746
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3310
movq %r15, %rdi
callq 0x3100
movq %r14, %rdi
callq 0x76ac
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x768d
movq %rax, %r15
movl $0x258, %esi            # imm = 0x258
movq %r12, %rdi
callq 0x32c0
jmp 0x7690
movq %rax, %r15
addq $0x30, %r14
movq %r14, %rdi
callq 0x5ecc
movq %rbx, %rdi
callq 0x3100
movq %r15, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/IsaacLaw12[P]RayTracer/./src/AnimatedObject.cpp
// Function: AnimatedObject::load_animation()
void AnimatedObject::load_animation(){
    std::vector<std::string> animation_steps = extract_file_lines(animation_file);
    int section_start = 0;
    int section_end = 0;
    for (std::string animation_step:animation_steps){
        std::stringstream driver(animation_step);
        driver >> section_end;
        std::vector<double> transform_floats;
        double temp = 0;
        while (driver >> temp){
            transform_floats.push_back(temp);
        }
        add_animation_section(section_start, section_end, transform_floats);
        section_start = section_end;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdi, 0x8(%rsp)
leaq 0x10(%rdi), %rsi
leaq 0x78(%rsp), %rbx
movq %rbx, %rdi
callq 0x3360
leaq 0x28(%rsp), %rdi
movq %rbx, %rdx
callq 0x78a8
leaq 0x78(%rsp), %rdi
callq 0x3100
leaq 0x4(%rsp), %rax
andl $0x0, (%rax)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
xorl %r15d, %r15d
leaq 0xb0(%rsp), %r13
leaq 0x20(%rsp), %r14
leaq 0x40(%rsp), %rbp
cmpq 0x10(%rsp), %rsi
je 0x77e6
leaq 0x58(%rsp), %rbx
movq %rbx, %rdi
movq %rsi, 0x18(%rsp)
callq 0x3360
movq %r13, %rdi
movq %rbx, %rsi
pushq $0x18
popq %rdx
callq 0x33e0
movq %r13, %rdi
leaq 0x4(%rsp), %rsi
callq 0x3190
andq $0x0, 0x50(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
andq $0x0, 0x20(%rsp)
movq %r13, %rdi
movq %r14, %rsi
callq 0x31b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x7788
movq %rbp, %rdi
movq %r14, %rsi
callq 0x7daa
jmp 0x7762
movl 0x4(%rsp), %ebx
leaq 0x98(%rsp), %r12
movq %r12, %rdi
movq %rbp, %rsi
callq 0x7dcc
movq 0x8(%rsp), %rdi
movl %r15d, %esi
movl %ebx, %edx
movq %r12, %rcx
callq 0x7966
movq %r12, %rdi
callq 0x5f3a
movl 0x4(%rsp), %r15d
movq %rbp, %rdi
callq 0x5f3a
movq %r13, %rdi
callq 0x3200
leaq 0x58(%rsp), %rdi
callq 0x3100
movq 0x18(%rsp), %rsi
addq $0x20, %rsi
jmp 0x7716
leaq 0x28(%rsp), %rdi
callq 0x7e1a
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x3100
jmp 0x7862
jmp 0x7834
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x5f3a
jmp 0x7837
movq %rax, %rbx
jmp 0x7841
movq %rax, %rbx
jmp 0x7858
movq %rax, %rbx
jmp 0x784e
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x5f3a
leaq 0xb0(%rsp), %rdi
callq 0x3200
leaq 0x58(%rsp), %rdi
callq 0x3100
leaq 0x28(%rsp), %rdi
callq 0x7e1a
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
pushq $0x8
popq %rax
movq %r14, %rdi
movq %rdx, %rsi
movl %eax, %edx
callq 0x3400
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3070
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x791b
cmpq $0xb, 0x10(%rsp)
jb 0x78ed
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7e68
jmp 0x78ed
leaq 0x8(%rsp), %rdi
callq 0x3100
leaq 0x28(%rsp), %rdi
callq 0x30a0
movq %rbx, %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7e1a
leaq 0x8(%rsp), %rdi
callq 0x3100
leaq 0x28(%rsp), %rdi
callq 0x30a0
movq %r14, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xb8, %rsp
movq %rdi, 0x20(%rsp)
movl %edx, %ebx
movq %rsi, 0x28(%rsp)
subl %esi, %ebx
je 0x7aad
movl %edx, %ebp
cvtsi2sd %ebx, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x88(%rsp), %r15
movq %r15, %rdi
movq %rcx, %rsi
callq 0x7dcc
leaq 0x58(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
movq %r15, %rdx
callq 0x7afa
leaq 0x88(%rsp), %rdi
callq 0x5f3a
addq $0x30, 0x20(%rsp)
xorl %r14d, %r14d
testl %ebx, %ebx
cmovlel %r14d, %ebx
movq 0x28(%rsp), %rax
subl %ebp, %eax
incl %eax
movl %eax, 0x8(%rsp)
leaq 0x70(%rsp), %rbp
leaq 0x58(%rsp), %rsi
leaq 0xa0(%rsp), %r15
movq %rsi, 0x18(%rsp)
movl %ebx, 0x14(%rsp)
cmpl %r14d, %ebx
je 0x7aa3
leaq 0x38(%rsp), %rax
andq $0x0, 0x10(%rax)
xorpd %xmm0, %xmm0
movupd %xmm0, (%rax)
movq 0x28(%rsp), %rax
addl %r14d, %eax
movl %eax, 0x30(%rsp)
movq %rbp, %rdi
callq 0x7dcc
leal 0x1(%r14), %ebx
cvtsi2sd %ebx, %xmm0
movq %r15, %rdi
movq %rbp, %rdx
callq 0x7bb6
addl 0x8(%rsp), %r14d
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
callq 0x80a6
movq %r15, %r12
movq %r15, %rdi
callq 0x5f3a
movq %rbp, %r13
movq %rbp, %rdi
callq 0x5f3a
testl %r14d, %r14d
sete 0x50(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x7e3c
leaq 0x38(%rsp), %rdi
callq 0x5f3a
movl %ebx, %r14d
leaq 0x58(%rsp), %rsi
movl 0x14(%rsp), %ebx
movq %r13, %rbp
movq %r12, %r15
jmp 0x7a01
leaq 0x58(%rsp), %rdi
callq 0x5f3a
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, 0x18(%rsp)
movq %rax, %r14
jmp 0x7ae7
jmp 0x7ada
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x5f3a
jmp 0x7add
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x5f3a
movq 0x18(%rsp), %rdi
callq 0x5f3a
movq %r14, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
xorpd %xmm1, %xmm1
movupd %xmm1, (%rdi)
andq $0x0, 0x10(%rdi)
xorl %r12d, %r12d
leaq 0x10(%rsp), %r15
movsd %xmm0, 0x8(%rsp)
cmpq $0x8, %r12
je 0x7b93
movq (%r14), %rax
movsd (%rax,%r12,8), %xmm1
movapd %xmm1, %xmm3
addsd 0x10eef(%rip), %xmm3    # 0x18a30
divsd %xmm0, %xmm3
addsd 0x104e3(%rip), %xmm3    # 0x18030
cmpq $0x4, %r12
je 0x7b57
movapd %xmm1, %xmm3
movapd %xmm3, %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm2
cmpq $0x3, %r12
je 0x7b6d
movapd %xmm3, %xmm2
cmpq $0x5, %r12
jae 0x7b77
movapd %xmm2, %xmm1
movsd %xmm1, 0x10(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7daa
incq %r12
movsd 0x8(%rsp), %xmm0
jmp 0x7b26
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5f3a
movq %r14, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x340, %rsp            # imm = 0x340
movq %rdi, %r14
movl 0x8(%rdi), %ecx
movq 0x38(%rdi), %rax
movq 0x30(%rdi), %rsi
subq %rsi, %rax
pushq $0x28
popq %rdi
cqto
idivq %rdi
cmpq %rcx, %rax
jbe 0x7d3a
imulq $0x28, %rcx, %rax
addq %rax, %rsi
leaq 0x18(%rsp), %rdi
callq 0x7e94
leaq 0x20(%rsp), %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x7dcc
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x1251e
movq %rsp, %rdi
callq 0x5f3a
movq 0x50(%r14), %rdi
testq %rdi, %rdi
je 0x7cc7
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x258, %edi            # imm = 0x258
callq 0x32b0
movq %rax, %r15
movq 0x48(%r14), %rsi
movq %rax, %rdi
callq 0x8ae2
movq %r15, 0x50(%r14)
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
callq 0x1265a
cmpb $0x1, 0x38(%rsp)
jne 0x7d24
movq 0x48(%r14), %rdi
testq %rdi, %rdi
je 0x7d07
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x258, %edi            # imm = 0x258
callq 0x32b0
movq %rax, %r15
movq 0x50(%r14), %rsi
movq %rax, %rdi
callq 0x8ae2
movq %r15, 0x48(%r14)
incl 0x8(%r14)
leaq 0x40(%rsp), %rdi
callq 0x7ebe
movq %rbx, %rdi
callq 0x5f3a
addq $0x340, %rsp            # imm = 0x340
popq %rbx
popq %r14
popq %r15
retq
jmp 0x7d49
movq %rax, %r14
movl $0x258, %esi            # imm = 0x258
movq %r15, %rdi
callq 0x32c0
jmp 0x7d70
movq %rax, %r14
movq %rsp, %rdi
callq 0x5f3a
jmp 0x7d7a
movq %rax, %r14
jmp 0x7d7a
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x7ebe
movq %rbx, %rdi
callq 0x5f3a
movq %r14, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/IsaacLaw12[P]RayTracer/./src/Model.cpp
// Function: Model::Model(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Model::Model(std::string driver_line){
    Transformation model_to_scene = Transformation(driver_line);
    original_file = model_to_scene.get_asset_name();
    load_model();
    model_to_scene.transform_object(this);
    smoothing = model_to_scene.get_smoothing();
    animation_file = model_to_scene.get_animation_file();
    on_model_load();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x368, %rsp            # imm = 0x368
movq %rsi, %r12
movq %rdi, %rbx
callq 0xa1fe
leaq 0x2172d(%rip), %rax     # 0x29c50
movq %rax, (%rbx)
leaq 0x220(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x190(%rbx)
movups %xmm0, 0x1a0(%rbx)
movups %xmm0, 0x1b0(%rbx)
movups %xmm0, 0x1c0(%rbx)
movups %xmm0, 0x1d0(%rbx)
movups %xmm0, 0x1e0(%rbx)
movups %xmm0, 0x1f0(%rbx)
movups %xmm0, 0x200(%rbx)
movq %rax, 0x210(%rbx)
andq $0x0, 0x218(%rbx)
xorl %eax, %eax
movb %al, 0x220(%rbx)
leaq 0x240(%rbx), %rcx
movq %rcx, 0x230(%rbx)
andq $0x0, 0x238(%rbx)
leaq 0x210(%rbx), %r14
leaq 0x230(%rbx), %r15
movb %al, 0x240(%rbx)
movw $0x1, 0x250(%rbx)
leaq 0x40(%rsp), %rdi
movq %r12, %rsi
callq 0x3360
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x11dfc
leaq 0x40(%rsp), %rdi
callq 0x3100
leaq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x12710
leaq 0x20(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x3310
movq %r12, %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x871c
leaq 0x60(%rsp), %rdi
movq %rbx, %rsi
callq 0x1265a
leaq 0x60(%rsp), %rdi
callq 0x1271e
movb %al, 0x251(%rbx)
leaq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x12790
leaq 0x20(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x3310
movq %r12, %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x8a7a
leaq 0x60(%rsp), %rdi
callq 0x7ebe
addq $0x368, %rsp            # imm = 0x368
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x868b
jmp 0x868b
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x3100
jmp 0x869a
movq %rax, 0x8(%rsp)
jmp 0x869a
movq %rax, 0x8(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x7ebe
leaq 0x190(%rbx), %rax
movq %rax, 0x18(%rsp)
leaq 0x1f8(%rbx), %rbp
leaq 0x1e0(%rbx), %r12
leaq 0x1c8(%rbx), %r13
leaq 0x1b0(%rbx), %rax
movq %rax, 0x10(%rsp)
addq $0x198, %rbx            # imm = 0x198
movq %r15, %rdi
callq 0x3100
movq %r14, %rdi
callq 0x3100
movq %rbp, %rdi
callq 0xaeb8
movq %r12, %rdi
callq 0xa30c
movq %r13, %rdi
callq 0x4606
movq 0x10(%rsp), %rdi
callq 0xacf8
movq %rbx, %rdi
callq 0x4606
movq 0x18(%rsp), %rdi
callq 0xa32e
movq 0x8(%rsp), %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x8f5a
movq %rbx, %rdi
callq 0x901e
leaq 0xc(%rsp), %rcx
movl $0x8, (%rcx)
leaq 0x198(%rbx), %rsi
leaq 0x1b0(%rbx), %rdx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0xa5bc
leaq 0x190(%rbx), %rdi
movq (%r14), %rsi
andq $0x0, (%r14)
callq 0xad00
movq %r14, %rdi
callq 0xa32e
movq %rbx, %rdi
callq 0x9224
addq $0x18, %rsp
popq %rbx
popq %r14
retq