LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Lut99[P]RayTracer/src/lib/RenderWorld.cpp
// Function: RayTracer::RenderWorld::operator=(RayTracer::RenderWorld&&)
RenderWorld& RenderWorld::operator=(RenderWorld&& other) {
    // Simply shallow copy the vectors
    this->objects = other.objects;

    // Now fill the object's vectors with empty ones to avoid deallocation of the objects
    other.objects = nullptr;

    // Return a reference to this
    return *this;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rcx
movq $0x0, 0x8(%rcx)
retq
nopw (%rax,%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x40(%rsp)
movb $0x0, 0x97(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0xd99c0
leaq 0x70(%rsp), %rdi
callq 0x155e60
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
leaq 0x80(%rsp), %rdi
callq 0x155e10
jmp 0x163155
movq 0x30(%rsp), %rdi
leaq 0xe165(%rip), %rsi      # 0x1712c6
callq 0xd9b40
movq %rax, 0x28(%rsp)
jmp 0x16316d
movq 0x28(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x128ba0
leaq 0x80(%rsp), %rdi
callq 0xd9f30
movq $0x0, 0x58(%rsp)
movq 0x40(%rsp), %rax
movq 0x58(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rdi
callq 0x16cd30
movq %rax, 0x20(%rsp)
jmp 0x1631b4
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq %rcx, %rax
jae 0x163295
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x58(%rsp), %rsi
callq 0x16d000
movq %rax, 0x10(%rsp)
jmp 0x1631e1
movq 0x10(%rsp), %rsi
movq (%rsi), %rax
movq 0x58(%rax), %rax
leaq 0x48(%rsp), %rdi
callq *%rax
jmp 0x1631f6
movq 0x30(%rsp), %rdi
leaq 0xe0c4(%rip), %rsi      # 0x1712c6
callq 0xd9b40
movq %rax, 0x8(%rsp)
jmp 0x16320e
movq 0x8(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x155ed0
movq %rax, (%rsp)
jmp 0x163223
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x128ba0
leaq 0x48(%rsp), %rdi
callq 0xd9f30
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0x163195
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x1632be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x80(%rsp), %rdi
callq 0xd9f30
jmp 0x1632be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xd9f30
jmp 0x1632be
movb $0x1, 0x97(%rsp)
testb $0x1, 0x97(%rsp)
jne 0x1632b1
movq 0x30(%rsp), %rdi
callq 0xd9f30
movq 0x38(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xd9f30
movq 0x68(%rsp), %rdi
callq 0xd0a10
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
movq %rcx, 0xd8(%rsp)
movq %r8, 0xd0(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xe0(%rsp), %rsi
addq $0x18, %rsi
movq 0xe0(%rsp), %rdx
addq $0x38, %rdx
leaq 0x90(%rsp), %rdi
callq 0x1557b0
leaq 0x70(%rsp), %rdi
callq 0x15ee10
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x1557b0
movq 0xe0(%rsp), %rax
addq $0x18, %rax
movq %rax, (%rsp)
movq 0xe0(%rsp), %rdx
addq $0x18, %rdx
leaq 0x10(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x1558e0
movq (%rsp), %rsi
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x139c00
movq 0xd0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x166910
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
movq 0xd8(%rsp), %rdi
callq 0x1547a0
movb $0x1, %al
andb $0x1, %al
addq $0xf8, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x47(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0xd99c0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0x1663b7
movq 0x10(%rsp), %rsi
addq $0x10, %rsi
leaq 0x20(%rsp), %rdi
callq 0x154f50
jmp 0x1663cc
movq 0x18(%rsp), %rdi
leaq 0x11f46(%rip), %rsi     # 0x17831e
callq 0xd9b40
movq %rax, (%rsp)
jmp 0x1663e3
movq (%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x128ba0
leaq 0x20(%rsp), %rdi
callq 0xd9f30
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x16643d
jmp 0x166433
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x166447
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xd9f30
jmp 0x166447
movq 0x18(%rsp), %rdi
callq 0xd9f30
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xd9f30
movq 0x38(%rsp), %rdi
callq 0xd0a10
nopl (%rax,%rax)
// File: 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:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %rdx, 0x110(%rsp)
movq %rcx, 0x108(%rsp)
movq %r8, 0x100(%rsp)
movq 0x120(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x118(%rsp), %rsi
addq $0x20, %rsi
leaq 0xc0(%rsp), %rdi
callq 0x154ee0
movq 0x18(%rsp), %rsi
movq 0x110(%rsp), %rcx
addq $0x38, %rcx
movq (%rsi), %rax
leaq 0xe0(%rsp), %rdi
leaq 0xc0(%rsp), %rdx
callq *0x30(%rax)
movq 0x18(%rsp), %rax
movq 0x110(%rsp), %rcx
addq $0x18, %rcx
movq %rcx, 0x10(%rsp)
movsd 0x30(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x15ee10
movsd 0x8(%rsp), %xmm0
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x155ae0
leaq 0x60(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x1557b0
movq 0x10(%rsp), %rsi
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rdx
callq 0x139c00
movq 0x100(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x166910
movq 0x18(%rsp), %rsi
addq $0x10, %rsi
movq 0x108(%rsp), %rdi
callq 0x1547a0
movq 0x100(%rsp), %rdi
addq $0x20, %rdi
movq 0x110(%rsp), %rsi
addq $0x38, %rsi
callq 0x155c70
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
addq $0x128, %rsp            # imm = 0x128
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0x67(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0xd99c0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0x166c77
movq 0x20(%rsp), %rsi
addq $0x10, %rsi
leaq 0x40(%rsp), %rdi
callq 0x154f50
jmp 0x166c8c
movq 0x28(%rsp), %rdi
leaq 0x11686(%rip), %rsi     # 0x17831e
callq 0xd9b40
movq %rax, 0x10(%rsp)
jmp 0x166ca4
movq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movq %rsi, (%rsp)
callq 0x128ba0
movq (%rsp), %rdi
callq 0xd9f30
movq 0x20(%rsp), %rsi
addq $0x30, %rsi
leaq 0x30(%rsp), %rdi
callq 0x155e80
movq 0x28(%rsp), %rdi
leaq 0x1166a(%rip), %rsi     # 0x178349
callq 0xd9b40
movq %rax, 0x8(%rsp)
jmp 0x166ceb
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x128ba0
leaq 0x30(%rsp), %rdi
callq 0xd9f30
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x166d60
jmp 0x166d56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x166d6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xd9f30
jmp 0x166d6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xd9f30
jmp 0x166d6a
movq 0x28(%rsp), %rdi
callq 0xd9f30
movq 0x18(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xd9f30
movq 0x58(%rsp), %rdi
callq 0xd0a10
nop
// File: 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:
subq $0x118, %rsp            # imm = 0x118
movq %rdi, 0x108(%rsp)
movq %rsi, 0x100(%rsp)
movq %rdx, 0xf8(%rsp)
movsd %xmm0, 0xf0(%rsp)
movq %rcx, 0xe8(%rsp)
movq 0x100(%rsp), %rsi
leaq 0xc8(%rsp), %rdi
callq 0x154ee0
movq 0xf8(%rsp), %rsi
leaq 0xc8(%rsp), %rdi
callq 0x155c70
movsd %xmm0, 0xc0(%rsp)
movsd 0xf0(%rsp), %xmm0
mulsd 0xf0(%rsp), %xmm0
movsd 0xc0(%rsp), %xmm1
movsd 0xc0(%rsp), %xmm2
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm1
movsd 0x8386(%rip), %xmm2     # 0x170040
addsd %xmm2, %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm1, %xmm0
movsd 0x835f(%rip), %xmm1     # 0x170040
addsd %xmm1, %xmm0
movsd %xmm0, 0xb8(%rsp)
movsd 0xb8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x167dba
movsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0xf8(%rsp), %rsi
movsd 0xc0(%rsp), %xmm0
leaq 0x38(%rsp), %rdi
callq 0x155a80
leaq 0x58(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x1558e0
movsd 0x8(%rsp), %xmm0
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x155ae0
movq 0xf8(%rsp), %rax
movq %rax, 0x10(%rsp)
movsd 0xb8(%rsp), %xmm0
callq 0xd01b0
movq 0x10(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x155a80
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x1558e0
movq 0xe8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x1547a0
movb $0x1, 0x117(%rsp)
jmp 0x167dc2
movb $0x0, 0x117(%rsp)
movb 0x117(%rsp), %al
andb $0x1, %al
addq $0x118, %rsp            # imm = 0x118
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0x67(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0xd99c0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0x167ec7
movq 0x20(%rsp), %rsi
addq $0x10, %rsi
leaq 0x40(%rsp), %rdi
callq 0x154f50
jmp 0x167edc
movq 0x28(%rsp), %rdi
leaq 0x10436(%rip), %rsi     # 0x17831e
callq 0xd9b40
movq %rax, 0x10(%rsp)
jmp 0x167ef4
movq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movq %rsi, (%rsp)
callq 0x128ba0
movq (%rsp), %rdi
callq 0xd9f30
movq 0x20(%rsp), %rsi
addq $0x30, %rsi
leaq 0x30(%rsp), %rdi
callq 0x155e80
movq 0x28(%rsp), %rdi
leaq 0x10438(%rip), %rsi     # 0x178367
callq 0xd9b40
movq %rax, 0x8(%rsp)
jmp 0x167f3b
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x128ba0
leaq 0x30(%rsp), %rdi
callq 0xd9f30
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x167fb0
jmp 0x167fa6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x167fba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xd9f30
jmp 0x167fba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xd9f30
jmp 0x167fba
movq 0x28(%rsp), %rdi
callq 0xd9f30
movq 0x18(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xd9f30
movq 0x58(%rsp), %rdi
callq 0xd0a10
nop
// File: 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:
subq $0x118, %rsp            # imm = 0x118
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq 0x110(%rsp), %rax
movq %rax, (%rsp)
movq 0x108(%rsp), %rsi
addq $0x40, %rsi
leaq 0xe8(%rsp), %rdi
callq 0x155dd0
movq 0x108(%rsp), %rsi
addq $0x20, %rsi
leaq 0xc8(%rsp), %rdi
callq 0x155dd0
movsd 0xd0(%rsp), %xmm0
movsd 0xe0(%rsp), %xmm2
leaq 0xa8(%rsp), %rdi
xorps %xmm1, %xmm1
callq 0x154750
movsd 0xf0(%rsp), %xmm0
movsd 0x100(%rsp), %xmm2
leaq 0x88(%rsp), %rdi
xorps %xmm1, %xmm1
callq 0x154750
movq (%rsp), %rdi
addq $0x10, %rdi
leaq 0x88(%rsp), %rsi
callq 0x1547a0
leaq 0x68(%rsp), %rdi
xorps %xmm1, %xmm1
movsd 0x62a2(%rip), %xmm2     # 0x170040
movaps %xmm1, %xmm0
callq 0x154750
movq (%rsp), %rdx
addq $0x10, %rdx
leaq 0x28(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x1558e0
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x154ee0
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x155c70
callq 0xd0560
movq (%rsp), %rdx
movsd %xmm0, 0x38(%rdx)
addq $0x10, %rdx
leaq 0x8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x1558e0
leaq 0x8(%rsp), %rdi
callq 0x154e70
movq (%rsp), %rax
movsd %xmm0, 0x30(%rax)
addq $0x118, %rsp            # imm = 0x118
retq
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rsi, 0x60(%rsp)
movq %rdi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movsd 0x18(%rax), %xmm0
movsd %xmm0, (%rsp)
movsd 0x38(%rax), %xmm0
callq 0xd0180
movsd (%rsp), %xmm1
movq 0x28(%rsp), %rax
movsd 0x30(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x50(%rsp), %rcx
movsd 0x30(%rcx), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x28(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x38(%rax), %xmm0
callq 0xd03a0
movsd 0x8(%rsp), %xmm3
movsd 0x10(%rsp), %xmm1
movq 0x28(%rsp), %rax
movaps %xmm0, %xmm2
movsd 0x18(%rsp), %xmm0
movsd 0x30(%rax), %xmm4
mulsd %xmm4, %xmm2
addsd %xmm3, %xmm2
leaq 0x30(%rsp), %rdi
callq 0x154750
movq 0x50(%rsp), %rdi
addq $0x20, %rdi
leaq 0x30(%rsp), %rsi
callq 0x1547a0
movq 0x28(%rsp), %rax
movsd 0x40(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xd9ff0
movsd 0x20(%rsp), %xmm0
movq %rax, %rcx
movq 0x28(%rsp), %rax
cvtsi2sd %rcx, %xmm2
movsd 0x38(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rax)
movq 0x28(%rsp), %rax
movsd 0x38(%rax), %xmm0
movsd 0xe538(%rip), %xmm1     # 0x178460
ucomisd %xmm1, %xmm0
jb 0x169f4b
movq 0x28(%rsp), %rax
movsd 0x38(%rax), %xmm0
movsd 0xe520(%rip), %xmm1     # 0x178460
subsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rax)
jmp 0x169f16
movq 0x50(%rsp), %rdi
callq 0x160e50
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0x57(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0xd99c0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0x169fa7
movq 0x18(%rsp), %rdi
addq $0x48, %rdi
callq 0x16a7a0
movq %rax, 0x8(%rsp)
jmp 0x169fbc
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x16a7b0
movq 0x20(%rsp), %rdi
leaq 0xe487(%rip), %rsi      # 0x178468
callq 0xd9b40
movq %rax, (%rsp)
jmp 0x169fec
movq (%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x128ba0
leaq 0x30(%rsp), %rdi
callq 0xd9f30
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x16a046
jmp 0x16a03c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x16a050
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xd9f30
jmp 0x16a050
movq 0x20(%rsp), %rdi
callq 0xd9f30
movq 0x10(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xd9f30
movq 0x48(%rsp), %rdi
callq 0xd0a10
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movsd %xmm0, 0x58(%rsp)
movsd %xmm1, 0x50(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x4c(%rsp)
cmpl $0x3, 0x4c(%rsp)
jge 0x16ad49
movq 0x60(%rsp), %rdi
addq $0x20, %rdi
movl 0x4c(%rsp), %esi
callq 0x154cd0
movq 0x28(%rsp), %rdi
movaps %xmm0, %xmm1
movsd 0x5427(%rip), %xmm0     # 0x170040
divsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movl 0x4c(%rsp), %esi
callq 0x154cd0
movsd %xmm0, 0x18(%rsp)
movq 0x60(%rsp), %rdi
movl 0x4c(%rsp), %esi
callq 0x154cd0
movq 0x28(%rsp), %rdi
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
subsd %xmm1, %xmm0
mulsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
addq $0x20, %rdi
movl 0x4c(%rsp), %esi
callq 0x154cd0
movsd %xmm0, 0x20(%rsp)
movq 0x60(%rsp), %rdi
movl 0x4c(%rsp), %esi
callq 0x154cd0
movaps %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
subsd %xmm1, %xmm0
mulsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
xorps %xmm0, %xmm0
ucomisd 0x40(%rsp), %xmm0
jbe 0x16acb2
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x16af70
movsd 0x38(%rsp), %xmm0
ucomisd 0x58(%rsp), %xmm0
jbe 0x16acce
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x16acda
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x58(%rsp)
movsd 0x30(%rsp), %xmm1
movsd 0x50(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x16ad06
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x16ad12
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm1
movsd 0x58(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x16ad37
movb $0x0, 0x77(%rsp)
jmp 0x16ad4e
jmp 0x16ad39
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x16abec
movb $0x1, 0x77(%rsp)
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x54(%rsp)
cmpl $0x3, 0x54(%rsp)
jge 0x16aef5
movq 0x18(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0x154cd0
movq 0x18(%rsp), %rdi
movsd %xmm0, 0x48(%rsp)
addq $0x20, %rdi
movl 0x54(%rsp), %esi
callq 0x154cd0
movsd %xmm0, 0x40(%rsp)
movq 0x58(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0x154cd0
movsd %xmm0, 0x38(%rsp)
movq 0x58(%rsp), %rdi
addq $0x20, %rdi
movl 0x54(%rsp), %esi
callq 0x154cd0
movsd %xmm0, 0x30(%rsp)
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
ucomisd 0x20(%rsp), %xmm0
jbe 0x16ae21
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x38(%rsp), %xmm1
movsd 0x28(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x16ae41
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
jmp 0x16ae5d
movsd 0x38(%rsp), %xmm0
ucomisd 0x20(%rsp), %xmm0
jbe 0x16ae5b
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x16ae5d
movsd 0x30(%rsp), %xmm1
movsd 0x28(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x16ae7d
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
jmp 0x16ae99
movsd 0x30(%rsp), %xmm0
ucomisd 0x20(%rsp), %xmm0
jbe 0x16ae97
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x16ae99
movq 0x18(%rsp), %rdi
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movl 0x54(%rsp), %esi
callq 0x154b30
movsd 0x8(%rsp), %xmm0
movq 0x18(%rsp), %rdi
movsd %xmm0, (%rax)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
addq $0x20, %rdi
movl 0x54(%rsp), %esi
callq 0x154b30
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x16ad80
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movsd 0x8(%rax), %xmm0
subsd 0x28(%rax), %xmm0
callq 0xd0a60
movq (%rsp), %rax
movsd %xmm0, 0x18(%rsp)
movsd 0x10(%rax), %xmm0
subsd 0x30(%rax), %xmm0
callq 0xd0a60
movq (%rsp), %rax
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rax), %xmm0
subsd 0x38(%rax), %xmm0
callq 0xd0a60
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
retq
// File: 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:
subq $0x28, %rsp
movq %rsi, %rax
movq %rdi, %rsi
movq %rsi, 0x20(%rsp)
movq %rax, 0x18(%rsp)
movq 0x40fbd(%rip), %rdi     # 0x1abf88
callq 0xd0540
movq %rax, %rdi
leaq 0xd4c4(%rip), %rsi      # 0x17849e
callq 0xd05b0
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x15d790
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x16b052
cmpq $0x0, 0x10(%rsp)
jbe 0x16b024
movq 0x40f70(%rip), %rdi     # 0x1abf88
leaq 0xb0d1(%rip), %rsi      # 0x1760f0
callq 0xd05b0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x15da90
movq (%rax), %rsi
movq 0x40f4b(%rip), %rdi     # 0x1abf88
callq 0xd0490
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x16afe8
movq 0x40f2f(%rip), %rdi     # 0x1abf88
leaq 0xd441(%rip), %rsi      # 0x1784a1
callq 0xd05b0
movq %rax, %rdi
movq 0x40ec9(%rip), %rsi     # 0x1abf38
callq 0xd0610
addq $0x28, %rsp
retq
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/ObjectTree.cpp
// Function: RayTracer::ObjectTreeBranch::hit(RayTracer::Ray const&, double, double, RayTracer::HitRecord&) const
bool ObjectTreeBranch::hit(const Ray& ray, double t_min, double t_max, HitRecord& record) const {
    HitRecord record_r;
    bool hit_left = this->left->quick_hit(ray, t_min, t_max) && this->left->hit(ray, t_min, t_max, record);
    bool hit_right = this->right->quick_hit(ray, t_min, t_max) && this->right->hit(ray, t_min, t_max, record_r);
    // Note the record if it was a hit
    if (hit_left && hit_right) {
        // Set record to the smallest one
        if (record_r.t < record.t) {
            record = record_r;
        }
    } else if (hit_right) {
        // Don't forget to update record
        record = record_r;
    }
    
    // Return if we actually hit
    return hit_left || hit_right;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movsd %xmm0, 0x90(%rsp)
movsd %xmm1, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x15d9c0
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rdi
movq 0x98(%rsp), %rsi
movsd 0x90(%rsp), %xmm0
movsd 0x88(%rsp), %xmm1
movq (%rdi), %rax
callq *0x10(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x15(%rsp)
jne 0x16c2e0
jmp 0x16c315
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rdi
movq 0x98(%rsp), %rsi
movsd 0x90(%rsp), %xmm0
movsd 0x88(%rsp), %xmm1
movq 0x80(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, 0x15(%rsp)
movq 0x8(%rsp), %rax
movb 0x15(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x17(%rsp)
movq 0x58(%rax), %rdi
movq 0x98(%rsp), %rsi
movsd 0x90(%rsp), %xmm0
movsd 0x88(%rsp), %xmm1
movq (%rdi), %rax
callq *0x10(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x16c358
jmp 0x16c38a
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rdi
movq 0x98(%rsp), %rsi
movsd 0x90(%rsp), %xmm0
movsd 0x88(%rsp), %xmm1
movq (%rdi), %rax
leaq 0x18(%rsp), %rdx
callq *0x18(%rax)
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x16(%rsp)
testb $0x1, 0x17(%rsp)
je 0x16c3ce
testb $0x1, 0x16(%rsp)
je 0x16c3ce
movsd 0x18(%rsp), %xmm1
movq 0x80(%rsp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x16c3cc
movq 0x80(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x15da10
jmp 0x16c3e9
testb $0x1, 0x16(%rsp)
je 0x16c3e7
movq 0x80(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x15da10
jmp 0x16c3e9
movb $0x1, %al
testb $0x1, 0x17(%rsp)
movb %al, 0x6(%rsp)
jne 0x16c3fe
movb 0x16(%rsp), %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/ObjectTree.cpp
// Function: RayTracer::ObjectTreeBranch::operator=(RayTracer::ObjectTreeBranch)
ObjectTreeBranch& ObjectTreeBranch::operator=(ObjectTreeBranch other) {
    // Copy the stuff by swapping
    if (this != &other) {
        // Copy by swapping
        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 0x16c441
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x16c450
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/ObjectTree.cpp
// Function: RayTracer::ObjectTreeBranch::operator=(RayTracer::ObjectTreeBranch&&)
ObjectTreeBranch& ObjectTreeBranch::operator=(ObjectTreeBranch&& other) {
    // Copy the stuff directly
    if (this != &other) {
        this->left = other.left;
        this->right = other.right;
        other.left = nullptr;
        other.right = nullptr;
    }
    return *this;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpq -0x10(%rsp), %rax
je 0x16c4f4
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movq 0x50(%rcx), %rcx
movq %rcx, 0x50(%rax)
movq -0x10(%rsp), %rcx
movq 0x58(%rcx), %rcx
movq %rcx, 0x58(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x50(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x58(%rax)
movq -0x18(%rsp), %rax
retq
nopw (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/ObjectTree.cpp
// Function: RayTracer::ObjectTreeLeaf::operator=(RayTracer::ObjectTreeLeaf)
ObjectTreeLeaf& ObjectTreeLeaf::operator=(ObjectTreeLeaf other) {
    // Copy the stuff by swapping
    if (this != &other) {
        // Copy by swapping
        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 0x16c7c1
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x16c7d0
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/ObjectTree.cpp
// Function: RayTracer::ObjectTreeLeaf::operator=(RayTracer::ObjectTreeLeaf&&)
ObjectTreeLeaf& ObjectTreeLeaf::operator=(ObjectTreeLeaf&& other) {
    // Copy the stuff directly
    if (this != &other) {
        this->obj = other.obj;
        other.obj = nullptr;
    }
    return *this;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpq -0x10(%rsp), %rax
je 0x16c83a
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movq 0x50(%rcx), %rcx
movq %rcx, 0x50(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x50(%rax)
movq -0x18(%rsp), %rax
retq
// File: Lut99[P]RayTracer/src/lib/ObjectTree.cpp
// Function: RayTracer::ObjectTree::~ObjectTree()
ObjectTree::~ObjectTree() {
    if (this->root != nullptr) { delete this->root; }

    // ALso delete all objects
    for (size_t i = 0; i < this->objects.size(); i++) {
        delete this->objects.at(i);
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x18(%rax)
je 0x16c9eb
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x16c9e9
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x16c9eb
movq $0x0, 0x28(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x15d790
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x16ca59
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x15d980
movq %rax, 0x8(%rsp)
jmp 0x16ca2b
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x16ca47
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x16ca49
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x16c9f4
movq 0x20(%rsp), %rdi
callq 0x15d8d0
addq $0x38, %rsp
retq
movq %rax, %rdi
callq 0xd9890
// File: Lut99[P]RayTracer/src/lib/ObjectTree.cpp
// Function: RayTracer::ObjectTree::add(RayTracer::RenderObject*)
bool ObjectTree::add(RenderObject* obj) {
    // Crash if the object has no hitbox
    if (!obj->has_hitbox) {
        return false;
    }

    this->objects.push_back(obj);   

    // Be sure to mark the tree as non-optimised anymore
    this->is_optimised = false;

    return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x78(%rax)
jne 0x16ca9a
movb $0x0, 0x27(%rsp)
jmp 0x16cab7
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x16d480
movq 0x8(%rsp), %rax
movb $0x0, 0x20(%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/ObjectTree.cpp
// Function: RayTracer::ObjectTree::remove(RayTracer::RenderObject*)
bool ObjectTree::remove(RenderObject* obj) {
    // Check if a node with this pointer is present
    for (size_t i = 0; i < this->objects.size(); i++) {
        if (this->objects.at(i) == obj) {
            // Remove it and then quit
            this->objects.erase(this->objects.begin() + i);

            this->is_optimised = false;
            
            return true;
        }
    }
    return false;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x15d790
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x16cb9d
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x15d980
movq (%rax), %rax
cmpq 0x40(%rsp), %rax
jne 0x16cb88
movq 0x10(%rsp), %rdi
callq 0x15ea20
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x16d330
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x16d560
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x16d4f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rsp)
movb $0x0, 0x20(%rax)
movb $0x1, 0x57(%rsp)
jmp 0x16cba2
jmp 0x16cb8a
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x16caf1
movb $0x0, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/ObjectTree.cpp
// Function: RayTracer::ObjectTree::optimize()
void ObjectTree::optimize() {
    this->is_optimised = true;

    // Start by removing any existing trees
    if (this->root != nullptr) {
        delete this->root;
    }
    
    // Make sure there are things to optimize
    if (this->size() == 0) { return; }

    // Create the root node
    if (this->size() == 1) {
        // If there is only one element, make a leaf
        this->root = (ObjectTreeNode*) new ObjectTreeLeaf(this->objects.at(0));
    } else {
        // Else, make a branch which splits itself
        this->root = (ObjectTreeNode*) new ObjectTreeBranch(this->objects);
    }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
movb $0x1, 0x20(%rax)
cmpq $0x0, 0x18(%rax)
je 0x16cbef
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x16cbed
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x16cbef
movq 0x28(%rsp), %rdi
callq 0x16cd30
cmpq $0x0, %rax
jne 0x16cc04
jmp 0x16cd18
movq 0x28(%rsp), %rdi
callq 0x16cd30
cmpq $0x1, %rax
jne 0x16cc81
movl $0x58, %edi
callq 0xd05d0
movq 0x28(%rsp), %rdi
movq %rax, 0x10(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x15d980
movq %rax, 0x18(%rsp)
jmp 0x16cc38
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
callq 0x16c570
jmp 0x16cc4c
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x16cd18
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movl $0x58, %esi
callq 0xd05e0
jmp 0x16cd1d
movl $0x60, %edi
callq 0xd05d0
movq 0x28(%rsp), %rsi
movq %rax, 0x8(%rsp)
movb $0x1, 0x37(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x15d7d0
jmp 0x16cca6
movq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x16bc20
jmp 0x16ccb7
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, 0x37(%rsp)
movq %rcx, 0x18(%rax)
leaq 0x38(%rsp), %rdi
callq 0x15d8d0
jmp 0x16cd18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x16ccfe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x15d8d0
testb $0x1, 0x37(%rsp)
jne 0x16cd07
jmp 0x16cd16
movq 0x8(%rsp), %rdi
movl $0x60, %esi
callq 0xd05e0
jmp 0x16cd1d
addq $0x68, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0xd0a10
nopw (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/ObjectTree.cpp
// Function: RayTracer::ObjectTree::operator=(RayTracer::ObjectTree)
ObjectTree& ObjectTree::operator=(ObjectTree other) {
    if (this != &other) {
        // Copy by swapping
        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 0x16cf41
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x16cf50
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/ObjectTree.cpp
// Function: RayTracer::swap(RayTracer::ObjectTree&, RayTracer::ObjectTree&)
void RayTracer::swap(ObjectTree& first, ObjectTree& second) {
    using std::swap;

    swap(first.objects, second.objects);
    swap(first.root, second.root);
    swap(first.is_optimised, second.is_optimised);
    swap(first.uid, second.uid);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x16d620
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movq 0x8(%rsp), %rsi
addq $0x18, %rsi
callq 0x16d5a0
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
movq 0x8(%rsp), %rsi
addq $0x20, %rsi
callq 0x16d650
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
movq 0x8(%rsp), %rsi
addq $0x28, %rsi
callq 0x16d690
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/ObjectTree.cpp
// Function: RayTracer::ObjectTree::operator=(RayTracer::ObjectTree&&)
ObjectTree& ObjectTree::operator=(ObjectTree&& other) {
    if (this != &other) {
        // Copy by swapping
        swap(*this, other);
    }
    return *this;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq 0x8(%rsp), %rax
je 0x16cfec
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x16cf50
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: kazzmir[P]xborder/src/main.cpp
// Function: choose_window(_XDisplay*)
Window choose_window(Display * display){
    Window root = RootWindow(display, DefaultScreen(display));
    Window root_out;
    int root_x, root_y;
    int win_x, win_y;
    unsigned int mask;
    Window child = 0;
    Cursor cursor;

    cursor = XCreateFontCursor(display, XC_crosshair);

    XGrabPointer(display, root, False, ButtonPressMask | ButtonReleaseMask, GrabModeSync, GrabModeAsync, root, cursor, CurrentTime);

    // std::cout << "Grabbing window" << std::endl;
    while (1){
        XAllowEvents(display, SyncPointer, CurrentTime);
        XEvent event;
        XWindowEvent(display, root, ButtonPressMask | ButtonReleaseMask, &event);
        if (event.type == ButtonPress){
            child = event.xbutton.subwindow;
            break;
        }
    }

    // XQueryPointer(display, root, &root_out, &child, &root_x, &root_y, &win_x, &win_y, &mask);
    // std::cout << "Grabbed window " << child << std::endl;
    XUngrabPointer(display, CurrentTime);
    std::cout << "Grabbed window " << child << std::endl;
    if (child == root){
        return 0;
    }

    return child;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0xe0(%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl $0x22, %esi
callq 0x31b0
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %r10
movq -0x48(%rbp), %rax
xorl %r8d, %r8d
movl $0xc, %ecx
movl $0x1, %r9d
xorl %edx, %edx
movl %r8d, %edx
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x3110
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3160
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0xc, %edx
leaq -0x108(%rbp), %rcx
callq 0x3090
cmpl $0x4, -0x108(%rbp)
jne 0x38b9
movq -0xd8(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x38bb
jmp 0x3878
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x32d0
movq 0x6701(%rip), %rdi      # 0x9fd0
leaq 0x3816(%rip), %rsi      # 0x70ec
callq 0x3310
movq %rax, %rdi
movq -0x40(%rbp), %rsi
callq 0x3060
movq %rax, %rdi
movq 0x66cf(%rip), %rsi      # 0x9fc0
callq 0x3370
movq -0x40(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x390a
movq $0x0, -0x8(%rbp)
jmp 0x3912
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nop
// File: kazzmir[P]xborder/src/main.cpp
// Function: find_xborder_window(_XDisplay*)
Window find_xborder_window(Display * display){
    Window chosen = choose_window(display);
    if (chosen == 0){
        std::cout << "Error: Window could not be selected, or root window chosen" << std::endl;
        return 0;
    }
    Atom xborder = XInternAtom(display, "xborder", false);
    Window xborder_window = find_window_by_atom(display, chosen, xborder);
    if (xborder_window == 0){
        std::cout << "Error: Selected window is not an xborder: " << chosen << std::endl;
        return 0;
    }
    return xborder_window;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x37f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x396c
movq 0x6689(%rip), %rdi      # 0x9fd0
leaq 0x37ae(%rip), %rsi      # 0x70fc
callq 0x3310
movq %rax, %rdi
movq 0x6663(%rip), %rsi      # 0x9fc0
callq 0x3370
movq $0x0, -0x8(%rbp)
jmp 0x39de
movq -0x10(%rbp), %rdi
leaq 0x39fa(%rip), %rsi      # 0x7371
xorl %edx, %edx
callq 0x3230
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x39f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x39d6
movq 0x662b(%rip), %rdi      # 0x9fd0
leaq 0x378b(%rip), %rsi      # 0x7137
callq 0x3310
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3060
movq %rax, %rdi
movq 0x65f9(%rip), %rsi      # 0x9fc0
callq 0x3370
movq $0x0, -0x8(%rbp)
jmp 0x39de
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kazzmir[P]xborder/src/main.cpp
// Function: find_window_by_atom(_XDisplay*, unsigned long, unsigned long)
static Window find_window_by_atom(Display *dpy, Window win, Atom atom){
    Atom type = None;
    int format;
    unsigned long nitems, after;
    unsigned char *data = NULL;
    Window inf;

    // std::cout << "Find window with atom " << XGetAtomName(dpy, atom) << std::endl;
    XGetWindowProperty(dpy, win, atom, 0, 0, False, AnyPropertyType,
            &type, &format, &nitems, &after, &data);
    if (data)
        XFree(data);
    if (type)
        return win;
    inf = TryChildren(dpy, win, atom);
    if (!inf)
        inf = win;
    return inf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
xorl %eax, %eax
movl %eax, %r8d
xorl %r9d, %r9d
leaq -0x38(%rbp), %r14
leaq -0x3c(%rbp), %rbx
leaq -0x48(%rbp), %r11
leaq -0x50(%rbp), %r10
leaq -0x58(%rbp), %rax
movq %r8, %rcx
movq $0x0, (%rsp)
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq %r11, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movq %rax, 0x28(%rsp)
callq 0x30d0
cmpq $0x0, -0x58(%rbp)
je 0x3a7b
movq -0x58(%rbp), %rdi
callq 0x3430
cmpq $0x0, -0x38(%rbp)
je 0x3a8c
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x3ab8
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x5a10
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
jne 0x3ab0
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax,%rax)
// File: kazzmir[P]xborder/src/main.cpp
// Function: find_terminal(_XDisplay*)
Window find_terminal(Display * display){
    Window child = choose_window(display);
    if (child == 0){
        return 0;
    }
    return _XmuClientWindow(display, child);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x37f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3afa
movq $0x0, -0x8(%rbp)
jmp 0x3b0b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3b20
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kazzmir[P]xborder/src/main.cpp
// Function: XmuClientWindow(_XDisplay*, unsigned long)
static Window _XmuClientWindow(Display *dpy, Window win){
    Atom WM_STATE;

    WM_STATE = XInternAtom(dpy, "WM_STATE", True);
    if (!WM_STATE)
        return win;
    return find_window_by_atom(dpy, win, WM_STATE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x36e6(%rip), %rsi      # 0x7221
movl $0x1, %edx
callq 0x3230
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3b5a
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3b6f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x39f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: kazzmir[P]xborder/src/main.cpp
// Function: get_window_dimensions(_XDisplay*, unsigned long, int*, int*)
void get_window_dimensions(Display * display, Window window, int * width, int * height){
    XWindowAttributes attributes;
    XGetWindowAttributes(display, window, &attributes);
    *width = attributes.width;
    *height = attributes.height;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x3640
movl -0xa0(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x9c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
addq $0xb0, %rsp
popq %rbp
retq
// File: kazzmir[P]xborder/src/main.cpp
// Function: create_color(_XDisplay*, int, int, int)
XColor create_color(Display * display, int red, int green, int blue){
    XColor color;
    color.red = red;
    color.green = green;
    color.blue = blue;
    int screen = DefaultScreen(display);
    Colormap screen_colormap = DefaultColormap(display, screen);
    XAllocColor(display, screen_colormap, &color);
    return color;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movw -0x1c(%rbp), %ax
movw %ax, -0x8(%rbp)
movw -0x20(%rbp), %ax
movw %ax, -0x6(%rbp)
movw -0x24(%rbp), %ax
movw %ax, -0x4(%rbp)
movq -0x18(%rbp), %rax
movl 0xe0(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0xe8(%rax), %rax
movslq -0x28(%rbp), %rcx
shlq $0x7, %rcx
movq 0x50(%rax,%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x3260
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)