LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Viewer.cpp
// Function: gaps::R3Viewer::RotateCamera(double, int, int, int, int)
void R3Viewer::
RotateCamera(RNScalar factor, int x, int y, int, int)
{
    // Rotate camera based on mouse (x,y)                                                                                           
    RNLength vx = (RNLength) ((2 * x) - viewport.Width()) / (RNLength) viewport.Width();
    RNLength vy = (RNLength) ((2 * y) - viewport.Height()) / (RNLength) viewport.Height();
    RNAngle theta = factor * (RN_PI/64.0) * (vx*vx + vy*vy);
    R3Vector vector = (camera.Right() * vx) + (camera.Up() * vy);
    R3Vector axis = camera.Towards() % vector;
    axis.Normalize();
    RotateCamera(axis, theta);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movapd %xmm0, %xmm3
movq %rdi, %rbx
addl %esi, %esi
movl 0xa0(%rdi), %eax
subl %eax, %esi
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
movl 0xa4(%rdi), %ecx
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
addl %edx, %edx
subl %ecx, %edx
cvtsi2sd %edx, %xmm2
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
divsd %xmm1, %xmm2
movsd %xmm2, 0x8(%rsp)
leaq 0x9f69b(%rip), %rax     # 0xdde68
movsd (%rax), %xmm1
mulsd 0x9d3ef(%rip), %xmm1    # 0xdbbc8
mulsd %xmm1, %xmm3
movapd %xmm2, %xmm1
mulsd %xmm2, %xmm1
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
mulsd %xmm2, %xmm3
movsd %xmm3, 0x10(%rsp)
leaq 0x8(%rdi), %r14
leaq 0x20(%rdi), %rsi
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x767fa
leaq 0x38(%rbx), %rsi
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x767fa
leaq 0x48(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x76ab8
addq $0x50, %rbx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x76a98
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x76792
movq %rbx, %rdi
callq 0x76174
movq %r14, %rdi
movq %rbx, %rsi
movsd 0x10(%rsp), %xmm0
callq 0x4042a
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Viewer.cpp
// Function: gaps::R3Viewer::RotateCameraPitch(double, int, int, int, int)
void R3Viewer::
RotateCameraPitch(RNScalar factor, int x, int, int, int)
{
    // Rotate camera based on mouse (x)
    RNLength vx = (RNLength) ((2 * x) - viewport.Width()) / (RNLength) viewport.Width();
    RNAngle dpitch = factor * (RN_PI/64.0) * vx * ((vx < 0.0) ? -vx : vx); // vx*vx*vx;
    camera.RotatePitch(-dpitch);
}

// Assembly:
addl %esi, %esi
movl 0xa0(%rdi), %eax
subl %eax, %esi
cvtsi2sd %esi, %xmm1
cvtsi2sd %eax, %xmm2
divsd %xmm2, %xmm1
leaq 0x9f5c3(%rip), %rax     # 0xdde68
movsd (%rax), %xmm2
movapd 0x9bc8f(%rip), %xmm3    # 0xda540
xorpd %xmm1, %xmm3
maxsd %xmm1, %xmm3
mulsd 0x9d30f(%rip), %xmm2    # 0xdbbd0
addq $0x8, %rdi
mulsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm3, %xmm0
leaq 0x104190(%rip), %rsi    # 0x142a68
jmp 0x4042a
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Viewer.cpp
// Function: gaps::R3Viewer::RotateCameraYaw(double, int, int, int, int)
void R3Viewer::
RotateCameraYaw(RNScalar factor, int, int y, int, int)
{
    // Rotate camera based on mouse (x,y)
    RNLength vy = (RNLength) ((2 * y) - viewport.Height()) / (RNLength) viewport.Height();
    RNAngle dyaw = factor * (RN_PI/64.0) * vy * ((vy < 0.0) ? -vy : vy); // vy*vy*vy;
    camera.RotateYaw(dyaw);
}

// Assembly:
addl %edx, %edx
movl 0xa4(%rdi), %eax
subl %eax, %edx
cvtsi2sd %edx, %xmm1
cvtsi2sd %eax, %xmm2
leaq 0x9f571(%rip), %rax     # 0xdde68
movsd (%rax), %xmm3
mulsd 0x9d2c5(%rip), %xmm3    # 0xdbbc8
divsd %xmm2, %xmm1
mulsd %xmm3, %xmm0
mulsd %xmm1, %xmm0
movapd 0x9bc29(%rip), %xmm2    # 0xda540
xorpd %xmm1, %xmm2
maxsd %xmm1, %xmm2
mulsd %xmm2, %xmm0
leaq 0x8(%rdi), %rax
leaq 0x20(%rdi), %rsi
movq %rax, %rdi
jmp 0x4042a
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Viewer.cpp
// Function: gaps::R3Viewer::RotateCameraRoll(double, int, int, int, int)
void R3Viewer::
RotateCameraRoll(RNScalar factor, int x, int, int, int)
{
    // Rotate camera based on mouse (x,y)
    RNLength vx = (RNLength) ((2 * x) - viewport.Width()) / (RNLength) viewport.Width();
    RNAngle droll = factor * (RN_PI/64.0) * vx * ((vx < 0.0) ? -vx : vx); // vx*vx*vx;
    camera.RotateRoll(droll);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
addl %esi, %esi
movl 0xa0(%rdi), %eax
subl %eax, %esi
cvtsi2sd %esi, %xmm1
cvtsi2sd %eax, %xmm2
divsd %xmm2, %xmm1
leaq 0x9f510(%rip), %rax     # 0xdde68
movsd (%rax), %xmm2
mulsd 0x9d264(%rip), %xmm2    # 0xdbbc8
mulsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
movapd 0x9bbcc(%rip), %xmm2    # 0xda540
xorpd %xmm1, %xmm2
maxsd %xmm1, %xmm2
mulsd %xmm2, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x8(%rdi), %rbx
leaq 0x50(%rdi), %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x76a98
movq %rbx, %rdi
movq %r14, %rsi
movsd 0x8(%rsp), %xmm0
callq 0x4042a
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Viewer.cpp
// Function: gaps::R3Viewer::WorldRay(double, double) const
const R3Ray R3Viewer::
WorldRay(RNCoord x, RNCoord y) const
{
    // Return ray from camera origin to appropriate point on far plane
#if FALSE
    // This also works
    RNScalar dx = (RNScalar) (2 * (x - viewport.XCenter())) / (RNScalar) viewport.Width();
    RNScalar dy = (RNScalar) (2 * (y - viewport.YCenter())) / (RNScalar) viewport.Height();
    R3Vector v = camera.Towards();
    v.Rotate(camera.Up(), dx * camera.XFOV());
    v.Rotate(camera.Left(), dy * camera.YFOV());
    return R3Ray(camera.Origin(), v);
#else
    RNScalar dx = (RNScalar) (2 * (x - viewport.XCenter())) / (RNScalar) viewport.Width();
    RNScalar dy = (RNScalar) (2 * (y - viewport.YCenter())) / (RNScalar) viewport.Height();
    R3Point far_org = camera.Origin() + camera.Towards() * camera.Far();
    R3Vector far_right = camera.Right() * camera.Far() * tan(camera.XFOV());
    R3Vector far_up = camera.Up() * camera.Far() * tan(camera.YFOV());
    R3Point far_point = far_org + (far_right * dx) + (far_up * dy);
    return R3Ray(camera.Origin(), far_point);
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl 0xa0(%rsi), %ecx
movl 0xa4(%rsi), %eax
movl %ecx, %edx
shrl $0x1f, %edx
addl %ecx, %edx
sarl %edx
addl 0x98(%rsi), %edx
cvtsi2sd %edx, %xmm2
subsd %xmm2, %xmm0
addsd %xmm0, %xmm0
movapd %xmm0, %xmm3
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl 0x9c(%rsi), %ecx
xorps %xmm2, %xmm2
cvtsi2sd %ecx, %xmm2
divsd %xmm0, %xmm3
movsd %xmm3, (%rsp)
subsd %xmm2, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
addsd %xmm1, %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
leaq 0x8(%rsi), %r14
addq $0x50, %rsi
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x76a98
movsd 0x80(%r15), %xmm0
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x767fa
leaq 0xa0(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x7570f
leaq 0x20(%r15), %rsi
movsd 0x80(%r15), %xmm0
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
callq 0x767fa
movsd 0x68(%r15), %xmm0
callq 0x214c0
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %rbp, %rsi
callq 0x767fa
leaq 0x38(%r15), %rsi
movsd 0x80(%r15), %xmm0
leaq 0x28(%rsp), %rbp
movq %rbp, %rdi
callq 0x767fa
movsd 0x70(%r15), %xmm0
callq 0x214c0
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbp, %rsi
callq 0x767fa
leaq 0x70(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movsd (%rsp), %xmm0
callq 0x767fa
leaq 0x88(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x7570f
leaq 0x58(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movsd 0x8(%rsp), %xmm0
callq 0x767fa
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x7570f
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x74fbe
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Viewer.cpp
// Function: gaps::R3Viewer::ViewportPoint(gaps::R3Point const&) const
const R2Point R3Viewer::
ViewportPoint(const R3Point& point) const 
{
    // Transform 3D point into canonical coordinate system
    R3Point p = Camera().CoordSystem().InverseMatrix() * point;
    if (RNIsPositiveOrZero(p.Z())) return R2infinite_point;

    // Compute 2D point projected onto viewport
    RNCoord x = viewport.XCenter() + 0.5 * viewport.Width() * p.X() / -(p.Z() * tan(Camera().XFOV()));
    RNCoord y = viewport.YCenter() + 0.5 * viewport.Height() * p.Y() / -(p.Z() * tan(Camera().YFOV()));

    // Return point projected onto viewport
    return R2Point(x, y);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rsi
leaq 0x40(%rsp), %r12
movq %r12, %rdi
callq 0x701de
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x73dc2
movsd 0x10(%r13), %xmm1
leaq 0xfefa6(%rip), %rax     # 0x13e0d8
movsd (%rax), %xmm0
xorpd 0x9b402(%rip), %xmm0    # 0xda540
ucomisd %xmm0, %xmm1
jae 0x3f238
movl 0xa0(%r14), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl 0x98(%r14), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x9aea5(%rip), %xmm0    # 0xda020
mulsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x68(%r14), %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0x214c0
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
divsd %xmm0, %xmm1
movl 0xa4(%r14), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl 0x9c(%r14), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x9ae35(%rip), %xmm0    # 0xda020
mulsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x70(%r14), %xmm0
callq 0x214c0
mulsd 0x20(%rsp), %xmm0
movsd 0x8(%rsp), %xmm2
divsd %xmm0, %xmm2
movsd 0x10(%rsp), %xmm1
subsd %xmm2, %xmm1
movq %rbx, %rdi
movsd 0x18(%rsp), %xmm0
callq 0x819be
jmp 0x3f247
leaq 0x1072e1(%rip), %rsi    # 0x146520
movq %rbx, %rdi
callq 0x819c8
movq %rbx, %rax
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Viewer.cpp
// Function: gaps::R3Viewer::ViewportBCircle(gaps::R3Shape const&) const
const R2Circle R3Viewer::
ViewportBCircle(const R3Shape& shape) const 
{
    // Return bounding circle of shape projection on viewport
    R3Sphere bsphere(shape.BSphere());
    R3Point p = Camera().CoordSystem().InverseMatrix() * bsphere.Center();
    if (RNIsPositiveOrZero(p.Z())) return R2infinite_circle;

    // Compute sphere center projection
    RNCoord x = viewport.XCenter() + 0.5 * viewport.Width() * p.X() / -(p.Z() * tan(Camera().XFOV()));
    RNCoord y = viewport.YCenter() + 0.5 * viewport.Height() * p.Y() / -(p.Z() * tan(Camera().YFOV()));
    R2Point center(x, y);

    // Compute sphere radius projection
    RNScalar fov = (Camera().XFOV() > Camera().YFOV()) ? Camera().XFOV() : Camera().YFOV();
    RNScalar radius = 0.5 * viewport.Width() * bsphere.Radius() / -(p.Z() * fov);

    // Return bounding circle of projection
    return R2Circle(center, radius);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rax
leaq 0x40(%rsp), %rdi
movq %rdx, %rsi
callq *0x90(%rax)
leaq 0x8(%r14), %rsi
leaq 0x68(%rsp), %rdi
callq 0x701de
leaq 0x48(%rsp), %rdx
leaq 0x28(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x73dc2
movsd 0x38(%rsp), %xmm1
leaq 0xfead4(%rip), %rax     # 0x13e0d8
movsd (%rax), %xmm0
xorpd 0x9af30(%rip), %xmm0    # 0xda540
ucomisd %xmm0, %xmm1
jae 0x3f749
movl 0xa0(%r14), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl 0x98(%r14), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x9a9d3(%rip), %xmm0    # 0xda020
mulsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x68(%r14), %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0x214c0
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
divsd %xmm0, %xmm1
movl 0xa4(%r14), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl 0x9c(%r14), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x9a963(%rip), %xmm0    # 0xda020
mulsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x70(%r14), %xmm0
callq 0x214c0
mulsd 0x20(%rsp), %xmm0
movsd 0x8(%rsp), %xmm2
divsd %xmm0, %xmm2
movsd 0x10(%rsp), %xmm1
subsd %xmm2, %xmm1
leaq 0x68(%rsp), %rdi
movsd 0x18(%rsp), %xmm0
callq 0x819be
movsd 0x68(%r14), %xmm1
maxsd 0x70(%r14), %xmm1
xorps %xmm0, %xmm0
cvtsi2sdl 0xa0(%r14), %xmm0
mulsd 0x9adde(%rip), %xmm0    # 0xda508
mulsd 0x60(%rsp), %xmm0
mulsd 0x38(%rsp), %xmm1
divsd %xmm1, %xmm0
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0x7fcb4
jmp 0x3f758
leaq 0x1067d0(%rip), %rsi    # 0x145f20
movq %rbx, %rdi
callq 0x7fc68
leaq 0x40(%rsp), %rdi
callq 0x6dafc
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r14
retq
jmp 0x3f776
jmp 0x3f776
jmp 0x3f776
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x6dafc
movq %rbx, %rdi
callq 0x220c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Viewer.cpp
// Function: gaps::R3Viewer::ViewportArea(gaps::R3Shape const&) const
const RNArea R3Viewer::
ViewportArea(const R3Shape& shape) const 
{
    // Return area of shape projection on viewport
    R2Circle bcircle(ViewportBCircle(shape));
    if (bcircle.IsFinite()) return bcircle.Area();
    else return 0.0;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x3f5b4
movsd 0x18(%rbx), %xmm3
leaq 0xfe938(%rip), %rax     # 0x13e0e8
movsd (%rax), %xmm1
movapd 0x9ad84(%rip), %xmm2    # 0xda540
xorpd %xmm1, %xmm2
ucomisd %xmm2, %xmm3
xorps %xmm0, %xmm0
jbe 0x3f7d9
ucomisd %xmm3, %xmm1
jbe 0x3f7d9
leaq 0x10(%rsp), %rdi
callq 0x7fd42
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x8086c
movsd 0x8(%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8086c
movq %rbx, %rdi
callq 0x220c0
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Viewer.cpp
// Function: gaps::R3Viewer::DrawText(double, double, char const*, void*)
void R3Viewer::
DrawText(double x, double y, const char *str, void *font)
{
  // Draw text string s and position p
  R3Ray ray = WorldRay(x, y);
  R3Point position = ray.Point(2 * Camera().Near());
  R3DrawText(position, str, font);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3ef42
movsd 0x78(%r15), %xmm0
addsd %xmm0, %xmm0
movq %rsp, %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x74fca
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
movsd 0x10(%r15), %xmm2
callq 0x212b0
testq %r14, %r14
jne 0x3f868
leaq 0x106f38(%rip), %r14    # 0x1467a0
movb (%rbx), %al
testb %al, %al
je 0x3f885
incq %rbx
movsbl %al, %esi
movq %r14, %rdi
callq 0xcd6c0
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x3f871
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Camera.cpp
// Function: gaps::R3Camera::R3Camera(gaps::R3Point const&, double, double, double, double, double, double, double)
R3Camera::
R3Camera(const R3Point& origin, RNAngle pitch, RNAngle yaw, RNAngle roll,
		  RNAngle xfov, RNAngle yfov, RNLength neardist, RNLength fardist)
    : xfov(xfov),
      yfov(yfov),
      neardist(neardist),
      fardist(fardist),
      value(0),
      data(NULL)
{
    // Clamp yaw (roll is undefined at +-PI/2)
    const RNAngle max_yaw = 0.99 * RN_PI_OVER_TWO;
    if (yaw > max_yaw) yaw = max_yaw;
    if (yaw < -max_yaw) yaw = -max_yaw;

    // Derive  triad from pitch, yaw, and roll
    RNScalar cos_yaw = cos(yaw);
    R3Vector towards = R3Vector(cos_yaw * cos(pitch), cos_yaw * sin(pitch), sin(yaw));
    R3Vector up = R3posz_vector;
    up.Rotate(towards, roll);
    R3Triad triad(towards, up);

    // Set coordinate system
    cs = R3CoordSystem(origin, triad);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movsd %xmm6, 0x20(%rsp)
movsd %xmm5, 0x10(%rsp)
movsd %xmm4, 0x38(%rsp)
movsd %xmm3, 0x30(%rsp)
movsd %xmm2, 0x40(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x18(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
callq 0x700f0
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x60(%rbx)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x68(%rbx)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x70(%rbx)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x78(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rbx)
leaq 0x9e304(%rip), %rax     # 0xdde78
movsd (%rax), %xmm0
mulsd 0x9c098(%rip), %xmm0    # 0xdbc18
movapd %xmm0, %xmm1
minsd 0x8(%rsp), %xmm1
xorpd 0x9a9ae(%rip), %xmm0    # 0xda540
maxsd %xmm1, %xmm0
movapd %xmm0, 0x20(%rsp)
callq 0x221d0
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x221d0
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x21170
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movaps 0x20(%rsp), %xmm0
callq 0x21170
movaps %xmm0, %xmm2
leaq 0xc0(%rsp), %r15
movq %r15, %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x75e5e
leaq 0x9d1c7(%rip), %rsi     # 0xdcdd0
leaq 0xa8(%rsp), %r12
movq %r12, %rdi
callq 0x75e6e
movq %r12, %rdi
movq %r15, %rsi
movsd 0x40(%rsp), %xmm0
callq 0x7660a
leaq 0xd8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x7062e
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x70130
movq %rbx, %rdi
movq %r15, %rsi
callq 0x75732
leaq 0x18(%rbx), %rdi
leaq 0x60(%rsp), %rsi
callq 0x765ea
leaq 0x78(%rsp), %rsi
leaq 0x30(%rbx), %rdi
callq 0x765ea
leaq 0x90(%rsp), %rsi
addq $0x48, %rbx
movq %rbx, %rdi
callq 0x765ea
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Camera.cpp
// Function: gaps::R3Camera::Pitch() const
const RNAngle R3Camera::
Pitch(void) const
{
    // Return pitch angle
    R3Vector v1(Towards());
    RNAngle yaw = Yaw();
    if (RNIsNotZero(yaw)) v1.Rotate(Left(), yaw);
    RNAngle pitch = R3InteriorAngle(R3default_camera_towards_vector, v1);
    if (v1.Dot(R3default_camera_right_vector) > 0.0) pitch = -pitch;
    return pitch;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x76a98
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x76a98
leaq 0x102d94(%rip), %rdi    # 0x142a68
movq %r15, %rsi
callq 0x50933
leaq 0x9e195(%rip), %rax     # 0xdde78
movsd (%rax), %xmm1
subsd %xmm0, %xmm1
leaq 0xfe3e6(%rip), %rax     # 0x13e0d8
movsd (%rax), %xmm0
ucomisd %xmm0, %xmm1
ja 0x3fd0a
xorpd 0x9a83c(%rip), %xmm0    # 0xda540
ucomisd %xmm1, %xmm0
jbe 0x3fd35
addq $0x18, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movsd %xmm1, (%rsp)
callq 0x76a98
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movsd (%rsp), %xmm0
callq 0x7660a
leaq 0x102d14(%rip), %rdi    # 0x142a50
leaq 0x10(%rsp), %rbx
movq %rbx, %rsi
callq 0x50933
movapd %xmm0, (%rsp)
leaq 0x102ce3(%rip), %rsi    # 0x142a38
movq %rbx, %rdi
callq 0x760ea
movapd 0x9a7db(%rip), %xmm2    # 0xda540
movapd (%rsp), %xmm3
xorpd %xmm3, %xmm2
xorpd %xmm1, %xmm1
cmpltsd %xmm0, %xmm1
andpd %xmm1, %xmm2
andnpd %xmm3, %xmm1
orpd %xmm2, %xmm1
movapd %xmm1, %xmm0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Camera.cpp
// Function: gaps::R3Camera::Roll() const
const RNAngle R3Camera::
Roll(void) const
{
#if FALSE
    // Return roll angle
    R3Vector v2(Right());
    RNAngle yaw = Yaw();
    if (RNIsNotZero(yaw)) v2.Rotate(Left(), yaw);
    RNAngle roll = R3InteriorAngle(R3default_camera_up_vector, v2) - RN_PI_OVER_TWO;
    return roll;
#else
    // Return roll angle
    R3Vector v2 = Towards() % R3default_camera_up_vector; // Right vector if no roll
    RNAngle roll = R3InteriorAngle(Right(), v2);
    if (v2.Dot(Up()) > 0.0) roll = -roll;
    return roll;
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x48(%rdi), %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x76a98
leaq 0x102c74(%rip), %rdx    # 0x142a68
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x76792
leaq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0x50933
movapd %xmm0, (%rsp)
addq $0x30, %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x760ea
movapd 0x9a714(%rip), %xmm2    # 0xda540
movapd (%rsp), %xmm3
xorpd %xmm3, %xmm2
xorpd %xmm1, %xmm1
cmpltsd %xmm0, %xmm1
andpd %xmm1, %xmm2
andnpd %xmm3, %xmm1
orpd %xmm2, %xmm1
movapd %xmm1, %xmm0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Camera.cpp
// Function: gaps::R3Camera::Halfspace(int, int) const
const R3Halfspace R3Camera::
Halfspace(RNDirection dir, RNDimension dim) const
{
    R3Vector normal;
    switch (dim) {
    case RN_X:
        normal = cs.Axes().Axis(RN_X); 
	if (dir == RN_LO) normal.Rotate(cs.Axes().Axis(RN_Y), xfov);
	else normal.Rotate(cs.Axes().Axis(RN_Y), RN_PI - xfov);
	return R3Halfspace(Origin(), normal);
        break;

    case RN_Y:
        normal = cs.Axes().Axis(RN_Y); 
	if (dir == RN_LO) normal.Rotate(cs.Axes().Axis(RN_X), -yfov);
	else normal.Rotate(cs.Axes().Axis(RN_X), yfov - RN_PI);
	return R3Halfspace(Origin(), normal);
        break;

    case RN_Z:
        if (dir == RN_LO) return R3Halfspace(Origin() - cs.Axes().Axis(RN_Z) * neardist, -cs.Axes().Axis(RN_Z));
	else return R3Halfspace(Origin() - cs.Axes().Axis(RN_Z) * fardist, cs.Axes().Axis(RN_Z));
        break;
    }

    // Should never get here
    RNAbort("Invalid dim in camera halfspace query");
    return R3null_halfspace;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x75e5c
cmpl $0x2, %r15d
je 0x3fef6
cmpl $0x1, %r15d
je 0x3feca
testl %r15d, %r15d
jne 0x3ff33
leaq 0x18(%r14), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x765ea
leaq 0x30(%r14), %rsi
movsd 0x60(%r14), %xmm0
testl %ebp, %ebp
je 0x3fec2
leaq 0x9dfb2(%rip), %rax     # 0xdde68
movsd (%rax), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movq %r15, %rdi
jmp 0x3ff60
leaq 0x18(%r14), %r12
leaq 0x30(%r14), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x765ea
movsd 0x68(%r14), %xmm0
testl %ebp, %ebp
je 0x3ff52
leaq 0x9df78(%rip), %rax     # 0xdde68
subsd (%rax), %xmm0
jmp 0x3ff5a
leaq 0x48(%r14), %r15
testl %ebp, %ebp
je 0x3ff85
movsd 0x78(%r14), %xmm0
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x767fa
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x75deb
movq %rbx, %rdi
movq %r13, %rsi
jmp 0x3ff6b
leaq 0x9bd16(%rip), %rdi     # 0xdbc50
xorl %eax, %eax
callq 0x8a022
leaq 0x105998(%rip), %rsi    # 0x1458e0
movq %rbx, %rdi
callq 0x73e66
jmp 0x3ff73
xorpd 0x9a5e6(%rip), %xmm0    # 0xda540
movq %r15, %rdi
movq %r12, %rsi
callq 0x7660a
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x73e7e
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movsd 0x70(%r14), %xmm0
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x767fa
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x75deb
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x76a98
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
jmp 0x3ff6e
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Camera.cpp
// Function: gaps::R3Camera::Perspective() const
const R4Matrix R3Camera::
Perspective(void) const
{
#if FALSE
    // Return 4x4 perspective matrix
    double m[4][4];
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glLoadIdentity();
    gluPerspective(2.0 * RN_RAD2DEG(yfov), tan(xfov) / tan(yfov), neardist, fardist);
    glGetDoublev(GL_PROJECTION_MATRIX, m);
    glPopMatrix();
    glMatrixMode(GL_MODELVIEW);
    return R4Matrix(m);
#else 
    // Return 4x4 perspective matrix -- derived from OpenGL Programming Guide
    RNScalar A = 1.0 / tan(xfov);
    RNScalar B = 1.0 / tan(yfov);
    RNScalar C = -(fardist + neardist) / (fardist - neardist);
    RNScalar D = -2.0 * neardist * fardist / (fardist - neardist);
    return R4Matrix(  A, 0.0,  0.0, 0.0,
		    0.0,   B,  0.0, 0.0,
		    0.0, 0.0,    C,   D,
		    0.0, 0.0, -1.0, 0.0);
#endif
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x60(%rsi), %xmm0
callq 0x214c0
movsd 0x9a02f(%rip), %xmm2    # 0xda018
divsd %xmm0, %xmm2
movsd %xmm2, 0x40(%rsp)
movsd 0x68(%r14), %xmm0
callq 0x214c0
movsd 0x70(%r14), %xmm1
movsd 0x78(%r14), %xmm2
movapd %xmm2, %xmm3
addsd %xmm1, %xmm3
xorpd 0x9a526(%rip), %xmm3    # 0xda540
movsd 0x99ff6(%rip), %xmm5    # 0xda018
divsd %xmm0, %xmm5
movapd %xmm2, %xmm0
subsd %xmm1, %xmm0
divsd %xmm0, %xmm3
mulsd 0x9bbe6(%rip), %xmm1    # 0xdbc20
mulsd %xmm2, %xmm1
divsd %xmm0, %xmm1
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x30(%rsp)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x20(%rsp)
movupd %xmm0, (%rsp)
movsd %xmm1, 0x18(%rsp)
movsd %xmm3, 0x10(%rsp)
movq $0x0, 0x38(%rsp)
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
xorpd %xmm3, %xmm3
xorps %xmm4, %xmm4
xorps %xmm6, %xmm6
xorps %xmm7, %xmm7
movq %rbx, %rdi
movsd 0x40(%rsp), %xmm0
callq 0x71d66
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Camera.cpp
// Function: gaps::R3Camera::operator==(gaps::R3Camera const&) const
const RNBoolean R3Camera::
operator==(const R3Camera& camera) const
{
    // Return whether camera is equal
    return (cs == camera.cs) && 
           (xfov == camera.xfov) &&
           (yfov == camera.yfov) &&
           (neardist == camera.neardist) &&
           (fardist == camera.fardist);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x75490
xorl %ebx, %ebx
testl %eax, %eax
je 0x40121
leaq 0x18(%r14), %rdi
leaq 0x18(%r15), %rsi
callq 0x76110
testl %eax, %eax
je 0x40121
leaq 0x30(%r14), %rdi
leaq 0x30(%r15), %rsi
callq 0x76110
testl %eax, %eax
je 0x40121
movsd 0x60(%r14), %xmm0
ucomisd 0x60(%r15), %xmm0
jne 0x40121
jp 0x40121
movsd 0x68(%r14), %xmm0
ucomisd 0x68(%r15), %xmm0
jne 0x40121
jp 0x40121
movsd 0x70(%r14), %xmm0
ucomisd 0x70(%r15), %xmm0
jne 0x40121
jp 0x40121
movsd 0x78(%r15), %xmm0
cmpeqsd 0x78(%r14), %xmm0
movq %xmm0, %rbx
andl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Camera.cpp
// Function: gaps::R3Camera::Reorient(double, double, double)
void R3Camera::
Reorient(RNAngle pitch, RNAngle yaw, RNAngle roll)
{
    // Set orientation
    SetPitch(pitch);
    SetYaw(yaw);
    SetRoll(roll);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0x3fca0
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
leaq 0x10289e(%rip), %rsi    # 0x142a68
movq %rbx, %rdi
movapd %xmm1, %xmm0
callq 0x702da
movq %rbx, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x4022e
movq %rbx, %rdi
movsd 0x18(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
jmp 0x4028c
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Camera.cpp
// Function: gaps::R3Camera::Transform(gaps::R3Transformation const&)
void R3Camera::
Transform(const R3Transformation& transformation)
{
    // Transform near and far distances
    R3Vector zaxis(cs.Axes().Axis(RN_Z));
    zaxis.Transform(transformation);
    RNLength scale = zaxis.Length();
    neardist *= scale;
    fardist *= scale;
    
    // Transform coordinate system
    cs.Transform(transformation);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x48(%rdi), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x75e6e
movq %r15, %rdi
movq %rbx, %rsi
callq 0x769de
movq %r15, %rdi
callq 0x75f64
movupd 0x70(%r14), %xmm1
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm1, %xmm0
movupd %xmm0, 0x70(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x70334
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Camera.cpp
// Function: gaps::R3Camera::operator=(gaps::R3Camera const&)
R3Camera& R3Camera::
operator=(const R3Camera& camera)
{
    // Copy camera 
    this->cs = camera.cs;
    this->xfov = camera.xfov;
    this->yfov = camera.yfov;
    this->neardist = camera.neardist;
    this->fardist = camera.fardist;
    this->value = camera.value;
    return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x75732
leaq 0x18(%rbx), %rdi
leaq 0x18(%r14), %rsi
callq 0x765ea
leaq 0x30(%r14), %rsi
leaq 0x30(%rbx), %rdi
callq 0x765ea
leaq 0x48(%r14), %rsi
leaq 0x48(%rbx), %rdi
callq 0x765ea
movups 0x60(%r14), %xmm0
movups %xmm0, 0x60(%rbx)
movups 0x70(%r14), %xmm0
movups %xmm0, 0x70(%rbx)
movsd 0x80(%r14), %xmm0
movsd %xmm0, 0x80(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Camera.cpp
// Function: gaps::R3Camera::Load(int) const
void R3Camera::
Load(RNBoolean select_mode) const
{
    // Set the perspective projection
#if (RN_3D_GRFX == RN_IRISGL)
    perspective(20.0 * RN_RAD2DEG(yfov), tan(xfov) / tan(yfov), neardist, fardist);
#elif (RN_3D_GRFX == RN_OPENGL)
    if (!select_mode) {
      glMatrixMode(GL_PROJECTION);
      glLoadIdentity();
    }
    gluPerspective(2.0 * RN_RAD2DEG(yfov), tan(xfov) / tan(yfov), neardist, fardist);
    glMatrixMode(GL_MODELVIEW);
#elif ((RN_3D_GRFX == RN_3DR) && (RN_MATH_PRECISION == RN_FLOAT_PRECISION))
    PointFW_t loc;
    PointF_t dir, up;
    loc.x = Origin().X();   loc.y = Origin().Y();   loc.z = Origin().Z();   loc.w = 1.0;
    dir.x = Towards().X();  dir.y = Towards().Y();  dir.z = Towards().Z();
    up.x = Up().X();        up.y = Up().Y();        up.z = Up().Z();
    G3dSetCameraPosition(R3dr_gc, &loc, &dir, &up);
#else
    RNAbort("Not Implemented");
#endif

    // Load the rotation matrix
    cs.InverseMatrix().Load();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
testl %esi, %esi
jne 0x40510
movl $0x1701, %edi           # imm = 0x1701
callq 0x21cb0
callq 0x21c40
leaq 0x9d951(%rip), %rax     # 0xdde68
movsd 0x9b709(%rip), %xmm0    # 0xdbc28
divsd (%rax), %xmm0
mulsd 0x68(%rbx), %xmm0
addsd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x60(%rbx), %xmm0
callq 0x214c0
movsd %xmm0, 0x8(%rsp)
movsd 0x68(%rbx), %xmm0
callq 0x214c0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd 0x70(%rbx), %xmm2
movsd 0x78(%rbx), %xmm3
movsd 0x10(%rsp), %xmm0
callq 0x21ae0
movl $0x1700, %edi           # imm = 0x1700
callq 0x21cb0
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x701de
movq %r14, %rdi
callq 0x44f78
addq $0x98, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Camera.cpp
// Function: gaps::R3Camera::Draw(double) const
void R3Camera::
Draw(RNScalar scale) const
{
#if TRUE
    // Draw pyramid to near plane
    // static float pyramid_color[3] = { 1.0, 0.0, 0.0 };
    // R3LoadRgb(pyramid_color);
    R3Point org = Origin() + Towards() * scale;
    R3Vector dx = Right() * scale * tan(xfov);
    R3Vector dy = Up() * scale * tan(yfov);
    R3Point ur = org + dx + dy;
    R3Point lr = org + dx - dy;
    R3Point ul = org - dx + dy;
    R3Point ll = org - dx - dy;
    R3BeginLine();
    R3LoadPoint(ur);
    R3LoadPoint(ul);
    R3LoadPoint(ll);
    R3LoadPoint(lr);
    R3LoadPoint(ur);
    R3LoadPoint(Origin());
    R3LoadPoint(lr);
    R3LoadPoint(ll);
    R3LoadPoint(Origin());
    R3LoadPoint(ul);
    R3EndLine();
#endif

#if FALSE
    // Draw coordinate system 
    // static float cs_color[3] = { 0.0, 1.0, 0.0 };
    // R3LoadRgb(cs_color);
    cs.Draw();
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x48(%rdi), %rsi
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x76a98
leaq 0x80(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movsd (%rsp), %xmm0
callq 0x767fa
leaq 0xb0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x7570f
leaq 0x18(%rbx), %rsi
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movsd (%rsp), %xmm0
callq 0x767fa
movsd 0x60(%rbx), %xmm0
callq 0x214c0
leaq 0x80(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x767fa
leaq 0x30(%rbx), %rsi
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movsd (%rsp), %xmm0
callq 0x767fa
movsd 0x68(%rbx), %xmm0
callq 0x214c0
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x767fa
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x7570f
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x7570f
leaq 0x68(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x7570f
leaq 0x8(%rsp), %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x75deb
leaq 0x50(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x75deb
leaq 0x68(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x7570f
leaq 0x98(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x75deb
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x75deb
movl $0x3, %edi
callq 0x21190
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x211b0
movq %rbp, %rdi
callq 0x211b0
movq %r14, %rdi
callq 0x211b0
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x211b0
movq %r15, %rdi
callq 0x211b0
movq %rbx, %rdi
callq 0x211b0
movq %r12, %rdi
callq 0x211b0
movq %r14, %rdi
callq 0x211b0
movq %rbx, %rdi
callq 0x211b0
movq %rbp, %rdi
callq 0x211b0
callq 0x21c50
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3AreaLight.cpp
// Function: gaps::R3AreaLight::RadiusOfInfluence(double) const
RNScalar R3AreaLight::
RadiusOfInfluence(RNScalar intensity_threshhold) const
{
    // Return distance beyond which intensity is below threshold
    // kq*d^2 + kl*d + (kc - 1/a) = 0 (use quadratic formula)
    if (!IsActive()) return 0.0;
    if (RNIsZero(Intensity())) return 0.0;
    if (RNIsZero(intensity_threshhold)) return RN_INFINITY;
    RNScalar A = quadratic_attenuation;
    RNScalar B = linear_attenuation;
    RNScalar C = constant_attenuation - Intensity() / intensity_threshhold;
    RNScalar r = (-B + sqrt(B*B - 4.0*A*C)) / (2.0*A);
    return r + Radius();
}

// Assembly:
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
cmpl $0x0, 0x20(%rdi)
je 0x40d24
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0x28(%rdi), %xmm2
leaq 0xfd46a(%rip), %rax     # 0x13e0d8
movsd (%rax), %xmm3
movapd 0x998c6(%rip), %xmm4    # 0xda540
xorpd %xmm3, %xmm4
ucomisd %xmm4, %xmm2
jb 0x40c8e
ucomisd %xmm2, %xmm3
jae 0x40d1f
ucomisd %xmm4, %xmm1
jb 0x40ca7
ucomisd %xmm1, %xmm3
jb 0x40ca7
leaq 0xfd447(%rip), %rax     # 0x13e0e8
movsd (%rax), %xmm0
jmp 0x40d1f
movsd 0xa8(%rbx), %xmm3
movsd 0x98(%rbx), %xmm0
movsd 0xa0(%rbx), %xmm4
divsd %xmm1, %xmm2
subsd %xmm2, %xmm0
movsd 0x997e1(%rip), %xmm1    # 0xda4b0
mulsd %xmm3, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm4, %xmm0
mulsd %xmm4, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x40cf3
sqrtsd %xmm0, %xmm0
jmp 0x40d0e
movsd %xmm3, 0x8(%rsp)
movsd %xmm4, (%rsp)
callq 0x216c0
movsd (%rsp), %xmm4
movsd 0x8(%rsp), %xmm3
subsd %xmm4, %xmm0
addsd %xmm3, %xmm3
divsd %xmm3, %xmm0
addsd 0x70(%rbx), %xmm0
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3AreaLight.cpp
// Function: gaps::R3AreaLight::Draw(int) const
void R3AreaLight::
Draw(int i) const
{
    // Draw light
    GLenum index = (GLenum) (GL_LIGHT0 + i);
    if (index > GL_LIGHT7) return;
    GLfloat buffer[4];
    buffer[0] = Intensity() * Color().R();
    buffer[1] = Intensity() * Color().G();
    buffer[2] = Intensity() * Color().B();
    buffer[3] = 1.0;
    glLightfv(index, GL_DIFFUSE, buffer);
    glLightfv(index, GL_SPECULAR, buffer);
    buffer[0] = Position().X();
    buffer[1] = Position().Y();
    buffer[2] = Position().Z();
    buffer[3] = 1.0;
    glLightfv(index, GL_POSITION, buffer);
    buffer[0] = 90.0;
    glLightf(index, GL_SPOT_CUTOFF, buffer[0]);
    glEnable(index);
    buffer[0] = ConstantAttenuation();
    buffer[1] = LinearAttenuation();
    buffer[2] = QuadraticAttenuation();
    glLightf(index, GL_CONSTANT_ATTENUATION, buffer[0]);
    glLightf(index, GL_LINEAR_ATTENUATION, buffer[1]);
    glLightf(index, GL_QUADRATIC_ATTENUATION, buffer[2]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
addl $0x4000, %ebx           # imm = 0x4000
cmpl $0x4007, %ebx           # imm = 0x4007
ja 0x41737
movq %rdi, %r15
movupd 0x28(%rdi), %xmm0
movapd %xmm0, %xmm1
shufpd $0x1, %xmm0, %xmm1      # xmm1 = xmm1[1],xmm0[0]
movapd %xmm0, %xmm2
movhpd 0x38(%rdi), %xmm2       # xmm2 = xmm2[0],mem[0]
mulpd %xmm1, %xmm2
cvtpd2ps %xmm2, %xmm1
movq %rsp, %r14
movlpd %xmm1, (%r14)
mulsd 0x40(%rdi), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%r14)
movl $0x3f800000, %ebp       # imm = 0x3F800000
movl %ebp, 0xc(%r14)
movl %ebx, %edi
movl $0x1201, %esi           # imm = 0x1201
movq %r14, %rdx
callq 0x220a0
movl %ebx, %edi
movl $0x1202, %esi           # imm = 0x1202
movq %r14, %rdx
callq 0x220a0
movupd 0x58(%r15), %xmm0
cvtpd2ps %xmm0, %xmm0
movlpd %xmm0, (%r14)
xorps %xmm0, %xmm0
cvtsd2ss 0x68(%r15), %xmm0
movss %xmm0, 0x8(%r14)
movl %ebp, 0xc(%r14)
movl %ebx, %edi
movl $0x1203, %esi           # imm = 0x1203
movq %r14, %rdx
callq 0x220a0
movl $0x42b40000, (%r14)     # imm = 0x42B40000
movss 0x9a5a8(%rip), %xmm0    # 0xdbc78
movl %ebx, %edi
movl $0x1206, %esi           # imm = 0x1206
callq 0x211c0
movl %ebx, %edi
callq 0x21810
movupd 0x98(%r15), %xmm0
cvtpd2ps %xmm0, %xmm0
movlpd %xmm0, (%r14)
xorps %xmm1, %xmm1
cvtsd2ss 0xa8(%r15), %xmm1
movss %xmm1, 0x8(%r14)
movl %ebx, %edi
movl $0x1207, %esi           # imm = 0x1207
callq 0x211c0
movss 0x4(%r14), %xmm0
movl %ebx, %edi
movl $0x1208, %esi           # imm = 0x1208
callq 0x211c0
movss 0x8(%r14), %xmm0
movl %ebx, %edi
movl $0x1209, %esi           # imm = 0x1209
callq 0x211c0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3SpotLight.cpp
// Function: gaps::R3SpotLight::IntensityAtPoint(gaps::R3Point const&) const
RNScalar R3SpotLight::
IntensityAtPoint(const R3Point& point) const
{
    // Return intensity at point
    RNScalar I = R3PointLight::IntensityAtPoint(point);
    R3Vector ML = point - Position();
    ML.Normalize();
    RNScalar cos_alpha = ML.Dot(Direction());
    if (cos(cutoffangle) > cos_alpha) return 0.0;
    else return (I * pow(cos_alpha, dropoffrate));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x41cf2
movsd %xmm0, 0x8(%rsp)
leaq 0x50(%rbx), %rdx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x75626
movq %r15, %rdi
callq 0x76174
leaq 0x80(%rbx), %rsi
movq %r15, %rdi
callq 0x760ea
movsd %xmm0, 0x10(%rsp)
movsd 0xa0(%rbx), %xmm0
callq 0x221d0
movsd 0x10(%rsp), %xmm2
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm2, %xmm1
ja 0x419d1
movsd 0x98(%rbx), %xmm1
movapd %xmm2, %xmm0
callq 0x22090
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3PointLight.cpp
// Function: gaps::R3PointLight::IntensityAtPoint(gaps::R3Point const&) const
RNScalar R3PointLight::
IntensityAtPoint(const R3Point& point) const
{
    // Return intensity at point
    if (!IsActive()) return 0.0;
    RNLength d = R3Distance(point, position);
    RNScalar denom = constant_attenuation;
    denom += d * linear_attenuation;
    denom += d * d * quadratic_attenuation;
    if (RNIsZero(denom)) return Intensity();
    else return (Intensity() / denom);
}

// Assembly:
cmpl $0x0, 0x20(%rdi)
je 0x41d55
pushq %rbx
movq %rdi, %rbx
leaq 0x50(%rdi), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x4e0d4
movsd 0x70(%rbx), %xmm1
mulsd %xmm0, %xmm1
addsd 0x68(%rbx), %xmm1
mulsd %xmm0, %xmm0
mulsd 0x78(%rbx), %xmm0
addsd %xmm1, %xmm0
leaq 0xfc3ab(%rip), %rax     # 0x13e0d8
movsd (%rax), %xmm2
movapd 0x98807(%rip), %xmm1    # 0xda540
xorpd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
movsd 0x28(%rbx), %xmm1
popq %rbx
jb 0x41d4f
ucomisd %xmm0, %xmm2
jae 0x41d59
divsd %xmm0, %xmm1
jmp 0x41d59
xorpd %xmm1, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3PointLight.cpp
// Function: gaps::R3PointLight::RadiusOfInfluence(double) const
RNScalar R3PointLight::
RadiusOfInfluence(RNScalar intensity_threshhold) const
{
    // Return distance beyond which intensity is below threshold
    // kq*d^2 + kl*d + (kc - 1/a) = 0 (use quadratic formula)
    if (!IsActive()) return 0.0;
    if (RNIsZero(Intensity())) return 0.0;
    if (RNIsZero(intensity_threshhold)) return RN_INFINITY;
    RNScalar A = quadratic_attenuation;
    RNScalar B = linear_attenuation;
    RNScalar C = constant_attenuation - Intensity() / intensity_threshhold;
    RNScalar radius = (-B + sqrt(B*B - 4.0*A*C)) / (2.0*A);
    return radius;
}

// Assembly:
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
cmpl $0x0, 0x20(%rdi)
je 0x41dae
movsd 0x28(%rdi), %xmm2
leaq 0xfc346(%rip), %rax     # 0x13e0d8
movsd (%rax), %xmm3
movapd 0x987a2(%rip), %xmm4    # 0xda540
xorpd %xmm3, %xmm4
ucomisd %xmm4, %xmm2
jb 0x41daf
ucomisd %xmm2, %xmm3
jb 0x41daf
retq
ucomisd %xmm4, %xmm1
jb 0x41dc7
ucomisd %xmm1, %xmm3
jb 0x41dc7
leaq 0xfc326(%rip), %rax     # 0x13e0e8
movsd (%rax), %xmm0
retq
movsd 0x78(%rdi), %xmm3
movsd 0x68(%rdi), %xmm0
movsd 0x70(%rdi), %xmm4
divsd %xmm1, %xmm2
subsd %xmm2, %xmm0
movsd 0x986ca(%rip), %xmm1    # 0xda4b0
mulsd %xmm3, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm4, %xmm0
mulsd %xmm4, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x41e0a
sqrtsd %xmm0, %xmm0
jmp 0x41e2f
subq $0x18, %rsp
movsd %xmm3, 0x10(%rsp)
movsd %xmm4, 0x8(%rsp)
callq 0x216c0
movsd 0x8(%rsp), %xmm4
movsd 0x10(%rsp), %xmm3
addq $0x18, %rsp
subsd %xmm4, %xmm0
addsd %xmm3, %xmm3
divsd %xmm3, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3PointLight.cpp
// Function: gaps::R3PointLight::DiffuseReflection(gaps::R3Brdf const&, gaps::R3Point const&, gaps::R3Vector const&) const
RNRgb R3PointLight::
DiffuseReflection(const R3Brdf& brdf, 
    const R3Point& point, const R3Vector& normal) const
{
    // Check if light is active
    if (!IsActive()) return RNblack_rgb;

    // Get material properties
    const RNRgb& Dc = brdf.Diffuse();

    // Get light properties
    const RNRgb& Ic = Color();
    RNScalar I = IntensityAtPoint(point);
    R3Vector L = DirectionFromPoint(point);

    // Compute geometric stuff
    RNScalar NL = normal.Dot(L);
    if (RNIsNegativeOrZero(NL)) return RNblack_rgb;

    // Return diffuse component of reflection
    return (I * NL) * Dc * Ic;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x20(%rsi)
je 0x41f2e
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
movq %rcx, %rsi
callq *0x40(%rax)
movsd %xmm0, (%rsp)
movq (%r14), %rax
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq *0xb0(%rax)
movq %r12, %rdi
movq %rbp, %rsi
callq 0x760ea
leaq 0xfc211(%rip), %rax     # 0x13e0d8
movsd (%rax), %xmm1
ucomisd %xmm0, %xmm1
jae 0x41f2e
movsd (%rsp), %xmm2
mulsd %xmm0, %xmm2
movsd 0x38(%r15), %xmm0
mulsd %xmm2, %xmm0
movsd 0x40(%r15), %xmm1
mulsd %xmm2, %xmm1
mulsd 0x48(%r15), %xmm2
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x87400
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
mulsd 0x30(%r14), %xmm0
mulsd 0x38(%r14), %xmm1
movsd 0x10(%r15), %xmm2
mulsd 0x40(%r14), %xmm2
movq %rbx, %rdi
callq 0x87400
jmp 0x41f3d
leaq 0x1046ab(%rip), %rsi    # 0x1465e0
movq %rbx, %rdi
callq 0x873e2
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3PointLight.cpp
// Function: gaps::R3PointLight::SpecularReflection(gaps::R3Brdf const&, gaps::R3Point const&, gaps::R3Point const&, gaps::R3Vector const&) const
RNRgb R3PointLight::
SpecularReflection(const R3Brdf& brdf, const R3Point& eye, 
    const R3Point& point, const R3Vector& normal) const
{
    // Check if light is active
    if (!IsActive()) return RNblack_rgb;

    // Get material properties
    const RNRgb& Sc = brdf.Specular();
    RNScalar s = brdf.Shininess();

    // Get light properties
    const RNRgb& Ic = Color();
    RNScalar I = IntensityAtPoint(point);
    R3Vector L = DirectionFromPoint(point);

    // Compute geometric stuff
    RNScalar NL = normal.Dot(L);
    if (RNIsNegativeOrZero(NL)) return RNblack_rgb;
    R3Vector R = (2.0 * NL) * normal - L;
    R3Vector V = eye - point;
    V.Normalize();
    RNScalar VR = V.Dot(R);
    if (RNIsNegativeOrZero(VR)) return RNblack_rgb;

    // Return specular component of reflection
    return (I * pow(VR,s)) * Sc * Ic;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x20(%rsi)
je 0x4209c
movq %r9, %rbp
movq %r8, %r12
movq %rdx, %r15
movq %rsi, %r14
movq %rcx, 0x10(%rsp)
movsd 0x98(%rdx), %xmm0
movsd %xmm0, (%rsp)
movq (%rsi), %rax
movq %rsi, %rdi
movq %r8, %rsi
callq *0x40(%rax)
movsd %xmm0, 0x8(%rsp)
movq (%r14), %rax
leaq 0x30(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq *0xb0(%rax)
movq %rbp, %rdi
movq %r13, %rsi
callq 0x760ea
leaq 0xfc114(%rip), %rax     # 0x13e0d8
movsd (%rax), %xmm1
ucomisd %xmm0, %xmm1
jae 0x4209c
addsd %xmm0, %xmm0
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %rbp, %rsi
callq 0x767fa
leaq 0x60(%rsp), %rbp
leaq 0x30(%rsp), %rdx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x76adb
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq 0x10(%rsp), %rsi
movq %r12, %rdx
callq 0x75626
movq %r13, %rdi
callq 0x76174
movq %r13, %rdi
movq %rbp, %rsi
callq 0x760ea
leaq 0xfc0ae(%rip), %rax     # 0x13e0d8
movsd (%rax), %xmm1
ucomisd %xmm0, %xmm1
jae 0x4209c
movsd (%rsp), %xmm1
callq 0x22090
movsd 0x8(%rsp), %xmm2
mulsd %xmm0, %xmm2
movsd 0x50(%r15), %xmm0
mulsd %xmm2, %xmm0
movsd 0x58(%r15), %xmm1
mulsd %xmm2, %xmm1
mulsd 0x60(%r15), %xmm2
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x87400
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
mulsd 0x30(%r14), %xmm0
mulsd 0x38(%r14), %xmm1
movsd 0x10(%r15), %xmm2
mulsd 0x40(%r14), %xmm2
movq %rbx, %rdi
callq 0x87400
jmp 0x420ab
leaq 0x10453d(%rip), %rsi    # 0x1465e0
movq %rbx, %rdi
callq 0x873e2
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop