LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Viewer.cpp
// Function: gaps::R3Viewer::TranslateWorld(double, gaps::R3Point const&, int, int, int, int)
void R3Viewer::
TranslateWorld(RNScalar factor, const R3Point& origin, int, int, int dx, int dy)
{
    // Translate world based on mouse (dx,dy)
    if ((dx == 0) && (dy == 0)) return;
    RNLength length = factor * R3Distance(origin, camera.Origin()) * tan(camera.XFOV());
    RNLength vx = length * (RNLength) dx / (RNLength) viewport.Width();
    RNLength vy = length * (RNLength) dy / (RNLength) viewport.Height();
    R3Vector vector = (camera.Right() * vx) + (camera.Up() * vy);
    TranslateWorld(vector);
}

// Assembly:
movl %r9d, %eax
orl %r8d, %eax
je 0x3a2af
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %r9d, %ebp
movl %r8d, %r14d
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movq %rsi, %rdi
movq %rax, %rsi
movsd %xmm0, (%rsp)
callq 0x48146
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x68(%rbx), %xmm0
callq 0x214c0
movapd %xmm0, %xmm2
cvtsi2sd %r14d, %xmm0
mulsd (%rsp), %xmm2
mulsd %xmm2, %xmm0
cvtsi2sdl 0xa0(%rbx), %xmm1
divsd %xmm1, %xmm0
cvtsi2sd %ebp, %xmm1
mulsd %xmm1, %xmm2
cvtsi2sdl 0xa4(%rbx), %xmm1
divsd %xmm1, %xmm2
movsd %xmm2, (%rsp)
leaq 0x20(%rbx), %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x6c72a
leaq 0x38(%rbx), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movsd (%rsp), %xmm0
callq 0x6c72a
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6c9ba
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3a092
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Viewer.cpp
// Function: gaps::R3Viewer::ScaleWorld(double, gaps::R3Point const&, int, int, int, int)
void R3Viewer::
ScaleWorld(RNScalar factor, const R3Point& origin, int, int, int dx, int dy)
{
    // Scale world based on mouse dx
    if ((dx == 0) && (dy == 0)) return;
    RNScalar motion = (RNScalar) dx / (RNScalar) viewport.Width() + (RNScalar) dy / (RNScalar) viewport.Height();
    RNScalar scale = exp(2.0 * factor * motion);
    ScaleWorld(origin, scale);
}

// Assembly:
movl %r9d, %eax
orl %r8d, %eax
je 0x3a30b
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movd %r9d, %xmm1
movd %r8d, %xmm2
punpckldq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
cvtdq2pd 0xa0(%rdi), %xmm1
cvtdq2pd %xmm2, %xmm2
divpd %xmm1, %xmm2
movapd %xmm2, %xmm1
unpckhpd %xmm2, %xmm1            # xmm1 = xmm1[1],xmm2[1]
addsd %xmm2, %xmm1
addsd %xmm0, %xmm0
mulsd %xmm1, %xmm0
callq 0x22130
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3a0be
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Viewer.cpp
// Function: gaps::R3Viewer::RotateWorld(double, gaps::R3Point const&, int, int, int, int)
void R3Viewer::
RotateWorld(RNScalar factor, const R3Point& origin, int, int, int dx, int dy)
{
    // Rotate world based on mouse (dx)
    if ((dx == 0) && (dy == 0)) return;
    RNLength vx = (RNLength) dx / (RNLength) viewport.Width();
    RNLength vy = (RNLength) dy / (RNLength) viewport.Height();
    RNAngle theta = factor * 4.0 * (fabs(vx) + fabs(vy));
    R3Vector vector = (camera.Right() * vx) + (camera.Up() * vy);
    R3Vector axis = camera.Towards() % vector;
    axis.Normalize();
    RotateWorld(origin, axis, theta);
}

// Assembly:
movl %r9d, %eax
orl %r8d, %eax
je 0x3a401
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movd %r9d, %xmm1
movd %r8d, %xmm2
punpckldq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
cvtdq2pd %xmm2, %xmm3
mulsd 0x8c84b(%rip), %xmm0    # 0xc6b90
cvtdq2pd 0xa0(%rdi), %xmm1
divpd %xmm1, %xmm3
movapd 0x8c867(%rip), %xmm1    # 0xc6bc0
andpd %xmm3, %xmm1
movapd %xmm3, (%rsp)
pshufd $0xee, %xmm1, %xmm2     # xmm2 = xmm1[2,3,2,3]
addsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
movapd %xmm2, 0x10(%rsp)
leaq 0x20(%rdi), %rsi
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movapd %xmm3, %xmm0
callq 0x6c72a
leaq 0x38(%r14), %rsi
movaps (%rsp), %xmm0
movhlps %xmm0, %xmm0            # xmm0 = xmm0[1,1]
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x6c72a
leaq 0x58(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x6c9ba
leaq 0x50(%r14), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x6c99a
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x6c6e6
movq %r12, %rdi
callq 0x6c336
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movaps 0x10(%rsp), %xmm0
callq 0x3a120
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
cvtsi2sd %esi, %xmm0
movl 0xa4(%rdi), %ecx
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
addl %edx, %edx
subl %ecx, %edx
cvtsi2sd %edx, %xmm2
cvtsi2sd %ecx, %xmm1
divsd %xmm1, %xmm2
movsd %xmm2, 0x8(%rsp)
leaq 0x8e8f3(%rip), %rax     # 0xc8df8
movsd (%rax), %xmm1
mulsd 0x8c687(%rip), %xmm1    # 0xc6b98
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 0x6c72a
leaq 0x38(%rbx), %rsi
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x6c72a
leaq 0x48(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x6c9ba
addq $0x50, %rbx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6c99a
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x6c6e6
movq %rbx, %rdi
callq 0x6c336
movq %r14, %rdi
movq %rbx, %rsi
movsd 0x10(%rsp), %xmm0
callq 0x3c03e
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8e81b(%rip), %rax     # 0xc8df8
movsd (%rax), %xmm2
movapd 0x8af47(%rip), %xmm3    # 0xc5530
xorpd %xmm1, %xmm3
maxsd %xmm1, %xmm3
addq $0x8, %rdi
mulsd 0x8c5a3(%rip), %xmm2    # 0xc6ba0
mulsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm3, %xmm0
jmp 0x3b51a
// File: /workspace/github_cpp_makefile_star2_O2/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
divsd %xmm2, %xmm1
leaq 0x8e7cd(%rip), %rax     # 0xc8df8
movsd (%rax), %xmm2
mulsd 0x8c561(%rip), %xmm2    # 0xc6b98
mulsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
movapd 0x8aee9(%rip), %xmm2    # 0xc5530
xorpd %xmm1, %xmm2
maxsd %xmm1, %xmm2
mulsd %xmm2, %xmm0
addq $0x8, %rdi
jmp 0x3b526
// File: /workspace/github_cpp_makefile_star2_O2/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:
addl %esi, %esi
movl 0xa0(%rdi), %eax
subl %eax, %esi
cvtsi2sd %esi, %xmm1
cvtsi2sd %eax, %xmm2
divsd %xmm2, %xmm1
leaq 0x8e77f(%rip), %rax     # 0xc8df8
movsd (%rax), %xmm2
mulsd 0x8c513(%rip), %xmm2    # 0xc6b98
mulsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
movapd 0x8ae9b(%rip), %xmm2    # 0xc5530
xorpd %xmm1, %xmm2
maxsd %xmm1, %xmm2
mulsd %xmm2, %xmm0
addq $0x8, %rdi
jmp 0x3b530
// File: /workspace/github_cpp_makefile_star2_O2/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), %esi
pushq $0x2
popq %rdi
movl %ecx, %eax
cltd
idivl %edi
addl 0x98(%r15), %eax
cvtsi2sd %eax, %xmm2
subsd %xmm2, %xmm0
addsd %xmm0, %xmm0
cvtsi2sd %ecx, %xmm3
movl %esi, %eax
cltd
idivl %edi
addl 0x9c(%r15), %eax
cvtsi2sd %eax, %xmm2
divsd %xmm3, %xmm0
movsd %xmm0, (%rsp)
subsd %xmm2, %xmm1
cvtsi2sd %esi, %xmm0
addsd %xmm1, %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
leaq 0x8(%r15), %r14
leaq 0x50(%r15), %rsi
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x6c99a
movsd 0x80(%r15), %xmm0
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x6c72a
leaq 0xa0(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x6bb3b
leaq 0x20(%r15), %rsi
movsd 0x80(%r15), %xmm0
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
callq 0x6c72a
movsd 0x68(%r15), %xmm0
callq 0x214c0
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %rbp, %rsi
callq 0x6c72a
leaq 0x38(%r15), %rsi
movsd 0x80(%r15), %xmm0
leaq 0x28(%rsp), %rbp
movq %rbp, %rdi
callq 0x6c72a
movsd 0x70(%r15), %xmm0
callq 0x214c0
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbp, %rsi
callq 0x6c72a
leaq 0x70(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movsd (%rsp), %xmm0
callq 0x6c72a
leaq 0x88(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x6bb3b
leaq 0x58(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movsd 0x8(%rsp), %xmm0
callq 0x6c72a
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x6bb3b
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6b48c
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_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rsi
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x66f88
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x6a307
movsd 0x10(%r13), %xmm1
leaq 0xf4327(%rip), %rax     # 0x12f0f8
movsd (%rax), %xmm0
xorpd 0x8a753(%rip), %xmm0    # 0xc5530
ucomisd %xmm0, %xmm1
jae 0x3aec2
movl 0xa0(%r14), %ecx
pushq $0x2
popq %rbp
movl %ecx, %eax
cltd
idivl %ebp
addl 0x98(%r14), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%rsp)
cvtsi2sd %ecx, %xmm0
mulsd 0x8a22d(%rip), %xmm0    # 0xc5040
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x68(%r14), %xmm0
movsd %xmm1, (%rsp)
callq 0x214c0
mulsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movl 0xa4(%r14), %ecx
movl %ecx, %eax
cltd
idivl %ebp
addl 0x9c(%r14), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
cvtsi2sd %ecx, %xmm0
mulsd 0x8a1c9(%rip), %xmm0    # 0xc5040
mulsd 0x28(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x70(%r14), %xmm0
callq 0x214c0
mulsd 0x18(%rsp), %xmm0
movsd (%rsp), %xmm2
divsd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm1
subsd %xmm2, %xmm1
movq %rbx, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x76d94
jmp 0x3aed1
leaq 0xfc677(%rip), %rsi     # 0x137540
movq %rbx, %rdi
callq 0x76d9e
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_O2/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 %rbp
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rax
leaq 0x38(%rsp), %rdi
movq %rdx, %rsi
callq *0x90(%rax)
leaq 0x8(%r14), %rsi
leaq 0x60(%rsp), %rdi
callq 0x66f88
leaq 0x40(%rsp), %rdx
leaq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x6a307
movsd 0x30(%rsp), %xmm1
leaq 0xf3eb1(%rip), %rax     # 0x12f0f8
movsd (%rax), %xmm0
xorpd 0x8a2dd(%rip), %xmm0    # 0xc5530
ucomisd %xmm0, %xmm1
jae 0x3b374
movl 0xa0(%r14), %ecx
pushq $0x2
popq %rbp
movl %ecx, %eax
cltd
idivl %ebp
addl 0x98(%r14), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%rsp)
cvtsi2sd %ecx, %xmm0
mulsd 0x89db7(%rip), %xmm0    # 0xc5040
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x68(%r14), %xmm0
movsd %xmm1, (%rsp)
callq 0x214c0
mulsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movl 0xa4(%r14), %ecx
movl %ecx, %eax
cltd
idivl %ebp
addl 0x9c(%r14), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
cvtsi2sd %ecx, %xmm0
mulsd 0x89d53(%rip), %xmm0    # 0xc5040
mulsd 0x28(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x70(%r14), %xmm0
callq 0x214c0
mulsd 0x18(%rsp), %xmm0
movsd (%rsp), %xmm2
divsd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm1
subsd %xmm2, %xmm1
leaq 0x60(%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x76d94
movsd 0x68(%r14), %xmm1
maxsd 0x70(%r14), %xmm1
cvtsi2sdl 0xa0(%r14), %xmm0
mulsd 0x8b863(%rip), %xmm0    # 0xc6bb8
mulsd 0x58(%rsp), %xmm0
mulsd 0x30(%rsp), %xmm1
divsd %xmm1, %xmm0
leaq 0x60(%rsp), %rsi
movq %rbx, %rdi
callq 0x75208
jmp 0x3b383
leaq 0xfbbc5(%rip), %rsi     # 0x136f40
movq %rbx, %rdi
callq 0x751bc
leaq 0x38(%rsp), %rdi
callq 0x6499a
movq %rbx, %rax
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x3b3a2
jmp 0x3b3a2
jmp 0x3b3a2
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x6499a
movq %rbx, %rdi
callq 0x220e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3b1f6
movsd 0x18(%rbx), %xmm3
leaq 0xf3d2c(%rip), %rax     # 0x12f108
movsd (%rax), %xmm1
movapd 0x8a148(%rip), %xmm2    # 0xc5530
xorpd %xmm1, %xmm2
ucomisd %xmm2, %xmm3
xorps %xmm0, %xmm0
jbe 0x3b405
ucomisd %xmm3, %xmm1
jbe 0x3b405
leaq 0x10(%rsp), %rdi
callq 0x75294
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x75cce
movsd 0x8(%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x75cce
movq %rbx, %rdi
callq 0x220e0
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3abf0
movsd 0x78(%r15), %xmm0
addsd %xmm0, %xmm0
movq %rsp, %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x6b498
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3b56a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x66ebe
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 0x8d572(%rip), %rax     # 0xc8e08
movsd (%rax), %xmm0
mulsd 0x8b346(%rip), %xmm0    # 0xc6be8
movapd %xmm0, %xmm1
minsd 0x8(%rsp), %xmm1
xorpd 0x89c7c(%rip), %xmm0    # 0xc5530
maxsd %xmm1, %xmm0
movapd %xmm0, 0x20(%rsp)
callq 0x221f0
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x221f0
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 0x60(%rsp), %r15
movq %r15, %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x6c034
leaq 0x8c438(%rip), %rsi     # 0xc7d60
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0x6c044
movq %r12, %rdi
movq %r15, %rsi
movsd 0x40(%rsp), %xmm0
callq 0x6c5c4
leaq 0x78(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x67360
leaq 0xc0(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x66efe
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3c376
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x48(%rdi), %rsi
leaq 0x18(%rsp), %rdi
callq 0x6c99a
movq %rbx, %rdi
callq 0x3ba50
leaq 0xf3745(%rip), %rax     # 0x12f0f8
movsd (%rax), %xmm1
ucomisd %xmm1, %xmm0
ja 0x3b9cb
xorpd 0x89b6b(%rip), %xmm1    # 0xc5530
ucomisd %xmm0, %xmm1
jbe 0x3b9f6
addq $0x18, %rbx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movsd %xmm0, (%rsp)
callq 0x6c99a
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
movsd (%rsp), %xmm0
callq 0x6c5c4
leaq 0xf8073(%rip), %rdi     # 0x133a70
leaq 0x18(%rsp), %rbx
movq %rbx, %rsi
callq 0x4a48b
movapd %xmm0, (%rsp)
leaq 0xf8042(%rip), %rsi     # 0x133a58
movq %rbx, %rdi
callq 0x6c2ae
movapd 0x89b0a(%rip), %xmm2    # 0xc5530
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 $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6c99a
leaq 0xf7fd6(%rip), %rdx     # 0x133a88
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6c6e6
leaq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0x4a48b
movapd %xmm0, (%rsp)
addq $0x30, %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6c2ae
movapd 0x89a46(%rip), %xmm2    # 0xc5530
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_O2/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 0x6c032
cmpl $0x2, %r15d
je 0x3bbb4
cmpl $0x1, %r15d
je 0x3bb88
testl %r15d, %r15d
jne 0x3bbf1
leaq 0x18(%r14), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6c5a4
leaq 0x30(%r14), %rsi
movsd 0x60(%r14), %xmm0
testl %ebp, %ebp
je 0x3bb80
leaq 0x8d284(%rip), %rax     # 0xc8df8
movsd (%rax), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movq %r15, %rdi
jmp 0x3bc1e
leaq 0x18(%r14), %r12
leaq 0x30(%r14), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6c5a4
movsd 0x68(%r14), %xmm0
testl %ebp, %ebp
je 0x3bc10
leaq 0x8d24a(%rip), %rax     # 0xc8df8
subsd (%rax), %xmm0
jmp 0x3bc18
leaq 0x48(%r14), %r15
testl %ebp, %ebp
je 0x3bc43
movsd 0x78(%r14), %xmm0
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6c72a
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x6bfc5
movq %rbx, %rdi
movq %r13, %rsi
jmp 0x3bc29
leaq 0x8b010(%rip), %rdi     # 0xc6c08
xorl %eax, %eax
callq 0x7e764
leaq 0xfacfa(%rip), %rsi     # 0x136900
movq %rbx, %rdi
callq 0x6a3f4
jmp 0x3bc31
xorpd 0x89918(%rip), %xmm0    # 0xc5530
movq %r15, %rdi
movq %r12, %rsi
callq 0x6c5c4
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6a40c
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 0x6c72a
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x6bfc5
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x6c99a
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
jmp 0x3bc2c
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x89371(%rip), %xmm2    # 0xc5018
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 0x89858(%rip), %xmm3    # 0xc5530
movsd 0x89338(%rip), %xmm5    # 0xc5018
divsd %xmm0, %xmm5
movapd %xmm2, %xmm0
subsd %xmm1, %xmm0
divsd %xmm0, %xmm3
mulsd 0x8aef8(%rip), %xmm1    # 0xc6bf0
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)
andq $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 0x68818
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3c3a0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0x3bdb6
movsd 0x60(%rbx), %xmm0
ucomisd 0x60(%r14), %xmm0
jne 0x3bdb6
jp 0x3bdb6
movsd 0x68(%rbx), %xmm0
ucomisd 0x68(%r14), %xmm0
jne 0x3bdb6
jp 0x3bdb6
movsd 0x70(%rbx), %xmm0
ucomisd 0x70(%r14), %xmm0
jne 0x3bdb6
jp 0x3bdb6
movsd 0x78(%r14), %xmm0
cmpeqsd 0x78(%rbx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6c044
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6c8e0
movq %r15, %rdi
callq 0x6c13a
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 0x67086
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdi, %r14
callq 0x3c376
movups 0x60(%rbx), %xmm0
movups %xmm0, 0x60(%r14)
movups 0x70(%rbx), %xmm0
movups %xmm0, 0x70(%r14)
movsd 0x80(%rbx), %xmm0
movsd %xmm0, 0x80(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3c0fe
movl $0x1701, %edi           # imm = 0x1701
callq 0x21cc0
callq 0x21c50
leaq 0x8ccf3(%rip), %rax     # 0xc8df8
movsd 0x8aaeb(%rip), %xmm0    # 0xc6bf8
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 0x21cc0
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x66f88
movq %r14, %rdi
callq 0x40074
addq $0x98, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6c99a
leaq 0x80(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movsd (%rsp), %xmm0
callq 0x6c72a
leaq 0xb0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x6bb3b
leaq 0x18(%rbx), %rsi
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movsd (%rsp), %xmm0
callq 0x6c72a
movsd 0x60(%rbx), %xmm0
callq 0x214c0
leaq 0x80(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x6c72a
leaq 0x30(%rbx), %rsi
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movsd (%rsp), %xmm0
callq 0x6c72a
movsd 0x68(%rbx), %xmm0
callq 0x214c0
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x6c72a
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6bb3b
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x6bb3b
leaq 0x68(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6bb3b
leaq 0x8(%rsp), %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x6bfc5
leaq 0x50(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6bfc5
leaq 0x68(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x6bb3b
leaq 0x98(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6bfc5
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x6bfc5
callq 0x2736a
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 0x21c60
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Camera.cpp
// Function: gaps::R3CompareCameras(void const*, void const*)
int R3CompareCameras(const void *data1, const void *data2)
{
  // Sort the cameras according to highest value first
  R3Camera *camera1 = *((R3Camera **) data1);
  R3Camera *camera2 = *((R3Camera **) data2);
  if (camera1->Value() > camera2->Value()) return -1;
  else if (camera1->Value() < camera2->Value()) return 1;
  return 0;
}

// Assembly:
movq (%rdi), %rax
movq (%rsi), %rcx
movsd 0x80(%rax), %xmm0
movsd 0x80(%rcx), %xmm1
xorl %ecx, %ecx
ucomisd %xmm0, %xmm1
seta %cl
ucomisd %xmm1, %xmm0
pushq $-0x1
popq %rax
cmovbel %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3c9dc
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0x28(%rdi), %xmm2
leaq 0xf27d2(%rip), %rax     # 0x12f0f8
movsd (%rax), %xmm3
movapd 0x88bfe(%rip), %xmm4    # 0xc5530
xorpd %xmm3, %xmm4
ucomisd %xmm4, %xmm2
jb 0x3c946
ucomisd %xmm2, %xmm3
jae 0x3c9d7
ucomisd %xmm4, %xmm1
jb 0x3c95f
ucomisd %xmm1, %xmm3
jb 0x3c95f
leaq 0xf27af(%rip), %rax     # 0x12f108
movsd (%rax), %xmm0
jmp 0x3c9d7
movsd 0xa8(%rbx), %xmm3
movsd 0x98(%rbx), %xmm0
movsd 0xa0(%rbx), %xmm4
divsd %xmm1, %xmm2
subsd %xmm2, %xmm0
movsd 0x88b29(%rip), %xmm1    # 0xc54b0
mulsd %xmm3, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm4, %xmm0
mulsd %xmm4, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x3c9ab
sqrtsd %xmm0, %xmm0
jmp 0x3c9c6
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_O2/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 0x3d335
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 0x220c0
movl %ebx, %edi
movl $0x1202, %esi           # imm = 0x1202
movq %r14, %rdx
callq 0x220c0
movupd 0x58(%r15), %xmm0
cvtpd2ps %xmm0, %xmm0
movlpd %xmm0, (%r14)
cvtsd2ss 0x68(%r15), %xmm0
movss %xmm0, 0x8(%r14)
movl %ebp, 0xc(%r14)
movl %ebx, %edi
movl $0x1203, %esi           # imm = 0x1203
movq %r14, %rdx
callq 0x220c0
movl $0x42b40000, (%r14)     # imm = 0x42B40000
movss 0x8995f(%rip), %xmm0    # 0xc6c30
movl %ebx, %edi
movl $0x1206, %esi           # imm = 0x1206
callq 0x211c0
movl %ebx, %edi
callq 0x21820
movupd 0x98(%r15), %xmm0
cvtpd2ps %xmm0, %xmm0
movlpd %xmm0, (%r14)
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_O2/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 0x3d948
movsd %xmm0, 0x8(%rsp)
leaq 0x50(%rbx), %rdx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6ba51
movq %r15, %rdi
callq 0x6c336
leaq 0x80(%rbx), %rsi
movq %r15, %rdi
callq 0x6c2ae
movsd %xmm0, 0x10(%rsp)
movsd 0xa0(%rbx), %xmm0
callq 0x221f0
movsd 0x10(%rsp), %xmm2
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm2, %xmm1
ja 0x3d633
movsd 0x98(%rbx), %xmm1
movapd %xmm2, %xmm0
callq 0x220b0
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_O2/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 0x3d9ab
pushq %rbx
movq %rdi, %rbx
leaq 0x50(%rdi), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x48146
movsd 0x70(%rbx), %xmm1
mulsd %xmm0, %xmm1
addsd 0x68(%rbx), %xmm1
mulsd %xmm0, %xmm0
mulsd 0x78(%rbx), %xmm0
addsd %xmm1, %xmm0
leaq 0xf1775(%rip), %rax     # 0x12f0f8
movsd (%rax), %xmm2
movapd 0x87ba1(%rip), %xmm1    # 0xc5530
xorpd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
movsd 0x28(%rbx), %xmm1
popq %rbx
jb 0x3d9a5
ucomisd %xmm0, %xmm2
jae 0x3d9af
divsd %xmm0, %xmm1
jmp 0x3d9af
xorpd %xmm1, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3da04
movsd 0x28(%rdi), %xmm2
leaq 0xf1710(%rip), %rax     # 0x12f0f8
movsd (%rax), %xmm3
movapd 0x87b3c(%rip), %xmm4    # 0xc5530
xorpd %xmm3, %xmm4
ucomisd %xmm4, %xmm2
jb 0x3da05
ucomisd %xmm2, %xmm3
jb 0x3da05
retq
ucomisd %xmm4, %xmm1
jb 0x3da1d
ucomisd %xmm1, %xmm3
jb 0x3da1d
leaq 0xf16f0(%rip), %rax     # 0x12f108
movsd (%rax), %xmm0
retq
movsd 0x78(%rdi), %xmm3
movsd 0x68(%rdi), %xmm0
movsd 0x70(%rdi), %xmm4
divsd %xmm1, %xmm2
subsd %xmm2, %xmm0
movsd 0x87a74(%rip), %xmm1    # 0xc54b0
mulsd %xmm3, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm4, %xmm0
mulsd %xmm4, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x3da60
sqrtsd %xmm0, %xmm0
jmp 0x3da85
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_O2/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 0x3db5c
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 0x6c2ae
leaq 0xf15db(%rip), %rax     # 0x12f0f8
movsd (%rax), %xmm1
ucomisd %xmm0, %xmm1
jae 0x3db5c
addq $0x30, %r14
addq $0x38, %r15
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movapd %xmm1, %xmm0
callq 0x3d3cb
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x3d360
jmp 0x3db6b
leaq 0xf9a9d(%rip), %rsi     # 0x137600
movq %rbx, %rdi
callq 0x7c020
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop