LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/objects/RenderObjectCollection.cpp
// Function: RayTracer::RenderObjectCollection::to_json[abi:cxx11]() const
json RenderObjectCollection::to_json() const {
    json j;

    // First, let the parent class parse all it wants
    this->baseclass_to_json(j);
    
    // Add child-specific properties
    j["objects"] = json::array();
    // Append all the internal objects
    for (std::size_t i = 0; i < this->objects.size(); i++) {
        j["objects"][i] = this->objects[i]->to_json();
    }
    return j;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
callq 0x56d46
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7eed0
leaq 0xa094(%rip), %rsi      # 0x8be76
movq %rbx, %rdi
callq 0x56e34
movq %rsp, %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x6d06c
movq %r15, %rdi
callq 0x56fca
xorl %r15d, %r15d
leaq 0x10(%rsp), %r12
leaq 0xa067(%rip), %r13      # 0x8be76
movq 0x80(%r14), %rax
movq 0x88(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
jae 0x81e64
movq (%rax,%r15,8), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x58(%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x56e34
movq %rax, %rdi
movq %r15, %rsi
callq 0x7eefe
movq %rax, %rdi
movq %r12, %rsi
callq 0x6d06c
movq %r12, %rdi
callq 0x56fca
incq %r15
jmp 0x81e0f
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
jmp 0x81e8c
jmp 0x81e7f
movq %rax, %r14
jmp 0x81e91
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x56fca
movq %rbx, %rdi
callq 0x56fca
movq %r14, %rdi
callq 0x527a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/Random.cpp
// Function: RayTracer::random_double()
double RayTracer::random_double() {
    static std::uniform_real_distribution<double> distribution(0.0, 1.0);
    static std::mt19937 generator;
    static std::function<double()> rand_generator = std::bind(distribution, generator);
    return rand_generator();
}

// Assembly:
pushq %rbx
subq $0x13a0, %rsp           # imm = 0x13A0
movb 0x3070a(%rip), %al      # 0xb2d60
testb %al, %al
je 0x82683
movb 0x31a90(%rip), %al      # 0xb40f0
testb %al, %al
je 0x826b2
movb 0x31aae(%rip), %al      # 0xb4118
testb %al, %al
je 0x826dc
leaq 0x31a83(%rip), %rdi     # 0xb40f8
callq 0x8291e
addq $0x13a0, %rsp           # imm = 0x13A0
popq %rbx
retq
leaq 0x306d6(%rip), %rdi     # 0xb2d60
callq 0x527c0
testl %eax, %eax
je 0x8265a
xorps %xmm0, %xmm0
movhps 0x89a3(%rip), %xmm0     # xmm0 = xmm0[0,1],mem[0,1]
movaps %xmm0, 0x306ac(%rip)    # 0xb2d50
leaq 0x306b5(%rip), %rdi     # 0xb2d60
callq 0x522e0
jmp 0x8265a
leaq 0x31a37(%rip), %rdi     # 0xb40f0
callq 0x527c0
testl %eax, %eax
je 0x82664
leaq 0x3069f(%rip), %rdi     # 0xb2d68
callq 0x828cc
leaq 0x31a1b(%rip), %rdi     # 0xb40f0
callq 0x522e0
jmp 0x82664
leaq 0x31a35(%rip), %rdi     # 0xb4118
callq 0x527c0
testl %eax, %eax
je 0x8266e
movaps 0x3065d(%rip), %xmm0    # 0xb2d50
leaq 0x10(%rsp), %rdi
movaps %xmm0, -0x10(%rdi)
leaq 0x30665(%rip), %rsi     # 0xb2d68
movl $0x1388, %edx           # imm = 0x1388
callq 0x523c0
leaq 0x319e4(%rip), %rdi     # 0xb40f8
movq %rsp, %rsi
callq 0x828d6
leaq -0x1763b(%rip), %rdi    # 0x6b0e8
leaq 0x319ce(%rip), %rsi     # 0xb40f8
leaq 0x2fd17(%rip), %rdx     # 0xb2448
callq 0x523f0
leaq 0x319db(%rip), %rdi     # 0xb4118
callq 0x522e0
jmp 0x8266e
movq %rax, %rbx
leaq 0x319c7(%rip), %rdi     # 0xb4118
jmp 0x8275d
movq %rax, %rbx
leaq 0x31993(%rip), %rdi     # 0xb40f0
callq 0x522d0
movq %rbx, %rdi
callq 0x527a0
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/Random.cpp
// Function: RayTracer::random_in_unit_sphere()
RayTracer::Vec3 RayTracer::random_in_unit_sphere() {
    Vec3 p;
    do {
        p = 2.0 * Vec3(random_double(), random_double(), random_double()) - 1.0;
    } while (p.squared_length() >= 1.0);
    return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
callq 0x7e44c
leaq 0x18(%rsp), %r14
leaq 0x38(%rsp), %r15
leaq 0x58(%rsp), %r12
callq 0x82648
movsd %xmm0, 0x10(%rsp)
callq 0x82648
movsd %xmm0, 0x8(%rsp)
callq 0x82648
movaps %xmm0, %xmm2
movq %r14, %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x7e464
movq %r15, %rdi
movsd 0x8897(%rip), %xmm0     # 0x8b060
movq %r14, %rsi
callq 0x7ed9c
movq %r12, %rdi
movq %r15, %rsi
movsd 0x8861(%rip), %xmm0     # 0x8b040
callq 0x7ece2
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7e47e
movq %rbx, %rdi
callq 0x7e7d8
ucomisd 0x8841(%rip), %xmm0     # 0x8b040
jae 0x8278c
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/Random.cpp
// Function: RayTracer::random_in_unit_disc()
RayTracer::Vec3 RayTracer::random_in_unit_disc() {
    Vec3 p;
    do {
        p = 2.0 * Vec3(random_double(), random_double(), 0) - Vec3(1, 1, 0);
    } while (dot(p, p) >= 1.0);
    return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
callq 0x7e44c
leaq 0x30(%rsp), %r14
leaq 0x50(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0x70(%rsp), %r13
callq 0x82648
movsd %xmm0, 0x8(%rsp)
callq 0x82648
movaps %xmm0, %xmm1
xorps %xmm2, %xmm2
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x7e464
movq %r15, %rdi
movsd 0x87f5(%rip), %xmm0     # 0x8b060
movq %r14, %rsi
callq 0x7ed9c
xorps %xmm2, %xmm2
movq %r12, %rdi
movsd 0x87bf(%rip), %xmm0     # 0x8b040
movapd %xmm0, %xmm1
callq 0x7e464
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x7ecb2
movq %rbx, %rdi
movq %r13, %rsi
callq 0x7e47e
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x7ee56
ucomisd 0x878a(%rip), %xmm0     # 0x8b040
jae 0x8283c
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/ProgressBar.cpp
// Function: std::ProgressBar::ProgressBar()
ProgressBar::ProgressBar() {
    this->min = DEFAULT_MIN;
    this->max = DEFAULT_MAX;
    
    this->left = DEFAULT_LEFT;
    this->right = DEFAULT_RIGHT;

    this->width = DEFAULT_WIDTH;
    this->interval = DEFAULT_INTERVAL;

    this->init();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x20(%rdi), %r14
xorl %eax, %eax
movb %al, 0x30(%rdi)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
leaq 0x40(%rdi), %r15
movb %al, 0x50(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
leaq 0x9656(%rip), %rsi      # 0x8c398
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x56548
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x52560
movq %r12, %rdi
callq 0x52888
leaq 0x9628(%rip), %rsi      # 0x8c398
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x56548
leaq 0x8(%rsp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x52560
movq %r14, %rdi
callq 0x52888
orl $-0x1, 0x60(%rbx)
movq $0x1f4, 0x78(%rbx)      # imm = 0x1F4
movq %rbx, %rdi
callq 0x82dd4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x82db9
movq %rax, %rbx
movq %r15, %rdi
callq 0x52888
movq %r14, %rdi
callq 0x52888
movq %rbx, %rdi
callq 0x527a0
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/ProgressBar.cpp
// Function: std::ProgressBar::init()
void ProgressBar::init() {
    this->var_width = this->width < 0;
    this->progress = this->min;
    this->done = false;

    this->last_draw = chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()) - this->interval;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x60(%rdi), %eax
shrl $0x1f, %eax
movb %al, 0x6c(%rdi)
movq 0x10(%rdi), %rax
movq %rax, 0x8(%rdi)
movb $0x0, (%rdi)
callq 0x52070
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
subq 0x78(%rbx), %rax
movq %rax, 0x70(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/ProgressBar.cpp
// Function: std::ProgressBar::ProgressBar(long, long)
ProgressBar::ProgressBar(long min_value, long max_value) {
    this->min = min_value;
    this->max = max_value;
    
    this->left = DEFAULT_LEFT;
    this->right = DEFAULT_RIGHT;

    this->width = DEFAULT_WIDTH;
    this->interval = DEFAULT_INTERVAL;

    this->init();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x20(%rdi), %r14
xorl %eax, %eax
movb %al, 0x30(%rdi)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
leaq 0x40(%rdi), %r15
movb %al, 0x50(%rdi)
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
leaq 0x954b(%rip), %rsi      # 0x8c398
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x56548
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x52560
movq %r12, %rdi
callq 0x52888
leaq 0x951d(%rip), %rsi      # 0x8c398
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x56548
leaq 0x8(%rsp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x52560
movq %r14, %rdi
callq 0x52888
orl $-0x1, 0x60(%rbx)
movq $0x1f4, 0x78(%rbx)      # imm = 0x1F4
movq %rbx, %rdi
callq 0x82dd4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x82ec4
movq %rax, %rbx
movq %r15, %rdi
callq 0x52888
movq %r14, %rdi
callq 0x52888
movq %rbx, %rdi
callq 0x527a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/ProgressBar.cpp
// Function: std::ProgressBar::ProgressBar(long, long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
ProgressBar::ProgressBar(long min_value, long max_value, std::string left_text, std::string right_text) {
    this->min = min_value;
    this->max = max_value;
    
    this->left = left_text;
    this->right = right_text;

    this->width = DEFAULT_WIDTH;
    this->interval = DEFAULT_INTERVAL;

    this->init();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rdi, %r14
leaq 0x30(%rdi), %rax
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x20(%rdi), %rbx
xorl %eax, %eax
movb %al, 0x30(%rdi)
addq $0x50, %rdi
movq %rdi, 0x40(%r14)
andq $0x0, 0x48(%r14)
leaq 0x40(%r14), %r12
movb %al, 0x50(%r14)
movq %rsi, 0x10(%r14)
movq %rdx, 0x18(%r14)
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x52270
movq %r12, %rdi
movq %r15, %rsi
callq 0x52270
orl $-0x1, 0x60(%r14)
movq $0x1f4, 0x78(%r14)      # imm = 0x1F4
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x82dd4
movq %rax, %r14
movq %r12, %rdi
callq 0x52888
movq %rbx, %rdi
callq 0x52888
movq %r14, %rdi
callq 0x527a0
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/ProgressBar.cpp
// Function: std::ProgressBar::ProgressBar(long, long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
ProgressBar::ProgressBar(long min_value, long max_value, std::string left_text, std::string right_text, int width) {
    this->min = min_value;
    this->max = max_value;
    
    this->left = left_text;
    this->right = right_text;

    this->width = width;
    this->interval = DEFAULT_INTERVAL;

    this->init();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r9d, %ebx
movq %r8, %r12
movq %rdi, %r15
leaq 0x30(%rdi), %rax
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x20(%rdi), %r14
xorl %eax, %eax
movb %al, 0x30(%rdi)
addq $0x50, %rdi
movq %rdi, 0x40(%r15)
andq $0x0, 0x48(%r15)
leaq 0x40(%r15), %r13
movb %al, 0x50(%r15)
movq %rsi, 0x10(%r15)
movq %rdx, 0x18(%r15)
movq %r14, %rdi
movq %rcx, %rsi
callq 0x52270
movq %r13, %rdi
movq %r12, %rsi
callq 0x52270
movl %ebx, 0x60(%r15)
movq $0x1f4, 0x78(%r15)      # imm = 0x1F4
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x82dd4
movq %rax, %rbx
movq %r13, %rdi
callq 0x52888
movq %r14, %rdi
callq 0x52888
movq %rbx, %rdi
callq 0x527a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/ProgressBar.cpp
// Function: std::ProgressBar::ProgressBar(long, long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::chrono::duration<long, std::ratio<1l, 1000l>>)
ProgressBar::ProgressBar(long min_value, long max_value, std::string left_text, std::string right_text, int width, chrono::milliseconds update_interval) {
    this->min = min_value;
    this->max = max_value;
    
    this->left = left_text;
    this->right = right_text;

    this->width = width;
    this->interval = update_interval;

    this->init();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %r8, %r12
movq %rdi, %r14
movq 0x40(%rsp), %rbp
leaq 0x30(%rdi), %rax
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x20(%rdi), %r15
xorl %eax, %eax
movb %al, 0x30(%rdi)
addq $0x50, %rdi
movq %rdi, 0x40(%r14)
andq $0x0, 0x48(%r14)
leaq 0x40(%r14), %r13
movb %al, 0x50(%r14)
movq %rsi, 0x10(%r14)
movq %rdx, 0x18(%r14)
movq %r15, %rdi
movq %rcx, %rsi
callq 0x52270
movq %r13, %rdi
movq %r12, %rsi
callq 0x52270
movl %ebx, 0x60(%r14)
movq %rbp, 0x78(%r14)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x82dd4
movq %rax, %rbx
movq %r13, %rdi
callq 0x52888
movq %r15, %rdi
callq 0x52888
movq %rbx, %rdi
callq 0x527a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/ProgressBar.cpp
// Function: std::ProgressBar::win()
void ProgressBar::win() {
    // Make sure progress isn't too large
    if (this->progress > this->max) {
        this->progress = this->max;
    }
    // Do a draw
    this->draw();
    // Print endline to finish it up
    cout << endl;
    this->done = true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq %rax, 0x8(%rdi)
jle 0x832f0
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x830a2
movq 0x2ec89(%rip), %rdi     # 0xb1f88
callq 0x52210
movb $0x1, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/ProgressBar.cpp
// Function: std::ProgressBar::set(long)
void ProgressBar::set(long value) {
    if (this->done) {
        return;
    }

    // Update the progress
    this->progress = value;
    
    // Check if we are done
    if (this->progress >= this->max) {
        return this->win();
    }

    // Otherwise, check for draw call
    chrono::milliseconds now = chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch());
    if (now - this->last_draw >= this->interval) {
        // Do the draw call
        this->draw();

        // Update the clock
        this->last_draw += this->interval;

        // Reset to now if we're an entire interval or more behind
        if (now - this->last_draw >= this->interval) {
            this->last_draw = now;
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, (%rdi)
je 0x83325
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdi, %rbx
movq %rsi, 0x8(%rdi)
cmpq %rsi, 0x18(%rdi)
jle 0x83374
callq 0x52070
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movq %rax, %r14
subq 0x70(%rbx), %rax
cmpq 0x78(%rbx), %rax
jl 0x8331d
movq %rbx, %rdi
callq 0x830a2
movq 0x78(%rbx), %rax
movq 0x70(%rbx), %rcx
addq %rax, %rcx
movq %r14, %rdx
subq %rcx, %rdx
cmpq %rax, %rdx
cmovgeq %r14, %rcx
movq %rcx, 0x70(%rbx)
jmp 0x8331d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x832de
nop
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/Camera.cpp
// Function: RayTracer::Camera::get_ray(int, int) const
Ray Camera::get_ray(int x, int y) const {
    // Compute u and v
    double s, t;
    if (this->rays > 1) {
        s = double(x + random_double()) / double(this->width);
        t = double(this->height - 1 - y + random_double()) / double(this->height);
    } else {
        s = double(x) / double(this->width);
        t = double(this->height - 1 - y) / double(this->height);
    }

    // Return a ray shot through this pixel
    Vec3 rd = this->lens_radius * random_in_unit_disc();
    Vec3 offset = this->u * rd.x + this->v * rd.y;
    return Ray(this->origin + offset, this->lower_left_corner + s * this->horizontal + t * this->vertical - this->origin - offset);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, 0x20(%rsp)
cmpl $0x2, 0x10(%rsi)
cvtsi2sd %edx, %xmm1
jl 0x837e5
movsd %xmm1, 0x8(%rsp)
callq 0x82648
addsd 0x8(%rsp), %xmm0
cvtsi2sdl 0x8(%r14), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
notl %ebp
addl 0xc(%r14), %ebp
cvtsi2sd %ebp, %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x82648
addsd 0x10(%rsp), %xmm0
movl 0xc(%r14), %eax
jmp 0x83801
cvtsi2sdl 0x8(%r14), %xmm0
divsd %xmm0, %xmm1
movl 0xc(%r14), %eax
notl %ebp
addl %eax, %ebp
cvtsi2sd %ebp, %xmm0
movsd %xmm1, 0x8(%rsp)
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x170(%r14), %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0x82810
leaq 0x128(%rsp), %r12
movq %r12, %rdi
movsd 0x18(%rsp), %xmm0
movq %r15, %rsi
callq 0x7ed9c
leaq 0x110(%r14), %rsi
movsd 0x8(%r12), %xmm0
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x7ed6e
leaq 0x150(%r14), %rsi
movsd 0x10(%r12), %xmm0
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0x7ed6e
leaq 0x68(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x7ec26
leaq 0xf0(%r14), %r13
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x7ec26
leaq 0x90(%r14), %rbp
leaq 0xb0(%r14), %rsi
leaq 0xa8(%rsp), %rbx
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x7ed9c
leaq 0xc8(%rsp), %r12
movq %r12, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x7ec26
addq $0xd0, %r14
leaq 0x88(%rsp), %rbx
movq %rbx, %rdi
movsd 0x10(%rsp), %xmm0
movq %r14, %rsi
callq 0x7ed9c
leaq 0xe8(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x7ec26
leaq 0x108(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x7ecb2
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x7ecb2
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
leaq 0x28(%rsp), %rsi
movq %r14, %rdx
callq 0x724c4
movq %rbx, %rax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/Camera.cpp
// Function: RayTracer::Camera::to_json[abi:cxx11]() const
json Camera::to_json() const {
    json j;
    j["lookat"] = this->lookat.to_json();
    j["lookfrom"] = this->lookfrom.to_json();
    j["up"] = this->up.to_json();
    j["vfov"] = this->vfov;
    j["aperture"] = this->aperture;
    if (this->animation != nullptr) {
        j["animation"] = this->animation->to_json();
    }
    return j;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
callq 0x56d46
leaq 0x40(%r14), %rsi
leaq 0x50(%rsp), %rdi
callq 0x7e82e
leaq 0xf051(%rip), %rsi      # 0x92a10
movq %rbx, %rdi
callq 0x56e34
leaq 0x50(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x6d06c
movq %r15, %rdi
callq 0x56fca
leaq 0x20(%r14), %rsi
leaq 0x40(%rsp), %rdi
callq 0x7e82e
leaq 0xf023(%rip), %rsi      # 0x92a17
movq %rbx, %rdi
callq 0x56e34
leaq 0x40(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x6d06c
movq %r15, %rdi
callq 0x56fca
leaq 0x60(%r14), %rsi
leaq 0x30(%rsp), %rdi
callq 0x7e82e
leaq 0xeff7(%rip), %rsi      # 0x92a20
movq %rbx, %rdi
callq 0x56e34
leaq 0x30(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x6d06c
movq %r15, %rdi
callq 0x56fca
leaq 0x80(%r14), %rsi
leaq 0x20(%rsp), %rdi
callq 0x7eee4
leaq 0x7faf(%rip), %rsi      # 0x8ba10
movq %rbx, %rdi
callq 0x56e34
leaq 0x20(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x6d06c
movq %r15, %rdi
callq 0x56fca
leaq 0x88(%r14), %rsi
leaq 0x10(%rsp), %rdi
callq 0x7eee4
leaq 0xef99(%rip), %rsi      # 0x92a32
movq %rbx, %rdi
callq 0x56e34
leaq 0x10(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x6d06c
movq %r15, %rdi
callq 0x56fca
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x83af0
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x28(%rax)
leaq 0x8138(%rip), %rsi      # 0x8bc0a
movq %rbx, %rdi
callq 0x56e34
movq %rsp, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x6d06c
movq %r14, %rdi
callq 0x56fca
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
jmp 0x83b35
movq %rax, %r14
leaq 0x10(%rsp), %rdi
jmp 0x83b35
movq %rax, %r14
leaq 0x20(%rsp), %rdi
jmp 0x83b35
movq %rax, %r14
leaq 0x30(%rsp), %rdi
jmp 0x83b35
movq %rax, %r14
leaq 0x40(%rsp), %rdi
jmp 0x83b35
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x56fca
jmp 0x83b3f
movq %rax, %r14
movq %rbx, %rdi
callq 0x56fca
movq %r14, %rdi
callq 0x527a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/RenderWorld.cpp
// Function: RayTracer::RenderWorld::bounce_ray(RayTracer::Ray const&, int) const
Vec3 RenderWorld::bounce_ray(const Ray& ray, int depth) const {
    // Find the hit with the smallest hit
    HitRecord record;
    bool hit = this->objects->hit(ray, 0.0, numeric_limits<double>::max(), record);

    // Check if a hit occured
    if (hit) {
        Ray scattered;
        Vec3 attenuation;
        if (depth < 50 && record.material->scatter(ray, record, attenuation, scattered)) {
            return attenuation * this->bounce_ray(scattered, depth + 1);
        } else {
            return Vec3(0, 0, 0);
        }
    } else {
        Vec3 unit = ray.direction.normalize();
        double t = 0.5 * (unit.y + 1.0);
        return (1.0 - t) * Vec3(1, 1, 1) + t * Vec3(0.5, 0.7, 1.0);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x140, %rsp            # imm = 0x140
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xd8(%rsp), %r12
movq %r12, %rdi
callq 0x82352
movq 0x8(%r14), %rdi
movsd 0xe5be(%rip), %xmm1     # 0x92a78
xorps %xmm0, %xmm0
movq %r15, %rsi
movq %r12, %rdx
callq 0x8963c
testb %al, %al
je 0x8453e
leaq 0x58(%rsp), %rdi
callq 0x72470
leaq 0x18(%rsp), %rdi
callq 0x7e44c
cmpl $0x31, %ebp
jg 0x845fc
leaq 0xd8(%rsp), %rdx
movq 0x60(%rdx), %rdi
movq (%rdi), %rax
leaq 0x18(%rsp), %rcx
leaq 0x58(%rsp), %r8
movq %r15, %rsi
callq *0x20(%rax)
testb %al, %al
je 0x845fc
incl %ebp
leaq 0x38(%rsp), %r15
leaq 0x58(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq 0x84484
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x7ed3e
jmp 0x8460d
addq $0x20, %r15
leaq 0x58(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x7e7e4
movsd 0x6ae6(%rip), %xmm1     # 0x8b040
movsd 0x10(%r14), %xmm0
addsd %xmm1, %xmm0
mulsd 0x6ab4(%rip), %xmm0     # 0x8b020
movsd %xmm0, 0x10(%rsp)
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movsd %xmm2, 0x8(%rsp)
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movapd %xmm1, %xmm0
movapd %xmm1, %xmm2
callq 0x7e464
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movsd 0x8(%rsp), %xmm0
movq %r14, %rsi
callq 0x7ed9c
leaq 0x98(%rsp), %r14
movsd 0xe4c5(%rip), %xmm1     # 0x92a80
movq %r14, %rdi
movsd 0x6a5a(%rip), %xmm0     # 0x8b020
movsd 0x6a72(%rip), %xmm2     # 0x8b040
callq 0x7e464
leaq 0xb8(%rsp), %r12
movq %r12, %rdi
movsd 0x10(%rsp), %xmm0
movq %r14, %rsi
callq 0x7ed9c
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x7ec26
jmp 0x8460d
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %rbx, %rdi
callq 0x7e464
movq %rbx, %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/RenderWorld.cpp
// Function: RayTracer::RenderWorld::render_pixel(int, int, RayTracer::Camera const&) const
Vec3 RenderWorld::render_pixel(int x, int y, const Camera& cam) const {
    Vec3 col;
    for (int r = 0; r < cam.rays; r++) {
        Ray ray = cam.get_ray(x, y);

        // Get the colour
        col += this->bounce_ray(ray);
    }

    // Compute the colour average
    Vec3 avg_col = col / cam.rays;
    if (cam.gamma) {
        // Gamma-correct the avg_colour
        return Vec3(sqrtf64(avg_col.x), sqrtf64(avg_col.y), sqrtf64(avg_col.z));
    } else {
        return avg_col;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, %r14
movl %ecx, (%rsp)
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x7e44c
xorl %ebp, %ebp
leaq 0x18(%rsp), %rbx
leaq 0x78(%rsp), %r13
movl 0x10(%r14), %eax
cmpl %eax, %ebp
jge 0x84692
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
movl (%rsp), %ecx
callq 0x8377e
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x84484
leaq 0x58(%rsp), %rdi
movq %r13, %rsi
callq 0x7e4b2
incl %ebp
jmp 0x84658
cvtsi2sd %eax, %xmm0
leaq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x7edfa
cmpb $0x0, 0x14(%r14)
je 0x846f5
movsd 0x20(%rsp), %xmm0
callq 0x52160
movsd %xmm0, (%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x52160
movsd %xmm0, 0x10(%rsp)
movsd 0x30(%rsp), %xmm0
callq 0x52160
movaps %xmm0, %xmm2
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movsd (%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x7e464
jmp 0x8471a
leaq 0x2cd7c(%rip), %rax     # 0xb1478
addq $0x10, %rax
movq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movups 0x20(%rsp), %xmm0
movups %xmm0, 0x8(%rbx)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/RenderWorld.cpp
// Function: RayTracer::RenderWorld::update(std::chrono::duration<long, std::ratio<1l, 1000l>>)
void RenderWorld::update(chrono::milliseconds time_passed) {
    // Loop through all objects and update them
    for (size_t i = 0; i < this->objects->size(); i++) {
        this->objects->operator[](i)->update(time_passed);
    }
    // Re-optimise the tree
    this->objects->optimize();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x8(%r14), %rdi
callq 0x89630
movq 0x8(%r14), %rdi
cmpq %rax, %r15
jae 0x84769
movq %r15, %rsi
callq 0x897f0
movq (%rax), %rcx
movq %rax, %rdi
movq %rbx, %rsi
callq *0x50(%rcx)
incq %r15
jmp 0x8473e
popq %rbx
popq %r14
popq %r15
jmp 0x8957a
nop
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/RenderWorld.cpp
// Function: RayTracer::RenderWorld::operator=(RayTracer::RenderWorld)
RenderWorld& RenderWorld::operator=(RenderWorld other) {
    // Only do some stuff if this != other
    if (this != &other) {
        // Swap this data with the other data
        swap(*this, other);
    }
    return *this;
}

// Assembly:
movq %rdi, %rax
cmpq %rsi, %rdi
je 0x84796
movq 0x8(%rax), %rcx
movq 0x8(%rsi), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x8(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/RenderWorld.cpp
// Function: RayTracer::RenderWorld::to_json[abi:cxx11]() const
json RenderWorld::to_json() const {
    json j;
    j["objects"] = json::array();

    for (size_t i = 0; i < this->objects->size(); i++) {
        j["objects"][i] = this->objects->operator[](i)->to_json();
    }

    return j;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
callq 0x56d46
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7eed0
leaq 0x768f(%rip), %rsi      # 0x8be76
movq %rbx, %rdi
callq 0x56e34
movq %rsp, %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x6d06c
movq %r15, %rdi
callq 0x56fca
xorl %r15d, %r15d
leaq 0x10(%rsp), %r12
leaq 0x7662(%rip), %r13      # 0x8be76
movq 0x8(%r14), %rdi
callq 0x89630
cmpq %rax, %r15
jae 0x84868
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x897f0
movq (%rax), %rcx
movq %r12, %rdi
movq %rax, %rsi
callq *0x58(%rcx)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x56e34
movq %rax, %rdi
movq %r15, %rsi
callq 0x7eefe
movq %rax, %rdi
movq %r12, %rsi
callq 0x6d06c
movq %r12, %rdi
callq 0x56fca
incq %r15
jmp 0x84814
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
jmp 0x8488b
jmp 0x84892
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x56fca
jmp 0x84895
movq %rax, %r14
movq %rbx, %rdi
callq 0x56fca
movq %r14, %rdi
callq 0x527a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/materials/Lambertian.cpp
// Function: RayTracer::Lambertian::scatter(RayTracer::Ray const&, RayTracer::HitRecord const&, RayTracer::Vec3&, RayTracer::Ray&) const
bool Lambertian::scatter(const Ray&, const HitRecord& record, Vec3& attenuation, Ray& ray_out) const {
    Vec3 target = record.hitpoint + record.normal + random_in_unit_sphere();
    ray_out = Ray(record.hitpoint, target - record.hitpoint);
    attenuation = this->albedo;
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, %r15
movq %rcx, (%rsp)
movq %rdi, %r14
leaq 0x18(%rdx), %r12
addq $0x38, %rdx
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x7ec26
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x8276a
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x7ec26
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x7ecb2
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x724c4
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8642a
addq $0x10, %r14
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x7e47e
movb $0x1, %al
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/materials/Lambertian.cpp
// Function: RayTracer::Lambertian::to_json[abi:cxx11]() const
nlohmann::json Lambertian::to_json() const {
    json j;
    
    // First, let the Material class compile
    this->baseclass_to_json(j);

    // Add our own properties
    j["albedo"] = this->albedo.to_json();
    return j;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
callq 0x56d46
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
addq $0x10, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x7e82e
leaq 0xcb2f(%rip), %rsi      # 0x92cd0
movq %rbx, %rdi
callq 0x56e34
leaq 0x8(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x6d06c
movq %r14, %rdi
callq 0x56fca
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x56fca
jmp 0x861de
movq %rax, %r14
movq %rbx, %rdi
callq 0x56fca
movq %r14, %rdi
callq 0x527a0
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/materials/Metal.cpp
// Function: RayTracer::Metal::scatter(RayTracer::Ray const&, RayTracer::HitRecord const&, RayTracer::Vec3&, RayTracer::Ray&) const
bool Metal::scatter(const Ray& ray_in, const HitRecord& record, Vec3& attenuation, Ray& ray_out) const {
    Vec3 reflected = this->reflect(ray_in.direction.normalize(), record.normal);
    ray_out = Ray(record.hitpoint, reflected + this->fuzz*random_in_unit_sphere());
    attenuation = this->albedo;
    return (dot(ray_out.direction, record.normal) > 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r8, %rbx
movq %rcx, 0x10(%rsp)
movq %rdx, %r13
movq %rdi, %r15
addq $0x20, %rsi
leaq 0x98(%rsp), %rbp
movq %rbp, %rdi
callq 0x7e7e4
leaq 0x38(%r13), %r12
movq (%r15), %rax
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r12, %rcx
callq *0x30(%rax)
addq $0x18, %r13
movsd 0x30(%r15), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x38(%rsp), %rbp
movq %rbp, %rdi
callq 0x8276a
leaq 0x58(%rsp), %r14
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movq %rbp, %rsi
callq 0x7ed9c
leaq 0x78(%rsp), %rbp
movq %rbp, %rdi
leaq 0x18(%rsp), %rsi
movq %r14, %rdx
callq 0x7ec26
leaq 0x98(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x724c4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8642a
addq $0x10, %r15
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x7e47e
addq $0x20, %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7ee56
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
seta %al
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/materials/Metal.cpp
// Function: RayTracer::Metal::to_json[abi:cxx11]() const
json Metal::to_json() const {
    json j;

    // First, let the Material class compile
    this->baseclass_to_json(j);

    // Add our own properties
    j["albedo"] = this->albedo.to_json();
    j["fuzz"] = this->fuzz;
    return j;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
callq 0x56d46
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
leaq 0x10(%r14), %rsi
leaq 0x10(%rsp), %rdi
callq 0x7e82e
leaq 0xc660(%rip), %rsi      # 0x92cd0
movq %rbx, %rdi
callq 0x56e34
leaq 0x10(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x6d06c
movq %r15, %rdi
callq 0x56fca
addq $0x30, %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0x7eee4
leaq 0xc67e(%rip), %rsi      # 0x92d24
movq %rbx, %rdi
callq 0x56e34
movq %rsp, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x6d06c
movq %r14, %rdi
callq 0x56fca
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
jmp 0x866e1
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x56fca
jmp 0x866eb
movq %rax, %r14
movq %rbx, %rdi
callq 0x56fca
movq %r14, %rdi
callq 0x527a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/materials/Dielectric.cpp
// Function: RayTracer::Dielectric::refract(RayTracer::Vec3 const&, RayTracer::Vec3 const&, double, RayTracer::Vec3&) const
bool Dielectric::refract(const Vec3& v, const Vec3& n, double ni_over_nt, Vec3& refracted) const {
    Vec3 v_normalized = v.normalize();
    double dt = dot(v_normalized, n);
    double D = 1.0 - ni_over_nt * ni_over_nt * (1 - dt * dt);
    // Only refract if there is a real solution to Snell's law
    if (D > 0) {
        refracted = ni_over_nt * (v_normalized - n * dt) - n * sqrtf64(D);
        return true;
    }
    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, %rbx
movsd %xmm0, 0x10(%rsp)
movq %rdx, %r14
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x7e7e4
movq %r15, %rdi
movq %r14, %rsi
callq 0x7ee56
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd 0x4172(%rip), %xmm3     # 0x8b040
movapd %xmm3, %xmm2
subsd %xmm1, %xmm2
movsd 0x10(%rsp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm2, %xmm1
subsd %xmm1, %xmm3
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm3
jbe 0x86f80
leaq 0x58(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movsd %xmm3, 0x8(%rsp)
callq 0x7ed6e
leaq 0x78(%rsp), %r12
leaq 0x18(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x7ecb2
leaq 0x98(%rsp), %r15
movq %r15, %rdi
movsd 0x10(%rsp), %xmm0
movq %r12, %rsi
callq 0x7ed9c
movsd 0x8(%rsp), %xmm0
callq 0x52160
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x7ed6e
leaq 0xb8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x7ecb2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7e47e
xorpd %xmm1, %xmm1
movsd 0x8(%rsp), %xmm3
ucomisd %xmm1, %xmm3
seta %al
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/materials/Dielectric.cpp
// Function: RayTracer::Dielectric::to_json[abi:cxx11]() const
json Dielectric::to_json() const {
    json j;
    
    // First, let the Material class compile
    this->baseclass_to_json(j);

    // Add our own properties
    j["albedo"] = this->albedo.to_json();
    j["ref_idx"] = this->ref_idx;
    return j;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
callq 0x56d46
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
leaq 0x10(%r14), %rsi
leaq 0x10(%rsp), %rdi
callq 0x7e82e
leaq 0xbca4(%rip), %rsi      # 0x92cd0
movq %rbx, %rdi
callq 0x56e34
leaq 0x10(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x6d06c
movq %r15, %rdi
callq 0x56fca
addq $0x30, %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0x7eee4
leaq 0xbd0e(%rip), %rsi      # 0x92d70
movq %rbx, %rdi
callq 0x56e34
movq %rsp, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x6d06c
movq %r14, %rdi
callq 0x56fca
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
jmp 0x8709d
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x56fca
jmp 0x870a7
movq %rax, %r14
movq %rbx, %rdi
callq 0x56fca
movq %r14, %rdi
callq 0x527a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/animations/camera/CameraRotation.cpp
// Function: RayTracer::CameraRotation::recompute(RayTracer::Camera*)
void CameraRotation::recompute(Camera* target) {
    Vec3 lookat = target->lookat;
    Vec3 lookfrom = target->lookfrom;
    Vec3 lookfrom_circle(lookfrom.x, 0, lookfrom.z);

    this->center = Vec3(lookat.x, 0, lookat.z);
    this->angle = acosf64(dot(Vec3(0, 0, 1), (lookfrom_circle - center).normalize()));
    this->radius = (lookfrom_circle - this->center).length();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movsd 0x48(%rsi), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x58(%rsi), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x28(%rsi), %xmm0
movsd 0x38(%rsi), %xmm2
leaq 0x78(%rsp), %r14
xorps %xmm1, %xmm1
movq %r14, %rdi
callq 0x7e464
leaq 0x18(%rsp), %r12
xorps %xmm1, %xmm1
movq %r12, %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm2
callq 0x7e464
leaq 0x10(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x7e47e
leaq 0x18(%rsp), %r12
movsd 0x312a(%rip), %xmm2     # 0x8b040
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %r12, %rdi
callq 0x7e464
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x7ecb2
leaq 0x58(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x7e7e4
movq %r12, %rdi
movq %rbp, %rsi
callq 0x7ee56
callq 0x52420
movsd %xmm0, 0x38(%rbx)
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x7ecb2
movq %r12, %rdi
callq 0x7e7b0
movsd %xmm0, 0x30(%rbx)
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/animations/camera/CameraRotation.cpp
// Function: RayTracer::CameraRotation::update(std::chrono::duration<long, std::ratio<1l, 1000l>>, RayTracer::Camera*)
void CameraRotation::update(chrono::milliseconds time_passed, Camera* target) {
    // Set the camera lookfrom to this new position
    target->lookfrom = Vec3(
        this->center.x + cosf64(this->angle) * this->radius,
        target->lookfrom.y,
        this->center.z + sinf64(this->angle) * this->radius
    );

    this->angle += this->speed * time_passed.count();
    while (this->angle >= 2 * M_PI) {
        this->angle -= 2 * M_PI;
    }

    // Recompute the camera variables
    target->recompute();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movsd 0x18(%rdi), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x38(%rdi), %xmm0
callq 0x52130
mulsd 0x30(%r14), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x20(%rbx), %r12
movsd 0x30(%rbx), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x28(%r14), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x38(%r14), %xmm0
callq 0x522c0
mulsd 0x30(%r14), %xmm0
movsd 0x10(%rsp), %xmm2
addsd %xmm0, %xmm2
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x7e464
movq %r12, %rdi
movq %r13, %rsi
callq 0x7e47e
cvtsi2sd %r15, %xmm0
mulsd 0x40(%r14), %xmm0
addsd 0x38(%r14), %xmm0
movsd 0xaea2(%rip), %xmm1     # 0x92ee0
movsd 0xaea2(%rip), %xmm2     # 0x92ee8
ucomisd %xmm1, %xmm0
jb 0x88052
addsd %xmm2, %xmm0
jmp 0x88046
movsd %xmm0, 0x38(%r14)
movq %rbx, %rdi
callq 0x83462
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/animations/camera/CameraRotation.cpp
// Function: RayTracer::CameraRotation::to_json[abi:cxx11]() const
json CameraRotation::to_json() const {
    json j;
    
    // First, let the parent add their general properties
    this->baseclass_to_json(j);

    // Now, add our own
    j["loop_time"] = this->loop_time.count();

    return j;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
callq 0x56d46
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
movq 0x48(%r14), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdi
callq 0x88452
leaq 0xae48(%rip), %rsi      # 0x92ef0
movq %rbx, %rdi
callq 0x56e34
movq %rsp, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x6d06c
movq %r14, %rdi
callq 0x56fca
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x56fca
jmp 0x880e1
movq %rax, %r14
movq %rbx, %rdi
callq 0x56fca
movq %r14, %rdi
callq 0x527a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/BoundingBox.cpp
// Function: RayTracer::BoundingBox::hit(RayTracer::Ray const&, double, double) const
bool BoundingBox::hit(const Ray& ray, double t_min, double t_max) const {
    // Fetch the correct order of the hits
    for (int i = 0; i < 3; i++) {
        // Compute the t's
        double invD = 1.0 / ray.direction.get(i);
        double t0 = (this->p1.get(i) - ray.origin.get(i)) * invD;
        double t1 = (this->p2.get(i) - ray.origin.get(i)) * invD;
        if (invD < 0.0) {
            std::swap(t0, t1);
        }

        // Mix in the given min and max t values
        t_min = t0 > t_min ? t0 : t_min;
        t_max = t1 < t_max ? t1 : t_max;

        if (t_max <= t_min) {
            return false;
        }
    }
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsi), %r15
leaq 0x20(%rdi), %r12
xorl %eax, %eax
movl %eax, %r13d
cmpl $0x3, %eax
je 0x8868f
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x18(%rsp)
movq %r15, %rdi
movl %r13d, %esi
callq 0x7e6e0
movsd 0x2a60(%rip), %xmm1     # 0x8b040
divsd %xmm0, %xmm1
movapd %xmm1, 0x20(%rsp)
movq %r14, %rdi
movl %r13d, %esi
callq 0x7e6e0
movapd %xmm0, (%rsp)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x7e6e0
movapd (%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x20(%rsp), %xmm1
movapd %xmm1, (%rsp)
movq %r12, %rdi
movl %r13d, %esi
callq 0x7e6e0
movapd %xmm0, 0x30(%rsp)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x7e6e0
movapd 0x30(%rsp), %xmm4
movapd (%rsp), %xmm3
movapd 0x20(%rsp), %xmm2
xorpd %xmm1, %xmm1
subsd %xmm0, %xmm4
mulsd %xmm2, %xmm4
ucomisd %xmm2, %xmm1
movapd %xmm4, %xmm0
ja 0x88660
movapd %xmm3, %xmm0
maxsd 0x10(%rsp), %xmm0
cmpltsd %xmm1, %xmm2
andpd %xmm2, %xmm3
andnpd %xmm4, %xmm2
orpd %xmm3, %xmm2
minsd 0x18(%rsp), %xmm2
leal 0x1(%r13), %eax
ucomisd %xmm2, %xmm0
movapd %xmm2, %xmm1
jb 0x885b5
cmpl $0x3, %r13d
setae %al
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/BoundingBox.cpp
// Function: RayTracer::BoundingBox::merge(RayTracer::BoundingBox const&)
void BoundingBox::merge(const BoundingBox& other) {
    // For each of the three dimensions, find the smallest and put that in
    //   this->p1. The larger is put in this->p2.
    for (int i = 0; i < 3; i++) {
        double a1 = this->p1.get(i);
        double a2 = this->p2.get(i);
        double b1 = other.p1.get(i);
        double b2 = other.p2.get(i);

        // Order the A-box values
        double min = a1;
        double max = a2;
        if (min > max) {
            min = max;
            max = a1;
        }

        // Add the B-box values
        if (b1 < min) {
            min = b1;
        } else if (b1 > max) {
            max = b1;
        }
        if (b2 < min) {
            min = b2;
        } else if (b2 > max) {
            max = b2;
        }

        // Set the values and return
        this->p1[i] = min;
        this->p2[i] = max;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rdi), %r15
leaq 0x20(%rsi), %r12
xorl %ebp, %ebp
cmpl $0x3, %ebp
je 0x8878e
movq %r14, %rdi
movl %ebp, %esi
callq 0x7e6e0
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
movl %ebp, %esi
callq 0x7e6e0
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7e6e0
movsd %xmm0, 0x18(%rsp)
movq %r12, %rdi
movl %ebp, %esi
callq 0x7e6e0
movsd 0x8(%rsp), %xmm3
movsd 0x18(%rsp), %xmm2
movsd 0x10(%rsp), %xmm4
movapd %xmm4, %xmm1
minsd %xmm3, %xmm1
maxsd %xmm4, %xmm3
ucomisd %xmm2, %xmm1
jbe 0x8872d
movapd %xmm2, %xmm1
jmp 0x88733
ucomisd %xmm3, %xmm2
ja 0x88737
movapd %xmm3, %xmm2
ucomisd %xmm0, %xmm1
jbe 0x88745
movsd %xmm0, 0x10(%rsp)
jmp 0x88759
ucomisd %xmm2, %xmm0
movsd %xmm1, 0x10(%rsp)
jbe 0x88759
movsd %xmm0, 0x8(%rsp)
jmp 0x8875f
movsd %xmm2, 0x8(%rsp)
movq %r14, %rdi
movl %ebp, %esi
callq 0x7e60e
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movq %r15, %rdi
movl %ebp, %esi
callq 0x7e60e
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
incl %ebp
jmp 0x886c0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/BoundingBox.cpp
// Function: RayTracer::BoundingBox::size() const
double BoundingBox::size() const {
    double dx = fabsf64(this->p1.x - this->p2.x);
    double dy = fabsf64(this->p1.y - this->p2.y);
    double dz = fabsf64(this->p1.z - this->p2.z);
    return dx * dy * dz;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0x8(%rdi), %xmm0
subsd 0x28(%rdi), %xmm0
callq 0x527e0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rbx), %xmm0
subsd 0x30(%rbx), %xmm0
callq 0x527e0
movsd %xmm0, (%rsp)
movsd 0x18(%rbx), %xmm0
subsd 0x38(%rbx), %xmm0
callq 0x527e0
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/ObjectTree.cpp
// Function: print_vec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<RayTracer::RenderObject*, std::allocator<RayTracer::RenderObject*>> const&)
void print_vec(string name, const vector<RenderObject*>& vec) {
    cout << name << " {";
    for (size_t i = 0; i < vec.size(); i++) {
        if (i > 0) { cout << ", "; }
        cout << vec.at(i);
    }
    cout << "}" << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %rsi
movq 0x2977f(%rip), %r14     # 0xb1f88
movq %r14, %rdi
callq 0x52400
leaq 0xa738(%rip), %rsi      # 0x92f50
movq %rax, %rdi
callq 0x52450
xorl %r15d, %r15d
leaq 0x7bf6(%rip), %r12      # 0x90420
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
cmpq %rax, %r15
jae 0x88865
testq %r15, %r15
je 0x8884a
movq %r14, %rdi
movq %r12, %rsi
callq 0x52450
movq %rbx, %rdi
movq %r15, %rsi
callq 0x823b2
movq (%rax), %rsi
movq %r14, %rdi
callq 0x52380
incq %r15
jmp 0x8882a
movq 0x2971c(%rip), %rdi     # 0xb1f88
leaq 0xa6e0(%rip), %rsi      # 0x92f53
callq 0x52450
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x52210