LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Lut99[P]RayTracer/src/lib/Vec3.cpp
// Function: RayTracer::operator+(double, RayTracer::Vec3 const&)
Vec3 RayTracer::operator+(const double n, const Vec3& v2) {
    return Vec3(
        n + v2.x,
        n + v2.y,
        n + v2.z
    );
}

// Assembly:
subq $0x28, %rsp
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
movq 0x10(%rsp), %rax
addsd 0x8(%rax), %xmm0
movsd 0x18(%rsp), %xmm1
movq 0x10(%rsp), %rax
addsd 0x10(%rax), %xmm1
movsd 0x18(%rsp), %xmm2
movq 0x10(%rsp), %rax
addsd 0x18(%rax), %xmm2
callq 0x154750
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/Vec3.cpp
// Function: RayTracer::cross(RayTracer::Vec3 const&, RayTracer::Vec3 const&)
Vec3 RayTracer::cross(const Vec3& v1, const Vec3& v2) {
    return Vec3(
        v1.y * v2.z - v1.z * v2.y,
        v1.z * v2.x - v1.x * v2.z,
        v1.x * v2.y - v1.y * v2.x
    );
}

// Assembly:
subq $0x28, %rsp
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq 0x10(%rsp), %rax
movsd 0x18(%rax), %xmm2
movq 0x18(%rsp), %rax
movsd 0x18(%rax), %xmm1
movq 0x10(%rsp), %rax
mulsd 0x10(%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x18(%rsp), %rax
movsd 0x18(%rax), %xmm1
movq 0x10(%rsp), %rax
movsd 0x8(%rax), %xmm3
movq 0x18(%rsp), %rax
movsd 0x8(%rax), %xmm2
movq 0x10(%rsp), %rax
mulsd 0x18(%rax), %xmm2
movq %xmm2, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
movq 0x18(%rsp), %rax
movsd 0x8(%rax), %xmm2
movq 0x10(%rsp), %rax
movsd 0x10(%rax), %xmm4
movq 0x18(%rsp), %rax
movsd 0x10(%rax), %xmm3
movq 0x10(%rsp), %rax
mulsd 0x8(%rax), %xmm3
movq %xmm3, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm3
mulsd %xmm4, %xmm2
addsd %xmm3, %xmm2
callq 0x154750
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: Lut99[P]RayTracer/src/lib/include/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::operator[](unsigned long) const
const_reference operator[](size_type idx) const
    {
        // const operator[] only works for arrays
        if (JSON_HEDLEY_LIKELY(is_array()))
        {
            return m_value.array->operator[](idx);
        }

        JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name())));
    }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xefa20
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x157210
jmp 0x15722b
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x78(%rsp), %rsi
callq 0x157330
addq $0x88, %rsp
retq
movb $0x1, 0x23(%rsp)
movl $0x20, %edi
callq 0xd02b0
movq 0x18(%rsp), %rdi
movq %rax, (%rsp)
callq 0x1302d0
movq %rax, 0x8(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xd0a20
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0xd8b80
jmp 0x157272
leaq 0x2079e(%rip), %rsi     # 0x177a17
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x12d820
jmp 0x15728a
movq (%rsp), %rdi
movl $0x131, %esi            # imm = 0x131
leaq 0x58(%rsp), %rdx
callq 0x130170
jmp 0x15729f
movq (%rsp), %rdi
movb $0x0, 0x23(%rsp)
leaq 0x540d9(%rip), %rsi     # 0x1ab388
leaq -0x26f46(%rip), %rdx    # 0x130370
callq 0xd09b0
jmp 0x157327
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x1572ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x1572f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xd0b38
leaq 0x38(%rsp), %rdi
callq 0xd0b38
leaq 0x37(%rsp), %rdi
callq 0xd0630
testb $0x1, 0x23(%rsp)
jne 0x157312
jmp 0x15731b
movq (%rsp), %rdi
callq 0xd0430
jmp 0x15731d
movq 0x28(%rsp), %rdi
callq 0xd0a10
nopw (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/objects/Sphere.cpp
// Function: RayTracer::Sphere::Sphere(RayTracer::Vec3 const&, double, RayTracer::Material*)
Sphere::Sphere(const Vec3& center, double radius, Material* material)
    : RenderObject(center, sphere)
{
    this->radius = radius;
    this->material = material;

    // Be sure to compute the hitbox
    this->has_hitbox = this->compute_hit_box();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x28(%rsp), %rsi
xorl %edx, %edx
callq 0x159630
movq (%rsp), %rdi
leaq 0x50967(%rip), %rax     # 0x1ab690
movq %rax, (%rdi)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x80(%rdi)
movq 0x18(%rsp), %rax
movq %rax, 0x88(%rdi)
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
movb %al, 0xb(%rsp)
jmp 0x15ad55
movq (%rsp), %rax
movb 0xb(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x78(%rax)
addq $0x38, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
callq 0x15a950
movq 0x10(%rsp), %rdi
callq 0xd0a10
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/objects/Sphere.cpp
// Function: RayTracer::Sphere::Sphere(RayTracer::Sphere const&)
Sphere::Sphere(const Sphere& other)
    : RenderObject(other.center, sphere)
{
    this->radius = other.radius;
    this->material = other.material->clone();

    // Also copy the hitbox
    this->has_hitbox = other.has_hitbox;
    if (this->has_hitbox) {
        this->box = BoundingBox(other.box);
    }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x68(%rsp), %rsi
addq $0x18, %rsi
xorl %edx, %edx
callq 0x159630
movq 0x8(%rsp), %rax
leaq 0x508cc(%rip), %rcx     # 0x1ab690
movq %rcx, (%rax)
movq 0x68(%rsp), %rcx
movsd 0x80(%rcx), %xmm0
movsd %xmm0, 0x80(%rax)
movq 0x68(%rsp), %rax
movq 0x88(%rax), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq %rax, 0x10(%rsp)
jmp 0x15adf8
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x88(%rax)
movq 0x68(%rsp), %rcx
movb 0x78(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x78(%rax)
testb $0x1, 0x78(%rax)
je 0x15ae64
movq 0x68(%rsp), %rsi
addq $0x38, %rsi
leaq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x15c220
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
addq $0x38, %rdi
callq 0x15c260
jmp 0x15ae48
jmp 0x15ae64
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
callq 0x15a950
jmp 0x15ae69
addq $0x78, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0xd0a10
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/objects/Sphere.cpp
// Function: RayTracer::Sphere::Sphere(RayTracer::Sphere&&)
Sphere::Sphere(Sphere&& other)
    : RenderObject(other.center, sphere)
{
    this->radius = other.radius;
    this->material = other.material;
    other.material = nullptr;

    // Also copy the hitbox
    this->has_hitbox = other.has_hitbox;
    if (this->has_hitbox) {
        this->box = other.box;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x18(%rsp), %rsi
addq $0x18, %rsi
xorl %edx, %edx
callq 0x159630
movq (%rsp), %rax
leaq 0x507ce(%rip), %rcx     # 0x1ab680
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movsd 0x80(%rcx), %xmm0
movsd %xmm0, 0x80(%rax)
movq 0x18(%rsp), %rcx
movq 0x88(%rcx), %rcx
movq %rcx, 0x88(%rax)
movq 0x18(%rsp), %rcx
movq $0x0, 0x88(%rcx)
movq 0x18(%rsp), %rcx
movb 0x78(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x78(%rax)
testb $0x1, 0x78(%rax)
je 0x15af38
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x38, %rsi
addq $0x38, %rdi
callq 0x15c2a0
jmp 0x15af1d
jmp 0x15af38
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
callq 0x15a950
jmp 0x15af3d
addq $0x28, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0xd0a10
nopw (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/objects/Sphere.cpp
// Function: RayTracer::Sphere::to_json[abi:cxx11]() const
json Sphere::to_json() const {
    json j;

    // First, let the parent class parse all it wants
    this->baseclass_to_json(j);
    
    // Add child-specific properties
    j["center"] = this->center.to_json();
    j["radius"] = this->radius;
    j["material"] = this->material->to_json();
    return j;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x30(%rsp)
movb $0x0, 0x87(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0xd99c0
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0x15b586
movq 0x30(%rsp), %rsi
addq $0x18, %rsi
leaq 0x60(%rsp), %rdi
callq 0x154f50
jmp 0x15b59b
movq 0x38(%rsp), %rdi
leaq 0x1c826(%rip), %rsi     # 0x177dcd
callq 0xd9b40
movq %rax, 0x20(%rsp)
jmp 0x15b5b3
movq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movq %rsi, 0x10(%rsp)
callq 0x128ba0
movq 0x10(%rsp), %rdi
callq 0xd9f30
movq 0x30(%rsp), %rsi
subq $-0x80, %rsi
leaq 0x50(%rsp), %rdi
callq 0x155e80
movq 0x38(%rsp), %rdi
leaq 0x1c7e4(%rip), %rsi     # 0x177dd4
callq 0xd9b40
movq %rax, 0x18(%rsp)
jmp 0x15b5fc
movq 0x18(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movq %rsi, 0x8(%rsp)
callq 0x128ba0
movq 0x8(%rsp), %rdi
callq 0xd9f30
movq 0x30(%rsp), %rax
movq 0x88(%rax), %rsi
movq (%rsi), %rax
movq 0x28(%rax), %rax
leaq 0x40(%rsp), %rdi
callq *%rax
jmp 0x15b636
movq 0x38(%rsp), %rdi
leaq 0x1c799(%rip), %rsi     # 0x177ddb
callq 0xd9b40
movq %rax, (%rsp)
jmp 0x15b64d
movq (%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x128ba0
leaq 0x40(%rsp), %rdi
callq 0xd9f30
movb $0x1, 0x87(%rsp)
testb $0x1, 0x87(%rsp)
jne 0x15b6e1
jmp 0x15b6d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x15b6ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xd9f30
jmp 0x15b6ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xd9f30
jmp 0x15b6ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xd9f30
jmp 0x15b6ee
movq 0x38(%rsp), %rdi
callq 0xd9f30
movq 0x28(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xd9f30
movq 0x78(%rsp), %rdi
callq 0xd0a10
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/objects/RenderObjectCollection.cpp
// Function: RayTracer::RenderObjectCollection::compute_center(std::vector<RayTracer::RenderObject*, std::allocator<RayTracer::RenderObject*>>) const
Vec3 RenderObjectCollection::compute_center(vector<RenderObject*> objects) const {
    Vec3 average;
    for (std::size_t i = 0; i < objects.size(); i++) {
        average += objects[i]->center;
    }
    return average / (double) objects.size();
}

// Assembly:
subq $0x68, %rsp
movq %rdx, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x154710
movq $0x0, 0x28(%rsp)
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x15d790
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x15c369
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x15d7b0
movq (%rax), %rsi
addq $0x18, %rsi
leaq 0x30(%rsp), %rdi
callq 0x154810
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x15c318
movq 0x10(%rsp), %rdi
callq 0x15d790
movq 0x18(%rsp), %rdi
movq %rax, %xmm0
movaps 0x1b5ac(%rip), %xmm1    # 0x177930
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x1b5b0(%rip), %xmm1    # 0x177940
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
leaq 0x30(%rsp), %rsi
callq 0x155bb0
movq 0x20(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/objects/RenderObjectCollection.cpp
// Function: RayTracer::RenderObjectCollection::RenderObjectCollection(std::vector<RayTracer::RenderObject*, std::allocator<RayTracer::RenderObject*>>)
RenderObjectCollection::RenderObjectCollection(vector<RenderObject*> objects)
    : RenderObject(this->compute_center(objects), render_object_collection)
{
    // Store this vector by copying
    this->objects = vector<RenderObject*>(objects);

    // Be sure to compute the hitbox
    this->has_hitbox = this->compute_hit_box();
}

// Assembly:
subq $0xa8, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x4f328(%rip), %rcx     # 0x1ab718
movq %rcx, (%rax)
leaq 0x60(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x15d7d0
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x78(%rsp), %rdi
callq 0x15c2e0
jmp 0x15c418
movq 0x28(%rsp), %rdi
leaq 0x78(%rsp), %rsi
movl $0x1, %edx
callq 0x159630
jmp 0x15c42e
leaq 0x60(%rsp), %rdi
callq 0x15d8d0
movq 0x28(%rsp), %rdi
leaq 0x4f2d4(%rip), %rax     # 0x1ab718
movq %rax, (%rdi)
subq $-0x80, %rdi
movq %rdi, 0x18(%rsp)
callq 0x15d930
movq 0x20(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x15d7d0
jmp 0x15c466
movq 0x28(%rsp), %rdi
subq $-0x80, %rdi
leaq 0x38(%rsp), %rsi
movq %rsi, 0x8(%rsp)
callq 0x15d940
movq 0x8(%rsp), %rdi
callq 0x15d8d0
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
movb %al, 0x17(%rsp)
jmp 0x15c49c
movq 0x28(%rsp), %rax
movb 0x17(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x78(%rax)
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x15d8d0
jmp 0x15c4ef
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
callq 0x15d8d0
movq 0x28(%rsp), %rdi
callq 0x15a950
movq 0x58(%rsp), %rdi
callq 0xd0a10
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/objects/RenderObjectCollection.cpp
// Function: RayTracer::RenderObjectCollection::RenderObjectCollection(RayTracer::RenderObjectCollection const&)
RenderObjectCollection::RenderObjectCollection(const RenderObjectCollection& other)
    : RenderObject(other.center, render_object_collection)
{
    // Copy the vector of the other
    this->objects = vector<RenderObject*>(other.objects);

    // Copy the hitbox vectors if needed
    this->has_hitbox = other.has_hitbox;
    if (this->has_hitbox) {
        this->box = BoundingBox(other.box);
    }
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x88(%rsp), %rsi
addq $0x18, %rsi
movl $0x1, %edx
callq 0x159630
movq 0x10(%rsp), %rdi
leaq 0x4f1d2(%rip), %rax     # 0x1ab718
movq %rax, (%rdi)
subq $-0x80, %rdi
movq %rdi, 0x18(%rsp)
callq 0x15d930
movq 0x88(%rsp), %rsi
subq $-0x80, %rsi
leaq 0x70(%rsp), %rdi
callq 0x15d7d0
jmp 0x15c56f
movq 0x10(%rsp), %rdi
addq $0x80, %rdi
leaq 0x70(%rsp), %rsi
callq 0x15d940
leaq 0x70(%rsp), %rdi
callq 0x15d8d0
movq 0x10(%rsp), %rax
movq 0x88(%rsp), %rcx
movb 0x78(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x78(%rax)
testb $0x1, 0x78(%rax)
je 0x15c601
movq 0x88(%rsp), %rsi
addq $0x38, %rsi
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x15c220
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x38, %rdi
callq 0x15c260
jmp 0x15c5db
jmp 0x15c601
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
callq 0x15d8d0
movq 0x10(%rsp), %rdi
callq 0x15a950
jmp 0x15c609
addq $0x98, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0xd0a10
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/objects/RenderObjectCollection.cpp
// Function: RayTracer::RenderObjectCollection::RenderObjectCollection(RayTracer::RenderObjectCollection&&)
RenderObjectCollection::RenderObjectCollection(RenderObjectCollection&& other)
    : RenderObject(other.center, render_object_collection)
{
    // Steal the vector
    this->objects = std::move(other.objects);
    other.objects = vector<RenderObject*>();

    // Also steal the vectors (if needed)
    this->has_hitbox = other.has_hitbox;
    if (this->has_hitbox) {
        this->box = other.box;
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x38(%rsp), %rsi
addq $0x18, %rsi
movl $0x1, %edx
callq 0x159630
movq 0x8(%rsp), %rdi
leaq 0x4f0b1(%rip), %rax     # 0x1ab708
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x80, %rdi
movq %rdi, (%rsp)
callq 0x15d930
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi
addq $0x80, %rsi
addq $0x80, %rdi
callq 0x15d940
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0xd0300
leaq 0x20(%rsp), %rdi
callq 0x15d930
movq 0x38(%rsp), %rdi
addq $0x80, %rdi
leaq 0x20(%rsp), %rsi
callq 0x15d940
leaq 0x20(%rsp), %rdi
callq 0x15d8d0
movq 0x8(%rsp), %rax
movq 0x38(%rsp), %rcx
movb 0x78(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x78(%rax)
testb $0x1, 0x78(%rax)
je 0x15c71d
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi
addq $0x38, %rsi
addq $0x38, %rdi
callq 0x15c2a0
jmp 0x15c6f8
jmp 0x15c71d
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x15d8d0
movq 0x8(%rsp), %rdi
callq 0x15a950
jmp 0x15c722
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xd0a10
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/objects/RenderObjectCollection.cpp
// Function: RayTracer::RenderObjectCollection::compute_hit_box()
bool RenderObjectCollection::compute_hit_box() {
    // If there are no elements, there is no box
    size_t s = this->size();
    if (s < 1) {
        return false;
    }

    // Otherwise, get the box of the first one if it has one
    if (!this->objects.at(0)->has_hitbox) {
        return false;
    }
    this->box.p1 = this->objects.at(0)->box.p1;
    this->box.p2 = this->objects.at(0)->box.p2;

    // Combine the boxes into an increasingly larger box
    for (size_t i = 1; i < s; i++) {
        if (!this->objects.at(i)->has_hitbox) {
            return false;
        }

        this->box.merge(this->objects.at(i)->box);
    }

    return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x15c8f0
movq %rax, 0x20(%rsp)
cmpq $0x1, 0x20(%rsp)
jae 0x15c7cf
movb $0x0, 0x37(%rsp)
jmp 0x15c8d6
movq 0x10(%rsp), %rdi
addq $0x80, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15d980
movq (%rax), %rax
testb $0x1, 0x78(%rax)
jne 0x15c7f7
movb $0x0, 0x37(%rsp)
jmp 0x15c8d6
movq 0x10(%rsp), %rdi
addq $0x80, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15d980
movq 0x10(%rsp), %rdi
movq (%rax), %rsi
addq $0x38, %rsi
addq $0x38, %rdi
callq 0x1547a0
movq 0x10(%rsp), %rdi
addq $0x80, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15d980
movq 0x10(%rsp), %rdi
movq (%rax), %rsi
addq $0x38, %rsi
addq $0x20, %rsi
addq $0x38, %rdi
addq $0x20, %rdi
callq 0x1547a0
movq $0x1, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x15c8d1
movq 0x10(%rsp), %rdi
addq $0x80, %rdi
movq 0x18(%rsp), %rsi
callq 0x15d980
movq (%rax), %rax
testb $0x1, 0x78(%rax)
jne 0x15c88e
movb $0x0, 0x37(%rsp)
jmp 0x15c8d6
movq 0x10(%rsp), %rdi
movq %rdi, %rax
addq $0x38, %rax
movq %rax, 0x8(%rsp)
addq $0x80, %rdi
movq 0x18(%rsp), %rsi
callq 0x15d980
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
addq $0x38, %rsi
callq 0x16ad60
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x15c85c
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/objects/RenderObjectCollection.cpp
// Function: RayTracer::RenderObjectCollection::hit(RayTracer::Ray const&, double, double, RayTracer::HitRecord&) const
bool RenderObjectCollection::hit(const Ray& ray, double t_min, double t_max, HitRecord& record) const {
    HitRecord temp_record;
    double t_best = t_max;
    bool hit = false;
    // Loop until we found the hit with the smallest t. By overriding t_max, we can easily and elegantly do this.
    for (std::size_t i = 0; i < this->objects.size(); i++) {
        if (this->objects[i]->quick_hit(ray, t_min, t_best) && this->objects[i]->hit(ray, t_min, t_best, temp_record)) {
            hit = true;
            t_best = temp_record.t;
            record = temp_record;
        }
    }
    return hit;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movsd %xmm0, 0xa0(%rsp)
movsd %xmm1, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x15d9c0
movsd 0x98(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movb $0x0, 0x1f(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
addq $0x80, %rdi
callq 0x15d790
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x15ca54
movq 0x8(%rsp), %rdi
addq $0x80, %rdi
movq 0x10(%rsp), %rsi
callq 0x15d9f0
movq (%rax), %rdi
movq 0xa8(%rsp), %rsi
movsd 0xa0(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movq (%rdi), %rax
callq *0x20(%rax)
testb $0x1, %al
jne 0x15c9db
jmp 0x15ca3f
movq 0x8(%rsp), %rdi
addq $0x80, %rdi
movq 0x10(%rsp), %rsi
callq 0x15d9f0
movq (%rax), %rdi
movq 0xa8(%rsp), %rsi
movsd 0xa0(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movq (%rdi), %rax
leaq 0x28(%rsp), %rdx
callq *0x30(%rax)
testb $0x1, %al
jne 0x15ca1c
jmp 0x15ca3f
movb $0x1, 0x1f(%rsp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x90(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x15da10
jmp 0x15ca41
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x15c975
movb 0x1f(%rsp), %al
andb $0x1, %al
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x28(%rsp)
movb $0x0, 0x87(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0xd99c0
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0x15cd36
leaq 0x50(%rsp), %rdi
callq 0x155e60
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x155e10
jmp 0x15cd56
movq 0x30(%rsp), %rdi
leaq 0x14564(%rip), %rsi     # 0x1712c6
callq 0xd9b40
movq %rax, 0x18(%rsp)
jmp 0x15cd6e
movq 0x18(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x128ba0
leaq 0x60(%rsp), %rdi
callq 0xd9f30
movq $0x0, 0x48(%rsp)
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x80, %rdi
callq 0x15d790
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x15ce7e
movq 0x28(%rsp), %rdi
subq $-0x80, %rdi
movq 0x48(%rsp), %rsi
callq 0x15d9f0
movq (%rax), %rsi
movq (%rsi), %rax
movq 0x58(%rax), %rax
leaq 0x38(%rsp), %rdi
callq *%rax
jmp 0x15cde2
movq 0x30(%rsp), %rdi
leaq 0x144d8(%rip), %rsi     # 0x1712c6
callq 0xd9b40
movq %rax, 0x8(%rsp)
jmp 0x15cdfa
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x155ed0
movq %rax, (%rsp)
jmp 0x15ce0f
movq (%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x128ba0
leaq 0x38(%rsp), %rdi
callq 0xd9f30
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0x15cd90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x15cea7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xd9f30
jmp 0x15cea7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xd9f30
jmp 0x15cea7
movb $0x1, 0x87(%rsp)
testb $0x1, 0x87(%rsp)
jne 0x15ce9a
movq 0x30(%rsp), %rdi
callq 0xd9f30
movq 0x20(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xd9f30
movq 0x78(%rsp), %rdi
callq 0xd0a10
nopl (%rax,%rax)
// File: 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:
subq $0x13a8, %rsp           # imm = 0x13A8
cmpb $0x0, 0x4e622(%rip)     # 0x1ad2d0
jne 0x15ece6
leaq 0x4e619(%rip), %rdi     # 0x1ad2d0
callq 0xd0a40
cmpl $0x0, %eax
je 0x15ece6
leaq 0x4e5f8(%rip), %rdi     # 0x1ad2c0
xorps %xmm0, %xmm0
movsd 0x1136d(%rip), %xmm1    # 0x170040
callq 0x15efa0
jmp 0x15ecda
leaq 0x4e5ef(%rip), %rdi     # 0x1ad2d0
callq 0xd03c0
cmpb $0x0, 0x4f973(%rip)     # 0x1ae660
jne 0x15ed1a
leaq 0x4f96a(%rip), %rdi     # 0x1ae660
callq 0xd0a40
cmpl $0x0, %eax
je 0x15ed1a
leaq 0x4e5d1(%rip), %rdi     # 0x1ad2d8
callq 0x15efd0
jmp 0x15ed0e
leaq 0x4f94b(%rip), %rdi     # 0x1ae660
callq 0xd03c0
cmpb $0x0, 0x4f967(%rip)     # 0x1ae688
jne 0x15ed83
leaq 0x4f95e(%rip), %rdi     # 0x1ae688
callq 0xd0a40
cmpl $0x0, %eax
je 0x15ed83
leaq 0x4e585(%rip), %rsi     # 0x1ad2c0
leaq 0x4e596(%rip), %rdx     # 0x1ad2d8
movq %rsp, %rdi
callq 0x15eff0
jmp 0x15ed4c
leaq 0x4f915(%rip), %rdi     # 0x1ae668
movq %rsp, %rsi
callq 0x15f030
jmp 0x15ed5d
leaq 0x37c(%rip), %rdi       # 0x15f0e0
leaq 0x4f8fd(%rip), %rsi     # 0x1ae668
leaq 0x4d836(%rip), %rdx     # 0x1ac5a8
callq 0xd0530
leaq 0x4f90a(%rip), %rdi     # 0x1ae688
callq 0xd03c0
leaq 0x4f8de(%rip), %rdi     # 0x1ae668
callq 0x15f0f0
addq $0x13a8, %rsp           # imm = 0x13A8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x13a0(%rsp)
movl %eax, 0x139c(%rsp)
leaq 0x4e51e(%rip), %rdi     # 0x1ad2d0
callq 0xd03b0
jmp 0x15edfb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x13a0(%rsp)
movl %eax, 0x139c(%rsp)
leaq 0x4f88c(%rip), %rdi     # 0x1ae660
callq 0xd03b0
jmp 0x15edfb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x13a0(%rsp)
movl %eax, 0x139c(%rsp)
leaq 0x4f892(%rip), %rdi     # 0x1ae688
callq 0xd03b0
movq 0x13a0(%rsp), %rdi
callq 0xd0a10
nopl (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
callq 0x154710
callq 0x15eca0
movsd %xmm0, 0x8(%rsp)
callq 0x15eca0
movsd %xmm0, (%rsp)
callq 0x15eca0
movsd (%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
leaq 0x20(%rsp), %rdi
callq 0x154750
leaq 0x40(%rsp), %rdi
movsd 0x111f0(%rip), %xmm0    # 0x170060
leaq 0x20(%rsp), %rsi
callq 0x155ae0
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movsd 0x111b4(%rip), %xmm0    # 0x170040
callq 0x155950
movq 0x10(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x1547a0
movq 0x10(%rsp), %rdi
callq 0x154eb0
movsd 0x1118e(%rip), %xmm1    # 0x170040
ucomisd %xmm1, %xmm0
jae 0x15ee31
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
nopl (%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0xa0(%rsp)
callq 0x154710
callq 0x15eca0
movsd %xmm0, 0x8(%rsp)
callq 0x15eca0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
leaq 0x40(%rsp), %rdi
xorps %xmm2, %xmm2
callq 0x154750
leaq 0x60(%rsp), %rdi
movsd 0x1113c(%rip), %xmm0    # 0x170060
leaq 0x40(%rsp), %rsi
callq 0x155ae0
leaq 0x20(%rsp), %rdi
movsd 0x11105(%rip), %xmm1    # 0x170040
xorps %xmm2, %xmm2
movaps %xmm1, %xmm0
callq 0x154750
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x1558e0
movq 0x10(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x1547a0
movq 0x10(%rsp), %rsi
movq %rsi, %rdi
callq 0x155c70
movsd 0x110bc(%rip), %xmm1    # 0x170040
ucomisd %xmm1, %xmm0
jae 0x15eef1
movq 0x18(%rsp), %rax
addq $0xa8, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
addq $0x20, %rdi
movq %rdi, 0x20(%rsp)
callq 0xd07e0
movq 0x30(%rsp), %rdi
addq $0x40, %rdi
movq %rdi, 0x28(%rsp)
callq 0xd07e0
movq 0x30(%rsp), %rax
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
leaq 0x8f(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0xd0a20
movq 0x38(%rsp), %rdx
leaq 0x1181b(%rip), %rsi     # 0x1717eb
leaq 0x90(%rsp), %rdi
callq 0xd8b80
jmp 0x15ffdf
movq 0x30(%rsp), %rdi
addq $0x20, %rdi
leaq 0x90(%rsp), %rsi
movq %rsi, 0x10(%rsp)
callq 0xd0710
movq 0x10(%rsp), %rdi
callq 0xd0b38
leaq 0x8f(%rsp), %rdi
callq 0xd0630
leaq 0x57(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xd0a20
movq 0x18(%rsp), %rdx
leaq 0x117bf(%rip), %rsi     # 0x1717eb
leaq 0x58(%rsp), %rdi
callq 0xd8b80
jmp 0x160038
movq 0x30(%rsp), %rdi
addq $0x40, %rdi
leaq 0x58(%rsp), %rsi
movq %rsi, 0x8(%rsp)
callq 0xd0710
movq 0x8(%rsp), %rdi
callq 0xd0b38
leaq 0x57(%rsp), %rdi
callq 0xd0630
movq 0x30(%rsp), %rax
movl $0xffffffff, 0x60(%rax) # imm = 0xFFFFFFFF
movl $0x1f4, 0x44(%rsp)      # imm = 0x1F4
leaq 0x48(%rsp), %rdi
leaq 0x44(%rsp), %rsi
callq 0x160b90
jmp 0x160089
movq 0x30(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x78(%rdi)
callq 0x160120
jmp 0x16009e
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x8f(%rsp), %rdi
callq 0xd0630
jmp 0x1600f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x57(%rsp), %rdi
callq 0xd0630
jmp 0x1600f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
movq 0x28(%rsp), %rdi
callq 0xd0b38
movq 0x20(%rsp), %rdi
callq 0xd0b38
movq 0x80(%rsp), %rdi
callq 0xd0a10
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x60(%rax)
setl %cl
andb $0x1, %cl
movb %cl, 0x6c(%rax)
movq 0x10(%rax), %rcx
movq %rcx, 0x8(%rax)
movb $0x0, (%rax)
callq 0xd00a0
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xeeea0
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xd9fc0
movq 0x8(%rsp), %rsi
movq %rax, 0x20(%rsp)
addq $0x78, %rsi
leaq 0x20(%rsp), %rdi
callq 0x160bb0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, 0x70(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xc0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
addq $0x20, %rdi
movq %rdi, 0x20(%rsp)
callq 0xd07e0
movq 0x30(%rsp), %rdi
addq $0x40, %rdi
movq %rdi, 0x28(%rsp)
callq 0xd07e0
movq 0x30(%rsp), %rax
movq 0xb8(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0xb0(%rsp), %rcx
movq %rcx, 0x18(%rax)
leaq 0x8f(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0xd0a20
movq 0x38(%rsp), %rdx
leaq 0x115b3(%rip), %rsi     # 0x1717eb
leaq 0x90(%rsp), %rdi
callq 0xd8b80
jmp 0x160247
movq 0x30(%rsp), %rdi
addq $0x20, %rdi
leaq 0x90(%rsp), %rsi
movq %rsi, 0x10(%rsp)
callq 0xd0710
movq 0x10(%rsp), %rdi
callq 0xd0b38
leaq 0x8f(%rsp), %rdi
callq 0xd0630
leaq 0x57(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xd0a20
movq 0x18(%rsp), %rdx
leaq 0x11557(%rip), %rsi     # 0x1717eb
leaq 0x58(%rsp), %rdi
callq 0xd8b80
jmp 0x1602a0
movq 0x30(%rsp), %rdi
addq $0x40, %rdi
leaq 0x58(%rsp), %rsi
movq %rsi, 0x8(%rsp)
callq 0xd0710
movq 0x8(%rsp), %rdi
callq 0xd0b38
leaq 0x57(%rsp), %rdi
callq 0xd0630
movq 0x30(%rsp), %rax
movl $0xffffffff, 0x60(%rax) # imm = 0xFFFFFFFF
movl $0x1f4, 0x44(%rsp)      # imm = 0x1F4
leaq 0x48(%rsp), %rdi
leaq 0x44(%rsp), %rsi
callq 0x160b90
jmp 0x1602f1
movq 0x30(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x78(%rdi)
callq 0x160120
jmp 0x160306
addq $0xc8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x8f(%rsp), %rdi
callq 0xd0630
jmp 0x16035c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x57(%rsp), %rdi
callq 0xd0630
jmp 0x16035c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
movq 0x28(%rsp), %rdi
callq 0xd0b38
movq 0x20(%rsp), %rdi
callq 0xd0b38
movq 0x80(%rsp), %rdi
callq 0xd0a10
nopl (%rax)
// File: 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:
subq $0x78, %rsp
movq %rcx, 0x28(%rsp)
movq %r8, 0x8(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x20, %rdi
movq %rdi, 0x20(%rsp)
callq 0xd07e0
movq 0x18(%rsp), %rdi
addq $0x40, %rdi
movq %rdi, 0x10(%rsp)
callq 0xd07e0
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x68(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x60(%rsp), %rcx
movq %rcx, 0x18(%rax)
callq 0xd0080
jmp 0x1603fa
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
addq $0x40, %rdi
callq 0xd0080
jmp 0x16040f
movq 0x18(%rsp), %rax
movl $0xffffffff, 0x60(%rax) # imm = 0xFFFFFFFF
movl $0x1f4, 0x34(%rsp)      # imm = 0x1F4
leaq 0x38(%rsp), %rdi
leaq 0x34(%rsp), %rsi
callq 0x160b90
jmp 0x160434
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x78(%rdi)
callq 0x160120
jmp 0x160449
addq $0x78, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0xd0b38
movq 0x20(%rsp), %rdi
callq 0xd0b38
movq 0x48(%rsp), %rdi
callq 0xd0a10
nopw (%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rcx, 0x20(%rsp)
movq %r8, (%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movl %r9d, 0x4c(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x20, %rdi
movq %rdi, 0x18(%rsp)
callq 0xd07e0
movq 0x10(%rsp), %rdi
addq $0x40, %rdi
movq %rdi, 0x8(%rsp)
callq 0xd07e0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x68(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x60(%rsp), %rcx
movq %rcx, 0x18(%rax)
callq 0xd0080
jmp 0x1604fe
movq (%rsp), %rsi
movq 0x10(%rsp), %rdi
addq $0x40, %rdi
callq 0xd0080
jmp 0x160512
movq 0x10(%rsp), %rax
movl 0x4c(%rsp), %ecx
movl %ecx, 0x60(%rax)
movl $0x1f4, 0x2c(%rsp)      # imm = 0x1F4
leaq 0x30(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x160b90
jmp 0x160537
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x78(%rdi)
callq 0x160120
jmp 0x16054c
addq $0x78, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0xd0b38
movq 0x18(%rsp), %rdi
callq 0xd0b38
movq 0x40(%rsp), %rdi
callq 0xd0a10
nopl (%rax)
// File: 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:
subq $0x78, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x70(%rsp)
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq %r8, 0x48(%rsp)
movl %r9d, 0x44(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x20, %rdi
movq %rdi, 0x20(%rsp)
callq 0xd07e0
movq 0x18(%rsp), %rdi
addq $0x40, %rdi
movq %rdi, 0x10(%rsp)
callq 0xd07e0
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x60(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x58(%rsp), %rcx
movq %rcx, 0x18(%rax)
callq 0xd0080
jmp 0x16060c
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
addq $0x40, %rdi
callq 0xd0080
jmp 0x160621
movq 0x18(%rsp), %rdi
movl 0x44(%rsp), %eax
movl %eax, 0x60(%rdi)
movq 0x70(%rsp), %rax
movq %rax, 0x78(%rdi)
callq 0x160120
jmp 0x16063d
addq $0x78, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0xd0b38
movq 0x20(%rsp), %rdi
callq 0xd0b38
movq 0x38(%rsp), %rdi
callq 0xd0a10
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rcx), %rax
cmpq 0x18(%rcx), %rax
jle 0x160a1a
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rdi
callq 0x160670
movq 0x4b55d(%rip), %rdi     # 0x1abf88
movq 0x4b506(%rip), %rsi     # 0x1abf38
callq 0xd0610
movq 0x8(%rsp), %rax
movb $0x1, (%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, (%rax)
je 0x160aa2
jmp 0x160b82
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rcx)
movq 0x8(%rcx), %rax
cmpq 0x18(%rcx), %rax
jl 0x160ac9
movq 0x8(%rsp), %rdi
callq 0x1609f0
jmp 0x160b82
callq 0xd00a0
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xeeea0
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xd9fc0
movq 0x8(%rsp), %rsi
movq %rax, 0x30(%rsp)
addq $0x70, %rsi
leaq 0x30(%rsp), %rdi
callq 0x160bb0
movq 0x8(%rsp), %rsi
movq %rax, 0x18(%rsp)
addq $0x78, %rsi
leaq 0x18(%rsp), %rdi
callq 0x160c20
testb $0x1, %al
jne 0x160b22
jmp 0x160b82
movq 0x8(%rsp), %rdi
callq 0x160670
movq 0x8(%rsp), %rdi
movq %rdi, %rsi
addq $0x78, %rsi
addq $0x70, %rdi
callq 0x160c50
movq 0x8(%rsp), %rsi
addq $0x70, %rsi
leaq 0x30(%rsp), %rdi
callq 0x160bb0
movq 0x8(%rsp), %rsi
movq %rax, 0x10(%rsp)
addq $0x78, %rsi
leaq 0x10(%rsp), %rdi
callq 0x160c20
testb $0x1, %al
jne 0x160b72
jmp 0x160b80
movq 0x8(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, 0x70(%rax)
jmp 0x160b82
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movq %rdx, 0x1e0(%rsp)
movl %ecx, 0x1dc(%rsp)
movq 0x1e8(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x170(%rsp), %rdi
callq 0x15d9c0
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, 0x38(%rsp)
callq 0x164680
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
leaq 0x170(%rsp), %rdx
callq 0x16cd40
andb $0x1, %al
movb %al, 0x16f(%rsp)
testb $0x1, 0x16f(%rsp)
je 0x162d34
leaq 0x128(%rsp), %rdi
callq 0x139b90
leaq 0x108(%rsp), %rdi
callq 0x154710
cmpl $0x32, 0x1dc(%rsp)
jge 0x162d1c
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movq (%rdi), %rax
leaq 0x170(%rsp), %rdx
leaq 0x108(%rsp), %rcx
leaq 0x128(%rsp), %r8
callq *0x20(%rax)
testb $0x1, %al
jne 0x162cd9
jmp 0x162d1c
movq 0x28(%rsp), %rsi
movl 0x1dc(%rsp), %ecx
addl $0x1, %ecx
leaq 0xe8(%rsp), %rdi
leaq 0x128(%rsp), %rdx
callq 0x162be0
movq 0x18(%rsp), %rdi
leaq 0x108(%rsp), %rsi
leaq 0xe8(%rsp), %rdx
callq 0x155a10
jmp 0x162e1d
movq 0x18(%rsp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x154750
jmp 0x162e1d
movq 0x1e0(%rsp), %rsi
addq $0x20, %rsi
leaq 0xc8(%rsp), %rdi
callq 0x154ee0
movsd 0xd2eb(%rip), %xmm1     # 0x170040
addsd 0xd8(%rsp), %xmm1
movsd 0xd2ba(%rip), %xmm0     # 0x170020
mulsd %xmm1, %xmm0
movsd %xmm0, 0xc0(%rsp)
movsd 0xd2c5(%rip), %xmm0     # 0x170040
subsd 0xc0(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x80(%rsp), %rdi
movsd 0xd2a6(%rip), %xmm2     # 0x170040
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x154750
movsd 0x8(%rsp), %xmm0
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x155ae0
movsd 0xc0(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
movsd 0xd244(%rip), %xmm0     # 0x170020
movsd 0x15334(%rip), %xmm1    # 0x178118
movsd 0xd254(%rip), %xmm2     # 0x170040
callq 0x154750
movsd 0x10(%rsp), %xmm0
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x155ae0
movq 0x18(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x1557b0
movq 0x20(%rsp), %rax
addq $0x1f8, %rsp            # imm = 0x1F8
retq
nopw (%rax,%rax)
// File: 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:
subq $0xf8, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movl %edx, 0xe4(%rsp)
movl %ecx, 0xe0(%rsp)
movq %r8, 0xd8(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x154710
movl $0x0, 0xb4(%rsp)
movl 0xb4(%rsp), %eax
movq 0xd8(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x162efe
movq 0xd8(%rsp), %rsi
movl 0xe4(%rsp), %edx
movl 0xe0(%rsp), %ecx
leaq 0x70(%rsp), %rdi
callq 0x1612c0
movq 0x28(%rsp), %rsi
leaq 0x50(%rsp), %rdi
leaq 0x70(%rsp), %rdx
xorl %ecx, %ecx
callq 0x162be0
leaq 0xb8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x154810
movl 0xb4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xb4(%rsp)
jmp 0x162e8f
movq 0xd8(%rsp), %rax
cvtsi2sdl 0x10(%rax), %xmm0
leaq 0x30(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x155bb0
movq 0xd8(%rsp), %rax
testb $0x1, 0x14(%rax)
je 0x162f73
movsd 0x38(%rsp), %xmm0
callq 0xd01b0
movsd %xmm0, 0x10(%rsp)
movsd 0x40(%rsp), %xmm0
callq 0xd01b0
movsd %xmm0, 0x8(%rsp)
movsd 0x48(%rsp), %xmm0
callq 0xd01b0
movq 0x18(%rsp), %rdi
movsd 0x8(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
callq 0x154750
jmp 0x162f82
movq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x155dd0
movq 0x20(%rsp), %rax
addq $0xf8, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rsi, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rdi
callq 0x16cd30
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x163011
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x16d000
movq %rax, %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
callq *0x50(%rax)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x162fb1
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x16cbb0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq %rsi, %rax
je 0x163081
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x163090
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)