LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Halfspace const&, gaps::R3Circle const&)
RNBoolean R3Contains(const R3Halfspace& halfspace, const R3Circle& circle)
{
    // Return whether halfspace contains circle
    RNScalar d = R3SignedDistance(halfspace.Plane(), circle.Center());
    if (RNIsNegative(d)) return FALSE;
    else if (RNIsGreater(d, circle.Radius())) return TRUE;
    else {
        RNScalar cos_theta = halfspace.Plane().Normal().Dot(circle.Normal());
	if (cos_theta < 0.0) cos_theta = halfspace.Plane().Normal().Dot(-circle.Normal());
	return (RNIsGreaterOrEqual(d, cos_theta * circle.Radius()));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rsi
callq 0x4a10f
leaq 0x9d578(%rip), %r13     # 0xe5b98
movsd (%r13), %xmm3
movapd 0x599f2(%rip), %xmm1    # 0xa2020
xorpd %xmm3, %xmm1
xorl %eax, %eax
ucomisd %xmm0, %xmm1
ja 0x486b0
movsd 0x20(%rbx), %xmm1
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
movl $0x1, %eax
ucomisd %xmm3, %xmm2
ja 0x486b0
movsd %xmm0, (%rsp)
leaq 0x28(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3d756
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x4868b
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3e154
movq %r14, %rdi
movq %r12, %rsi
callq 0x3d756
mulsd 0x20(%rbx), %xmm0
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd (%r13), %xmm0
xorpd 0x59979(%rip), %xmm0    # 0xa2020
xorl %eax, %eax
ucomisd %xmm0, %xmm1
setae %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Halfspace const&, gaps::R3Halfspace const&)
RNBoolean R3Contains(const R3Halfspace& halfspace1, const R3Halfspace& halfspace2)
{
    // Return whether halfspace1 contains halfspace2
    RNScalar dot = halfspace1.Plane().Normal().Dot(halfspace2.Plane().Normal());
    if (RNIsEqual(dot, 1.0)) {
	// Halfspace and plane are parallel ???
	return RNIsLessOrEqual(halfspace1.Plane().D(), halfspace2.Plane().D());
    }
    else {
	// Halfspace and plane are not parallel
	return FALSE;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3d756
leaq 0x9d4c4(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
addsd 0x59968(%rip), %xmm0    # 0xa2048
movapd 0x59938(%rip), %xmm2    # 0xa2020
xorpd %xmm1, %xmm2
xorl %eax, %eax
ucomisd %xmm2, %xmm0
jb 0x4870e
ucomisd %xmm0, %xmm1
jb 0x4870e
movsd 0x18(%r14), %xmm0
subsd 0x18(%rbx), %xmm0
xorl %eax, %eax
ucomisd %xmm0, %xmm1
setae %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3OrientedBox const&, gaps::R3Point const&)
RNBoolean R3Contains(const R3OrientedBox& box, const R3Point& point)
{
    // Check if box is empty
    if (box.IsEmpty()) return FALSE;

    // Return whether each halfspace contains point
    for (int dir = 0; dir < 2; dir++) {
      for (int dim = 0; dim < 3; dim++) {
        R3Halfspace halfspace(-box.Plane(dir, dim), 0);
        if (!R3Contains(halfspace, point)) {
          return FALSE;
        }
      }
    }

    // Passed all tests
    return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, 0x10(%rsp)
movsd 0x70(%rdi), %xmm0
movsd 0x78(%rdi), %xmm1
movq %rdi, 0x8(%rsp)
minsd 0x68(%rdi), %xmm0
minsd %xmm0, %xmm1
xorl %eax, %eax
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x48eac
movl $0x0, 0x4(%rsp)
leaq 0x18(%rsp), %r15
leaq 0x58(%rsp), %r12
leaq 0x38(%rsp), %r13
xorl %ebp, %ebp
xorl %r14d, %r14d
xorl %ebx, %ebx
movq %r15, %rdi
movq 0x8(%rsp), %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x56b92
movq %r12, %rdi
movq %r15, %rsi
callq 0x3e154
movsd 0x30(%rsp), %xmm0
movapd 0x591eb(%rip), %xmm1    # 0xa2020
xorpd %xmm1, %xmm0
movq %r13, %rdi
movq %r12, %rsi
callq 0x3b582
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x5796e
movq %r12, %rdi
movq 0x10(%rsp), %rsi
callq 0x4a10f
leaq 0x9cd33(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
xorpd 0x591af(%rip), %xmm1    # 0xa2020
ucomisd %xmm1, %xmm0
jb 0x48e8a
cmpl $0x2, %ebx
leal 0x1(%rbx), %eax
setae %r14b
movl %eax, %ebx
cmpl $0x3, %eax
jne 0x48e0b
jmp 0x48e90
testb $0x1, %r14b
je 0x48ea4
leal 0x1(%rbp), %eax
testl %ebp, %ebp
setne %cl
movl %ecx, 0x4(%rsp)
movl %eax, %ebp
je 0x48e06
movzbl 0x4(%rsp), %eax
andl $0x1, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Sphere const&, gaps::R3Point const&)
RNBoolean R3Contains(const R3Sphere& sphere, const R3Point& point)
{
    // Return whether sphere contains point
    RNScalar radius_squared = sphere.Radius() * sphere.Radius();
    R3Vector v = sphere.Center() - point;
    RNScalar distance_squared = v.X() * v.X() + v.Y() * v.Y() + v.Z() * v.Z();
    return RNIsLessOrEqual(distance_squared, radius_squared);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rdx
movsd 0x20(%rdi), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, (%rsp)
leaq 0x8(%rdi), %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x3cc88
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd 0x10(%rbx), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
subsd (%rsp), %xmm1
leaq 0x9c6a8(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm0
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setae %al
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Sphere const&, gaps::R3Span const&)
RNBoolean R3Contains(const R3Sphere& sphere, const R3Span& span)
{
    // Return whether sphere contains span
    if (!R3Contains(sphere, span.Start())) return FALSE;
    if (!R3Contains(sphere, span.End())) return FALSE;
    return TRUE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movsd 0x20(%rdi), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x8(%rdi), %r14
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3cc88
movsd (%r12), %xmm0
movsd 0x8(%r12), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd 0x10(%r12), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
subsd 0x8(%rsp), %xmm1
leaq 0x9c5c5(%rip), %r12     # 0xe5b98
movsd (%r12), %xmm0
xorl %eax, %eax
ucomisd %xmm1, %xmm0
jb 0x49642
addq $0x30, %rbx
movsd 0x20(%r15), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3cc88
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd 0x10(%r15), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
subsd 0x8(%rsp), %xmm1
movsd (%r12), %xmm0
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setae %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Cylinder const&, gaps::R3Point const&)
RNBoolean R3Contains(const R3Cylinder& cylinder, const R3Point& point) 
{
    // Get cylinder axis
    const R3Span& axis = cylinder.Axis();
  
    // Check if outside top or bottom
    RNScalar t = axis.T(point);
    if (RNIsNegative(t) || RNIsGreater(t, axis.Length())) 
        return FALSE;

    // Check if inside radius
    RNLength d = R3Distance(point, axis.Point(t));
    return (RNIsLessOrEqual(d, cylinder.Radius()));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
movq %r15, %rdi
callq 0x3c150
leaq 0x9c29e(%rip), %r13     # 0xe5b98
movsd (%r13), %xmm1
movapd 0x58718(%rip), %xmm2    # 0xa2020
xorpd %xmm1, %xmm2
xorl %eax, %eax
ucomisd %xmm0, %xmm2
ja 0x49952
movapd %xmm0, %xmm2
subsd 0x50(%rbx), %xmm2
ucomisd %xmm1, %xmm2
ja 0x49952
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3c03a
movq %r14, %rdi
movq %r12, %rsi
callq 0x49efc
movsd (%r13), %xmm1
subsd 0x78(%rbx), %xmm0
xorl %eax, %eax
ucomisd %xmm0, %xmm1
setae %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Cone const&, gaps::R3Point const&)
RNBoolean R3Contains(const R3Cone& cone, const R3Point& point) 
{
    // Get cone axis
    const R3Span& axis = cone.Axis();
  
    // Check if outside top or bottom
    RNScalar t = axis.T(point);
    if (RNIsNegative(t) || RNIsGreater(t, axis.Length())) 
        return FALSE;

    // Check if inside radius
    RNLength r = (1.0 - t / axis.Length()) * cone.Radius();
    RNLength d = R3Distance(axis.Point(t), point);
    return RNIsGreaterOrEqual(r, d);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x3c150
leaq 0x9c214(%rip), %r12     # 0xe5b98
movsd (%r12), %xmm1
movapd 0x5868e(%rip), %xmm2    # 0xa2020
xorpd %xmm1, %xmm2
xorl %eax, %eax
ucomisd %xmm0, %xmm2
ja 0x49a0e
movsd 0x50(%r15), %xmm2
movapd %xmm0, %xmm3
subsd %xmm2, %xmm3
ucomisd %xmm1, %xmm3
ja 0x49a0e
movapd %xmm0, %xmm1
divsd %xmm2, %xmm1
movsd 0x58676(%rip), %xmm2    # 0xa2038
subsd %xmm1, %xmm2
mulsd 0x78(%r15), %xmm2
movsd %xmm2, 0x8(%rsp)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3c03a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x49efc
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd (%r12), %xmm0
xorpd 0x5861b(%rip), %xmm0    # 0xa2020
xorl %eax, %eax
ucomisd %xmm0, %xmm1
setae %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Frustum const&, gaps::R3Point const&)
RNBoolean R3Contains(const R3Frustum& frustum, const R3Point& point)
{
  // Check each halfspace
  for (int dir = 0; dir < 2; dir++) {
    for (int dim = 0; dim < 3; dim++) {
      if (!R3Contains(frustum.Halfspace(dir, dim), point)) {
        return FALSE;
      }
    }
  }

  // Passed all tests
  return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x68(%rdi), %rax
movq %rax, 0x10(%rsp)
addq $0x88, %r14
xorl %ebp, %ebp
leaq 0x9c151(%rip), %r13     # 0xe5b98
movq $0x0, 0x8(%rsp)
leaq (,%rbp,2), %rdi
addq %rbp, %rdi
shlq $0x5, %rdi
addq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x4a10f
movsd (%r13), %xmm1
xorpd 0x585a6(%rip), %xmm1    # 0xa2020
ucomisd %xmm1, %xmm0
jb 0x49ad8
movq $-0x1, %r12
movq %r14, %r15
cmpq $0x1, %r12
je 0x49abc
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4a10f
movsd (%r13), %xmm1
xorpd 0x58577(%rip), %xmm1    # 0xa2020
incq %r12
addq $0x20, %r15
ucomisd %xmm1, %xmm0
jae 0x49a8a
cmpq $0x2, %r12
jb 0x49ad8
leaq 0x1(%rbp), %rax
addq $0x60, %r14
testq %rbp, %rbp
setne %cl
movq %rcx, 0x8(%rsp)
movq %rax, %rbp
je 0x49a50
movzbl 0x8(%rsp), %eax
andl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Frustum const&, gaps::R3Span const&)
RNBoolean R3Contains(const R3Frustum& frustum, const R3Span& span) 
{
  // Check each halfspace
  for (int dir = 0; dir < 2; dir++) {
    for (int dim = 0; dim < 3; dim++) {
      if (!R3Contains(frustum.Halfspace(dir, dim), span)) {
        return FALSE;
      }
    }
  }

  // Passed all tests
  return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x68(%rdi), %rax
movq %rax, (%rsp)
addq $0x88, %r14
xorl %r13d, %r13d
xorl %ebp, %ebp
leaq (,%r13,2), %rdi
addq %r13, %rdi
shlq $0x5, %rdi
addq (%rsp), %rdi
movq %rbx, %rsi
callq 0x4842f
testl %eax, %eax
je 0x49b79
movq $-0x1, %r12
movq %r14, %r15
cmpq $0x1, %r12
je 0x49b65
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4842f
incq %r12
addq $0x20, %r15
testl %eax, %eax
jne 0x49b43
cmpq $0x2, %r12
jb 0x49b79
leaq 0x1(%r13), %rax
addq $0x60, %r14
testq %r13, %r13
setne %bpl
movq %rax, %r13
je 0x49b1a
movzbl %bpl, %eax
andl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Frustum const&, gaps::R3Box const&)
RNBoolean R3Contains(const R3Frustum& frustum, const R3Box& box) 
{
  // Check each halfspace
  for (int dir = 0; dir < 2; dir++) {
    for (int dim = 0; dim < 3; dim++) {
      if (!R3Contains(frustum.Halfspace(dir, dim), box)) {
        return FALSE;
      }
    }
  }

  // Passed all tests
  return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x68(%rdi), %rax
movq %rax, (%rsp)
addq $0x88, %r14
xorl %r13d, %r13d
xorl %ebp, %ebp
leaq (,%r13,2), %rdi
addq %r13, %rdi
shlq $0x5, %rdi
addq (%rsp), %rdi
movq %rbx, %rsi
callq 0x48579
testl %eax, %eax
je 0x49c19
movq $-0x1, %r12
movq %r14, %r15
cmpq $0x1, %r12
je 0x49c05
movq %r15, %rdi
movq %rbx, %rsi
callq 0x48579
incq %r12
addq $0x20, %r15
testl %eax, %eax
jne 0x49be3
cmpq $0x2, %r12
jb 0x49c19
leaq 0x1(%r13), %rax
addq $0x60, %r14
testq %r13, %r13
setne %bpl
movq %rax, %r13
je 0x49bba
movzbl %bpl, %eax
andl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Frustum const&, gaps::R3OrientedBox const&)
RNBoolean R3Contains(const R3Frustum& frustum, const R3OrientedBox& box) 
{
  // Check each halfspace
  for (int dir = 0; dir < 2; dir++) {
    for (int dim = 0; dim < 3; dim++) {
      if (!R3Contains(frustum.Halfspace(dir, dim), box)) {
        return FALSE;
      }
    }
  }

  // Passed all tests
  return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x68(%rdi), %rax
movq %rax, (%rsp)
addq $0x88, %r14
xorl %r13d, %r13d
xorl %ebp, %ebp
leaq (,%r13,2), %rdi
addq %r13, %rdi
shlq $0x5, %rdi
addq (%rsp), %rdi
movq %rbx, %rsi
callq 0x48716
testl %eax, %eax
je 0x49cb3
movq $-0x1, %r12
movq %r14, %r15
cmpq $0x1, %r12
je 0x49c9f
movq %r15, %rdi
movq %rbx, %rsi
callq 0x48716
incq %r12
addq $0x20, %r15
testl %eax, %eax
jne 0x49c7d
cmpq $0x2, %r12
jb 0x49cb3
leaq 0x1(%r13), %rax
addq $0x60, %r14
testq %r13, %r13
setne %bpl
movq %rax, %r13
je 0x49c54
movzbl %bpl, %eax
andl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Frustum const&, gaps::R3Sphere const&)
RNBoolean R3Contains(const R3Frustum& frustum, const R3Sphere& sphere) 
{
  // Check each halfspace
  for (int dir = 0; dir < 2; dir++) {
    for (int dim = 0; dim < 3; dim++) {
      if (!R3Contains(frustum.Halfspace(dir, dim), sphere)) {
        return FALSE;
      }
    }
  }

  // Passed all tests
  return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x68(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x8(%rsi), %r15
addq $0x88, %r14
movq $0x0, (%rsp)
leaq 0x9be98(%rip), %rbp     # 0xe5b98
movq $0x0, 0x8(%rsp)
movq (%rsp), %rax
leaq (%rax,%rax,2), %rdi
shlq $0x5, %rdi
addq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x4a10f
subsd 0x20(%rbx), %xmm0
movsd (%rbp), %xmm1
xorpd 0x582ec(%rip), %xmm1    # 0xa2020
ucomisd %xmm1, %xmm0
jb 0x49d9b
movq $-0x1, %r13
movq %r14, %r12
cmpq $0x1, %r13
je 0x49d7a
movq %r12, %rdi
movq %r15, %rsi
callq 0x4a10f
subsd 0x20(%rbx), %xmm0
movsd (%rbp), %xmm1
xorpd 0x582b9(%rip), %xmm1    # 0xa2020
incq %r13
addq $0x20, %r12
ucomisd %xmm1, %xmm0
jae 0x49d44
cmpq $0x2, %r13
jb 0x49d9b
movq (%rsp), %rcx
leaq 0x1(%rcx), %rax
addq $0x60, %r14
testq %rcx, %rcx
setne %cl
movq %rcx, 0x8(%rsp)
movq %rax, (%rsp)
je 0x49d09
movzbl 0x8(%rsp), %eax
andl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Frustum const&, gaps::R3Shape const&)
RNBoolean R3Contains(const R3Frustum& frustum, const R3Shape& shape) 
{
  // Check each halfspace
  for (int dir = 0; dir < 2; dir++) {
    for (int dim = 0; dim < 3; dim++) {
      if (!R3Contains(frustum.Halfspace(dir, dim), shape)) {
        return FALSE;
      }
    }
  }

  // Passed all tests
  return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x68(%rdi), %rax
movq %rax, (%rsp)
addq $0x88, %r14
xorl %r13d, %r13d
xorl %ebp, %ebp
leaq (,%r13,2), %rsi
addq %r13, %rsi
shlq $0x5, %rsi
addq (%rsp), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x1a0(%rax)
testl %eax, %eax
je 0x49e3e
movq $-0x1, %r12
movq %r14, %r15
cmpq $0x1, %r12
je 0x49e2a
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x1a0(%rax)
incq %r12
addq $0x20, %r15
testl %eax, %eax
jne 0x49e04
cmpq $0x2, %r12
jb 0x49e3e
leaq 0x1(%r13), %rax
addq $0x60, %r14
testq %r13, %r13
setne %bpl
movq %rax, %r13
je 0x49dd7
movzbl %bpl, %eax
andl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3Distance(gaps::R3Point const&, gaps::R3Line const&)
RNLength R3Distance(const R3Point& point, const R3Line& line)
{
    // Return distance from point to line (Riddle p. 904)
    R3Vector v = line.Vector();
    v.Cross(line.Point() - point);
    return v.Length();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x3d4ce
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3cc88
movq %r15, %rdi
movq %r12, %rsi
callq 0x3d86a
movq %r15, %rdi
callq 0x3d5c4
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3Distance(gaps::R3Point const&, gaps::R3Ray const&)
RNLength R3Distance(const R3Point& point, const R3Ray& ray)
{
    // Check if start point is closest
    R3Vector v = point - ray.Start();
    RNScalar dir = v.Dot(ray.Vector());
    if (RNIsNegative(dir)) return v.Length();

    // Return distance from point to ray line
    return R3Distance(point, ray.Line());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3cc88
leaq 0x18(%rbx), %rsi
movq %r15, %rdi
callq 0x3d756
leaq 0x9bbed(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
xorpd 0x58069(%rip), %xmm1    # 0xa2020
ucomisd %xmm0, %xmm1
ja 0x49fca
movq %r14, %rdi
movq %rbx, %rsi
callq 0x49f22
jmp 0x49fd4
leaq 0x8(%rsp), %rdi
callq 0x3d5c4
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3Distance(gaps::R3Point const&, gaps::R3Span const&)
RNLength R3Distance(const R3Point& point, const R3Span& span)
{
    // Check if span has zero length
    if (RNIsZero(span.Length())) return R3Distance(point, span.Start());

    // Check if start point is closest
    R3Vector v1 = point - span.Start();
    RNScalar dir1 = v1.Dot(span.Vector());
    if (RNIsNegative(dir1)) return v1.Length();

    // Check if end point is closest
    R3Vector v2 = point - span.End();
    RNScalar dir2 = v2.Dot(span.Vector());
    if (RNIsPositive(dir2)) return v2.Length();

    // Return distance from point to span line
    return R3Distance(point, span.Line());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd 0x48(%rsi), %xmm0
leaq 0x9bb9b(%rip), %r13     # 0xe5b98
movsd (%r13), %xmm1
movapd 0x58015(%rip), %xmm2    # 0xa2020
xorpd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jb 0x4a031
ucomisd %xmm0, %xmm1
jb 0x4a031
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3cc88
movq %r15, %rdi
jmp 0x4a0a3
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3cc88
leaq 0x18(%rbx), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x3d756
movsd (%r13), %xmm1
xorpd 0x57fc1(%rip), %xmm1    # 0xa2020
ucomisd %xmm0, %xmm1
ja 0x4a099
leaq 0x30(%rbx), %rdx
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3cc88
movq %r12, %rdi
movq %r15, %rsi
callq 0x3d756
ucomisd (%r13), %xmm0
ja 0x4a09e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x49f22
jmp 0x4a0a8
movq %rsp, %rdi
jmp 0x4a0a3
leaq 0x18(%rsp), %rdi
callq 0x3d5c4
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3Distance(gaps::R3Point const&, gaps::R3OrientedBox const&)
RNLength R3Distance(const R3Point& point, const R3OrientedBox& box)
{
    // Check if box is empty
    if (box.IsEmpty()) return FLT_MAX;

    // Transform point into std coordinate system
    R3Point transformed_point = point;
    R3Affine cs_to_std_xform(box.CoordSystem().InverseMatrix());
    transformed_point.Transform(cs_to_std_xform);

    // Return distance in std coordinate system
    R3Box axis_aligned_box(-box.Radius(0), -box.Radius(1), -box.Radius(2), box.Radius(0), box.Radius(1), box.Radius(2));
    return R3Distance(transformed_point, axis_aligned_box);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %rbx
movsd 0x70(%rsi), %xmm0
movsd 0x78(%rsi), %xmm1
minsd 0x68(%rsi), %xmm0
minsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x4a3c7
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x3ca36
leaq 0x8(%rbx), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x2aa1e
leaq 0xa8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x2a22e
movq %r14, %rdi
movq %r12, %rsi
callq 0x3d342
movsd 0x68(%rbx), %xmm3
movsd 0x70(%rbx), %xmm4
movapd 0x57cb1(%rip), %xmm2    # 0xa2020
movapd %xmm3, %xmm0
xorpd %xmm2, %xmm0
movapd %xmm4, %xmm1
xorpd %xmm2, %xmm1
movsd 0x78(%rbx), %xmm5
xorpd %xmm5, %xmm2
leaq 0x28(%rsp), %rdi
callq 0x27590
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rbx
movq %rbx, %rsi
callq 0x4a187
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x28348
leaq 0xa8(%rsp), %rdi
callq 0x2a27c
movsd 0x8(%rsp), %xmm0
jmp 0x4a3cf
movsd 0x57c71(%rip), %xmm0    # 0xa2040
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x4a3e0
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x2a27c
movq %rbx, %rdi
callq 0xe7e0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3Distance(gaps::R3Point const&, gaps::R3Cone const&)
RNLength R3Distance(const R3Point& point, const R3Cone& cone)
{
    // Return distance from point to sphere
    RNScalar t = cone.Axis().T(point);
    if (RNIsNegativeOrZero(t)) {
        RNAbort("Not implemented");
        return 0.0;
    }
    else if (RNIsGreater(t, cone.Axis().Length())) {
        return R3Distance(point, cone.Apex());
    }
    else {
        // Get distance between axis and point
        R3Point p = cone.Axis().Point(t);
	RNLength r = (1.0 - t / cone.Axis().Length()) * cone.Radius();
	RNLength d = R3Distance(p, point) - r;
	if (RNIsNegativeOrZero(d)) return 0.0;
	else return d;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsi), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3c150
leaq 0x9b73e(%rip), %r13     # 0xe5b98
movsd (%r13), %xmm2
ucomisd %xmm0, %xmm2
jae 0x4a4ee
movapd %xmm0, %xmm1
subsd 0x50(%r14), %xmm1
ucomisd %xmm2, %xmm1
ja 0x4a502
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movsd %xmm0, 0x8(%rsp)
callq 0x3c03a
movsd 0x8(%rsp), %xmm1
divsd 0x50(%r14), %xmm1
movsd 0x57b90(%rip), %xmm0    # 0xa2038
subsd %xmm1, %xmm0
mulsd 0x78(%r14), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x3cc88
movq %r14, %rdi
callq 0x3d5c4
movapd %xmm0, %xmm1
subsd 0x8(%rsp), %xmm1
movapd %xmm1, %xmm0
cmpnlesd (%r13), %xmm0
andpd %xmm1, %xmm0
jmp 0x4a521
leaq 0x57e2d(%rip), %rdi     # 0xa2322
xorl %eax, %eax
callq 0x72942
xorpd %xmm0, %xmm0
jmp 0x4a521
addq $0x38, %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3cc88
movq %r15, %rdi
callq 0x3d5c4
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3Distance(gaps::R3Line const&, gaps::R3Line const&)
RNLength R3Distance(const R3Line& line1, const R3Line& line2)
{
    // Return distance from line to line (Riddle p. 905)
    R3Vector v = line1.Vector();
    v.Cross(line2.Vector());
    RNLength vlength = v.Length();
    if (vlength == 0.0) return R3Distance(line1.Point(), line2);
    else v /= vlength;
    return fabs(v.Dot(line1.Point() - line2.Point()));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rdi), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3d4ce
leaq 0x18(%rbx), %rsi
movq %r15, %rdi
callq 0x3d86a
movq %r15, %rdi
callq 0x3d5c4
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4a5d3
jp 0x4a5d3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x49f22
jmp 0x4a606
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3e0ec
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3cc88
movq %r15, %rdi
movq %r12, %rsi
callq 0x3d756
andpd 0x57c6a(%rip), %xmm0    # 0xa2270
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3Distance(gaps::R3Line const&, gaps::R3Plane const&)
RNLength R3Distance(const R3Line& line, const R3Plane& plane)
{
    // Return distance from line to plane
    RNScalar d = R3SignedDistance(plane, line);
    if (RNIsPositive(d)) return d;
    else if (RNIsNegative(d)) return -d;
    else return 0.0;
}

// Assembly:
pushq %rax
movq %rdi, %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x4aae9
leaq 0x9b0e3(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm2
ucomisd %xmm2, %xmm0
ja 0x4aadf
xorpd 0x57559(%rip), %xmm2    # 0xa2020
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm2
jbe 0x4aae3
movapd 0x57547(%rip), %xmm1    # 0xa2020
xorpd %xmm0, %xmm1
jmp 0x4aae3
movapd %xmm0, %xmm1
movapd %xmm1, %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3SignedDistance(gaps::R3Plane const&, gaps::R3Line const&)
RNLength R3SignedDistance(const R3Plane& plane, const R3Line& line)
{
    // Return signed distance from plane to line
    if (R3Parallel(plane, line)) {
	// Plane and line are parallel
	return R3SignedDistance(plane, line.Point());
    }
    else {
	// Plane and line are not parallel
	return 0.0;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x4c3d4
testl %eax, %eax
je 0x4ab30
movsd (%r14), %xmm1
movsd 0x8(%r14), %xmm2
mulsd 0x8(%rbx), %xmm2
mulsd (%rbx), %xmm1
movsd 0x10(%r14), %xmm0
mulsd 0x10(%rbx), %xmm0
addsd %xmm2, %xmm1
addsd %xmm1, %xmm0
addsd 0x18(%rbx), %xmm0
jmp 0x4ab34
xorpd %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3Distance(gaps::R3Line const&, gaps::R3Halfspace const&)
RNLength R3Distance(const R3Line& line, const R3Halfspace& halfspace)
{
    // Return distance from line to halfspace
    RNScalar d = R3SignedDistance(halfspace.Plane(), line);
    if (RNIsNegative(d)) return -d;
    else return 0.0;
}

// Assembly:
pushq %rax
movq %rdi, %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x4aae9
leaq 0x9b046(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
movapd 0x574c2(%rip), %xmm2    # 0xa2020
xorpd %xmm2, %xmm1
xorpd %xmm0, %xmm2
cmpnltsd %xmm1, %xmm0
andnpd %xmm2, %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3Distance(gaps::R3Line const&, gaps::R3OrientedBox const&)
RNLength R3Distance(const R3Line& line, const R3OrientedBox& box)
{
    // Check if box is empty
    if (box.IsEmpty()) return FLT_MAX;

    // Transform line into std coordinate system
    R3Line transformed_line = line;
    R3Affine cs_to_std_xform(box.CoordSystem().InverseMatrix());
    transformed_line.Transform(cs_to_std_xform);

    // Return distance in std coordinate system
    R3Box axis_aligned_box(-box.Radius(0), -box.Radius(1), -box.Radius(2), box.Radius(0), box.Radius(1), box.Radius(2));
    return R3Distance(transformed_line, axis_aligned_box);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsi, %rbx
movsd 0x70(%rsi), %xmm0
movsd 0x78(%rsi), %xmm1
minsd 0x68(%rsi), %xmm0
minsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x4ac5b
movq %rdi, %rsi
leaq 0x88(%rsp), %r14
movq %r14, %rdi
callq 0x3c712
leaq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2aa1e
leaq 0xb8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x2a22e
movq %r14, %rdi
movq %r12, %rsi
callq 0x3c920
movsd 0x68(%rbx), %xmm3
movsd 0x70(%rbx), %xmm4
movapd 0x57413(%rip), %xmm2    # 0xa2020
movapd %xmm3, %xmm0
xorpd %xmm2, %xmm0
movapd %xmm4, %xmm1
xorpd %xmm2, %xmm1
movsd 0x78(%rbx), %xmm5
xorpd %xmm5, %xmm2
leaq 0x8(%rsp), %rdi
callq 0x27590
leaq 0x576eb(%rip), %rdi     # 0xa2322
xorl %eax, %eax
callq 0x72942
leaq 0x8(%rsp), %rdi
callq 0x28348
leaq 0xb8(%rsp), %rdi
callq 0x2a27c
xorpd %xmm0, %xmm0
jmp 0x4ac63
movsd 0x573dd(%rip), %xmm0    # 0xa2040
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x28348
jmp 0x4ac86
jmp 0x4ac83
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x2a27c
movq %rbx, %rdi
callq 0xe7e0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3Distance(gaps::R3Ray const&, gaps::R3Plane const&)
RNLength R3Distance(const R3Ray& ray, const R3Plane& plane)
{
    // Return distance from ray to plane
    RNScalar d = R3SignedDistance(plane, ray);
    if (RNIsPositive(d)) return d;
    else if (RNIsNegative(d)) return -d;
    else return 0.0;
}

// Assembly:
pushq %rax
movq %rdi, %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x4afa4
leaq 0x9ac28(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm2
ucomisd %xmm2, %xmm0
ja 0x4af9a
xorpd 0x5709e(%rip), %xmm2    # 0xa2020
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm2
jbe 0x4af9e
movapd 0x5708c(%rip), %xmm1    # 0xa2020
xorpd %xmm0, %xmm1
jmp 0x4af9e
movapd %xmm0, %xmm1
movapd %xmm1, %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3SignedDistance(gaps::R3Plane const&, gaps::R3Ray const&)
RNLength R3SignedDistance(const R3Plane& plane, const R3Ray& ray)
{
    // Return signed distance from plane to ray
    RNLength d1 = R3SignedDistance(plane, ray.Start());
    if (RNIsPositive(d1)) {
	// Start point is above plane
	RNScalar dot = ray.Vector().Dot(plane.Normal());
	if (RNIsNegative(dot)) return 0.0;
	else return d1;
    }
    else if (RNIsNegative(d1)) {
	// Start point is below plane
	RNScalar dot = ray.Vector().Dot(plane.Normal());
	if (RNIsPositive(dot)) return 0.0;
	else return d1;
    }
    else {
	// Start point is on plane
	return 0.0;
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rax
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm1
mulsd 0x8(%rdi), %xmm1
mulsd (%rdi), %xmm0
movsd 0x10(%rsi), %xmm2
mulsd 0x10(%rdi), %xmm2
addsd %xmm1, %xmm0
addsd %xmm0, %xmm2
addsd 0x18(%rdi), %xmm2
leaq 0x9abbc(%rip), %rbx     # 0xe5b98
movsd (%rbx), %xmm1
ucomisd %xmm1, %xmm2
ja 0x4b016
xorpd 0x57032(%rip), %xmm1    # 0xa2020
xorpd %xmm0, %xmm0
ucomisd %xmm2, %xmm1
jbe 0x4b040
addq $0x18, %rsi
movq %rsi, %rdi
movq %rax, %rsi
movapd %xmm2, (%rsp)
callq 0x3d756
movapd %xmm0, %xmm1
movsd (%rbx), %xmm0
jmp 0x4b036
addq $0x18, %rsi
movq %rsi, %rdi
movq %rax, %rsi
movapd %xmm2, (%rsp)
callq 0x3d756
movsd (%rbx), %xmm1
xorpd 0x56fea(%rip), %xmm1    # 0xa2020
cmpnltsd %xmm1, %xmm0
andpd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3Distance(gaps::R3Ray const&, gaps::R3OrientedBox const&)
RNLength R3Distance(const R3Ray& ray, const R3OrientedBox& box)
{
    // Check if box is empty
    if (box.IsEmpty()) return FLT_MAX;

    // Transform ray into std coordinate system
    R3Ray transformed_ray = ray;
    R3Affine cs_to_std_xform(box.CoordSystem().InverseMatrix());
    transformed_ray.Transform(cs_to_std_xform);

    // Return distance in std coordinate system
    R3Box axis_aligned_box(-box.Radius(0), -box.Radius(1), -box.Radius(2), box.Radius(0), box.Radius(1), box.Radius(2));
    return R3Distance(transformed_ray, axis_aligned_box);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsi, %rbx
movsd 0x70(%rsi), %xmm0
movsd 0x78(%rsi), %xmm1
minsd 0x68(%rsi), %xmm0
minsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x4b165
movq %rdi, %rsi
leaq 0x88(%rsp), %r14
movq %r14, %rdi
callq 0x3c60e
leaq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2aa1e
leaq 0xb8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x2a22e
movq %r14, %rdi
movq %r12, %rsi
callq 0x3c6e8
movsd 0x68(%rbx), %xmm3
movsd 0x70(%rbx), %xmm4
movapd 0x56f09(%rip), %xmm2    # 0xa2020
movapd %xmm3, %xmm0
xorpd %xmm2, %xmm0
movapd %xmm4, %xmm1
xorpd %xmm2, %xmm1
movsd 0x78(%rbx), %xmm5
xorpd %xmm5, %xmm2
leaq 0x8(%rsp), %rdi
callq 0x27590
leaq 0x571e1(%rip), %rdi     # 0xa2322
xorl %eax, %eax
callq 0x72942
leaq 0x8(%rsp), %rdi
callq 0x28348
leaq 0xb8(%rsp), %rdi
callq 0x2a27c
xorpd %xmm0, %xmm0
jmp 0x4b16d
movsd 0x56ed3(%rip), %xmm0    # 0xa2040
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x28348
jmp 0x4b190
jmp 0x4b18d
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x2a27c
movq %rbx, %rdi
callq 0xe7e0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3Distance(gaps::R3Span const&, gaps::R3Plane const&)
RNLength R3Distance(const R3Span& span, const R3Plane& plane)
{
    // Return distance from span to plane
    RNScalar d = R3SignedDistance(plane, span);
    if (RNIsPositive(d)) return d;
    else if (RNIsNegative(d)) return -d;
    else return 0.0;
}

// Assembly:
pushq %rax
movq %rdi, %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x4b5ee
leaq 0x9a5de(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm2
ucomisd %xmm2, %xmm0
ja 0x4b5e4
xorpd 0x56a54(%rip), %xmm2    # 0xa2020
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm2
jbe 0x4b5e8
movapd 0x56a42(%rip), %xmm1    # 0xa2020
xorpd %xmm0, %xmm1
jmp 0x4b5e8
movapd %xmm0, %xmm1
movapd %xmm1, %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3Distance(gaps::R3Span const&, gaps::R3Halfspace const&)
RNLength R3Distance(const R3Span& span, const R3Halfspace& halfspace)
{
    // Return distance from span to halfspace
    RNScalar d = R3SignedDistance(halfspace.Plane(), span);
    if (RNIsNegative(d)) return -d;
    else return 0.0;
}

// Assembly:
pushq %rax
movq %rdi, %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x4b5ee
leaq 0x9a4de(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
movapd 0x5695a(%rip), %xmm2    # 0xa2020
xorpd %xmm2, %xmm1
xorpd %xmm0, %xmm2
cmpnltsd %xmm1, %xmm0
andnpd %xmm2, %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3Distance(gaps::R3Span const&, gaps::R3OrientedBox const&)
RNLength R3Distance(const R3Span& span, const R3OrientedBox& box)
{
    // Check if box is empty
    if (box.IsEmpty()) return FLT_MAX;

    // Transform span into std coordinate system
    R3Span transformed_span = span;
    R3Affine cs_to_std_xform(box.CoordSystem().InverseMatrix());
    transformed_span.Transform(cs_to_std_xform);

    // Return distance in std coordinate system
    R3Box axis_aligned_box(-box.Radius(0), -box.Radius(1), -box.Radius(2), box.Radius(0), box.Radius(1), box.Radius(2));
    return R3Distance(transformed_span, axis_aligned_box);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rsi, %rbx
movsd 0x70(%rsi), %xmm0
movsd 0x78(%rsi), %xmm1
minsd 0x68(%rsi), %xmm0
minsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x4b7c3
movq %rdi, %rsi
leaq 0x88(%rsp), %r14
movq %r14, %rdi
callq 0x3bdea
leaq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2aa1e
leaq 0xd8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x2a22e
movq %r14, %rdi
movq %r12, %rsi
callq 0x3c2a0
movsd 0x68(%rbx), %xmm3
movsd 0x70(%rbx), %xmm4
movapd 0x568ab(%rip), %xmm2    # 0xa2020
movapd %xmm3, %xmm0
xorpd %xmm2, %xmm0
movapd %xmm4, %xmm1
xorpd %xmm2, %xmm1
movsd 0x78(%rbx), %xmm5
xorpd %xmm5, %xmm2
leaq 0x8(%rsp), %rdi
callq 0x27590
leaq 0x56b83(%rip), %rdi     # 0xa2322
xorl %eax, %eax
callq 0x72942
leaq 0x8(%rsp), %rdi
callq 0x28348
leaq 0xd8(%rsp), %rdi
callq 0x2a27c
xorpd %xmm0, %xmm0
jmp 0x4b7cb
movsd 0x56875(%rip), %xmm0    # 0xa2040
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x28348
jmp 0x4b7ee
jmp 0x4b7eb
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
callq 0x2a27c
movq %rbx, %rdi
callq 0xe7e0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3Distance(gaps::R3Plane const&, gaps::R3Plane const&)
RNLength R3Distance(const R3Plane& plane1, const R3Plane& plane2)
{
    // Return distance from plane to plane
    RNScalar d = R3SignedDistance(plane1, plane2);
    if (RNIsPositive(d)) return d;
    else if (RNIsNegative(d)) return -d;
    else return 0.0;
}

// Assembly:
pushq %rax
callq 0x4b878
leaq 0x9a354(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm2
ucomisd %xmm2, %xmm0
ja 0x4b86e
xorpd 0x567ca(%rip), %xmm2    # 0xa2020
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm2
jbe 0x4b872
movapd 0x567b8(%rip), %xmm1    # 0xa2020
xorpd %xmm0, %xmm1
jmp 0x4b872
movapd %xmm0, %xmm1
movapd %xmm1, %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3SignedDistance(gaps::R3Plane const&, gaps::R3Plane const&)
RNLength R3SignedDistance(const R3Plane& plane1, const R3Plane& plane2)
{
    // Return signed distance from plane to plane
    RNScalar dot = plane1.Normal().Dot(plane2.Normal());
    if (RNIsEqual(dot, 1.0)) return (plane1.D() - plane2.D());
    else if (RNIsEqual(dot, -1.0)) return (plane1.D() + plane2.D());
    else return 0.0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3d756
leaq 0x9a30a(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm2
movsd 0x567ae(%rip), %xmm3    # 0xa2048
addsd %xmm0, %xmm3
movapd 0x5677a(%rip), %xmm1    # 0xa2020
xorpd %xmm2, %xmm1
ucomisd %xmm1, %xmm3
jb 0x4b8c3
ucomisd %xmm3, %xmm2
jb 0x4b8c3
movsd 0x18(%r14), %xmm1
subsd 0x18(%rbx), %xmm1
jmp 0x4b8e6
addsd 0x5676d(%rip), %xmm0    # 0xa2038
ucomisd %xmm1, %xmm0
xorpd %xmm1, %xmm1
jb 0x4b8e6
ucomisd %xmm0, %xmm2
jb 0x4b8e6
movsd 0x18(%r14), %xmm1
addsd 0x18(%rbx), %xmm1
movapd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3Distance(gaps::R3Plane const&, gaps::R3Halfspace const&)
RNLength R3Distance(const R3Plane& plane, const R3Halfspace& halfspace)
{
    // Return distance from plane to halfspace
    RNScalar d = R3SignedDistance(halfspace.Plane(), plane);
    if (RNIsNegative(d)) return -d;
    else return 0.0;
}

// Assembly:
pushq %rax
movq %rdi, %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x4b878
leaq 0x9a290(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
movapd 0x5670c(%rip), %xmm2    # 0xa2020
xorpd %xmm2, %xmm1
xorpd %xmm0, %xmm2
cmpnltsd %xmm1, %xmm0
andnpd %xmm2, %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3Distance(gaps::R3Plane const&, gaps::R3Box const&)
RNLength R3Distance(const R3Plane& plane, const R3Box& box)
{
    // Return distance from plane to box
    RNScalar d = R3SignedDistance(plane, box);
    if (RNIsPositive(d)) return d;
    else if (RNIsNegative(d)) return -d;
    else return 0.0;
}

// Assembly:
pushq %rax
callq 0x4b968
leaq 0x9a264(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm2
ucomisd %xmm2, %xmm0
ja 0x4b95e
xorpd 0x566da(%rip), %xmm2    # 0xa2020
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm2
jbe 0x4b962
movapd 0x566c8(%rip), %xmm1    # 0xa2020
xorpd %xmm0, %xmm1
jmp 0x4b962
movapd %xmm0, %xmm1
movapd %xmm1, %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3Distance(gaps::R3Plane const&, gaps::R3OrientedBox const&)
RNLength R3Distance(const R3Plane& plane, const R3OrientedBox& box)
{
    // Return distance from plane to box
    RNScalar d = R3SignedDistance(plane, box);
    if (RNIsPositive(d)) return d;
    else if (RNIsNegative(d)) return -d;
    else return 0.0;
}

// Assembly:
pushq %rax
callq 0x4bac0
leaq 0x9a10c(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm2
ucomisd %xmm2, %xmm0
ja 0x4bab6
xorpd 0x56582(%rip), %xmm2    # 0xa2020
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm2
jbe 0x4baba
movapd 0x56570(%rip), %xmm1    # 0xa2020
xorpd %xmm0, %xmm1
jmp 0x4baba
movapd %xmm0, %xmm1
movapd %xmm1, %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3SignedDistance(gaps::R3Plane const&, gaps::R3OrientedBox const&)
RNLength R3SignedDistance(const R3Plane& plane, const R3OrientedBox& box)
{
    // Check if box is empty
    if (box.IsEmpty()) return FLT_MAX;

    // Transform plane into std coordinate system
    R3Plane transformed_plane = plane;
    R3Affine cs_to_std_xform(box.CoordSystem().InverseMatrix());
    transformed_plane.Transform(cs_to_std_xform);

    // Return distance in std coordinate system
    R3Box axis_aligned_box(-box.Radius(0), -box.Radius(1), -box.Radius(2), box.Radius(0), box.Radius(1), box.Radius(2));
    return R3SignedDistance(transformed_plane, axis_aligned_box);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %rbx
movsd 0x70(%rsi), %xmm0
movsd 0x78(%rsi), %xmm1
minsd 0x68(%rsi), %xmm0
minsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x4bb9a
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3b51a
leaq 0x8(%rbx), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x2aa1e
leaq 0xa8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x2a22e
movq %r14, %rdi
movq %r12, %rsi
callq 0x3bc30
movsd 0x68(%rbx), %xmm3
movsd 0x70(%rbx), %xmm4
movapd 0x564db(%rip), %xmm2    # 0xa2020
movapd %xmm3, %xmm0
xorpd %xmm2, %xmm0
movapd %xmm4, %xmm1
xorpd %xmm2, %xmm1
movsd 0x78(%rbx), %xmm5
xorpd %xmm5, %xmm2
leaq 0x28(%rsp), %rdi
callq 0x27590
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x4b968
movsd %xmm0, (%rsp)
leaq 0x28(%rsp), %rdi
callq 0x28348
leaq 0xa8(%rsp), %rdi
callq 0x2a27c
movsd (%rsp), %xmm0
jmp 0x4bba2
movsd 0x5649e(%rip), %xmm0    # 0xa2040
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x28348
jmp 0x4bbc5
jmp 0x4bbc2
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x2a27c
movq %rbx, %rdi
callq 0xe7e0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3Distance(gaps::R3Plane const&, gaps::R3Sphere const&)
RNLength R3Distance(const R3Plane& plane, const R3Sphere& sphere)
{
    // Return distance from plane to sphere
    RNScalar d = R3SignedDistance(plane, sphere);
    if (RNIsPositive(d)) return d;
    else if (RNIsNegative(d)) return -d;
    else return 0.0;
}

// Assembly:
pushq %rax
callq 0x4bc1b
leaq 0x99fb1(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm2
ucomisd %xmm2, %xmm0
ja 0x4bc11
xorpd 0x56427(%rip), %xmm2    # 0xa2020
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm2
jbe 0x4bc15
movapd 0x56415(%rip), %xmm1    # 0xa2020
xorpd %xmm0, %xmm1
jmp 0x4bc15
movapd %xmm0, %xmm1
movapd %xmm1, %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3SignedDistance(gaps::R3Plane const&, gaps::R3Triangle const&)
RNLength R3SignedDistance(const R3Plane& plane, const R3Triangle& triangle)
{
    // Compute signed distance from plane to triangle
    RNLength max_distance = -FLT_MAX;
    RNLength min_distance = FLT_MAX;
    for (int i = 0; i < 3; i++) {
        RNLength distance = R3SignedDistance(plane, triangle.Vertex(i)->Position());
	if (distance < min_distance) min_distance = distance;
	if (distance > max_distance) max_distance = distance;
	if ((min_distance < 0.0) && (max_distance > 0.0)) return 0.0;
    }
    
    // Return signed distance
    if (min_distance > 0.0) return min_distance;
    else if (max_distance < 0.0) return max_distance;
    else return 0.0;
}

// Assembly:
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm2
movsd 0x10(%rdi), %xmm3
movsd 0x18(%rdi), %xmm4
movsd 0x5701f(%rip), %xmm1    # 0xa2cc0
movsd 0x56397(%rip), %xmm6    # 0xa2040
xorl %eax, %eax
xorpd %xmm5, %xmm5
xorl %ecx, %ecx
movapd %xmm1, %xmm7
movapd %xmm6, %xmm8
movq 0x8(%rsi,%rax,8), %rdx
movsd 0x8(%rdx), %xmm1
mulsd %xmm2, %xmm1
movsd (%rdx), %xmm6
mulsd %xmm0, %xmm6
addsd %xmm1, %xmm6
movsd 0x10(%rdx), %xmm1
mulsd %xmm3, %xmm1
addsd %xmm6, %xmm1
addsd %xmm4, %xmm1
movapd %xmm1, %xmm6
minsd %xmm8, %xmm6
maxsd %xmm7, %xmm1
ucomisd %xmm6, %xmm5
jbe 0x4bcfe
ucomisd %xmm5, %xmm1
ja 0x4bd12
cmpq $0x2, %rax
leaq 0x1(%rax), %rdx
setae %cl
movq %rdx, %rax
cmpq $0x3, %rdx
jne 0x4bcb1
xorpd %xmm0, %xmm0
testb $0x1, %cl
je 0x4bd31
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm6
movapd %xmm6, %xmm0
ja 0x4bd31
minsd %xmm2, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Dist.cpp
// Function: gaps::R3Distance(gaps::R3Halfspace const&, gaps::R3OrientedBox const&)
RNLength R3Distance(const R3Halfspace& halfspace, const R3OrientedBox& box)
{
    // Check distance from halfspace to corners of oriented box
    RNScalar min_d = RN_INFINITY;
    for (int i = 0; i < 8; i++) {
        R3Point corner = box.Corner(i);
        RNScalar d = R3SignedDistance(halfspace.Plane(), corner);
        if (d <= 0.0) return 0;
        if (d < min_d) min_d = d;
    }

    // Return distance to closest corner
    return min_d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x99d23(%rip), %rax     # 0xe5ba8
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %ebp, %ebp
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x247ea
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm2
mulsd 0x8(%r14), %xmm2
mulsd (%r14), %xmm0
movsd 0x20(%rsp), %xmm1
mulsd 0x10(%r14), %xmm1
addsd %xmm2, %xmm0
addsd %xmm0, %xmm1
addsd 0x18(%r14), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jae 0x4bef5
minsd 0x8(%rsp), %xmm1
incl %ebp
movsd %xmm1, 0x8(%rsp)
movapd %xmm1, %xmm0
cmpl $0x8, %ebp
jne 0x4be96
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq