LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3CatmullRomSpline.cpp
// Function: gaps::R3CatmullRomSpline::BlendingWeightDerivative(double, int) const
RNScalar R3CatmullRomSpline::
BlendingWeightDerivative(RNScalar t, int k) const
{
  // In interval i through i+1, 
  // k=-1: V(i-1)
  // k=0: V(i)
  // k=1: V(i+1)
  // k=2: V(i+2)
  // t \in [0,1]

  // Compute powers of t
  double t2 = t * t;

  // Compute blending function
  switch (k) {
  case -1: return -tao + 4*tao*t -3*tao*t2;
  case 0: return 2*(tao-3)*t + 3*(2-tao)*t2;
  case 1: return tao + 2*(3-2*tao)*t + 3*(tao-2)*t2;
  case 2: return -2*tao*t + 3*tao*t2;
  }

  // All other vertex_positions
  return 0;
}

// Assembly:
incl %esi
cmpl $0x3, %esi
ja 0x4ec07
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
leaq 0x5a500(%rip), %rax     # 0xa9038
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movsd 0x60(%rdi), %xmm1
movsd 0x536a2(%rip), %xmm3    # 0xa21f0
mulsd %xmm1, %xmm3
mulsd %xmm0, %xmm3
subsd %xmm1, %xmm3
mulsd 0x5a4b6(%rip), %xmm1    # 0xa9018
mulsd %xmm2, %xmm1
addsd %xmm3, %xmm1
jmp 0x4ec02
movsd 0x60(%rdi), %xmm1
movapd %xmm1, %xmm3
addsd %xmm1, %xmm3
movsd 0x53654(%rip), %xmm4    # 0xa21d8
movapd %xmm4, %xmm5
subsd %xmm3, %xmm5
addsd %xmm5, %xmm5
mulsd %xmm0, %xmm5
addsd %xmm1, %xmm5
addsd 0x53660(%rip), %xmm1    # 0xa2200
mulsd %xmm4, %xmm1
mulsd %xmm2, %xmm1
addsd %xmm5, %xmm1
jmp 0x4ec02
movsd 0x60(%rdi), %xmm3
movsd 0x53645(%rip), %xmm1    # 0xa2200
mulsd %xmm3, %xmm1
mulsd 0x53611(%rip), %xmm3    # 0xa21d8
mulsd %xmm3, %xmm2
jmp 0x4ebfa
movsd 0x60(%rdi), %xmm3
movsd 0x5a43e(%rip), %xmm1    # 0xa9018
addsd %xmm3, %xmm1
addsd %xmm1, %xmm1
movsd 0x5361e(%rip), %xmm4    # 0xa2208
subsd %xmm3, %xmm4
mulsd 0x535e2(%rip), %xmm4    # 0xa21d8
mulsd %xmm4, %xmm2
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movapd %xmm1, %xmm0
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3CatmullRomSpline.cpp
// Function: gaps::R3CatmullRomSpline::UpdateBBox()
void R3CatmullRomSpline::
UpdateBBox(void) 
{
  // Initialize bounding box
  R3Polyline::UpdateBBox();

  // Union phantom vertex_positions
  for (int i = 0; i < NVertices()-1; i++) {
    bbox.Union(PhantomVertexPosition(i, 0));
    bbox.Union(PhantomVertexPosition(i, 1));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x5020a
cmpl $0x2, 0x20(%rbx)
jl 0x4ec6f
leaq 0x28(%rbx), %r14
xorl %ebp, %ebp
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x4e1cc
movq %r14, %rdi
movq %r15, %rsi
callq 0x27cc6
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl $0x1, %ecx
callq 0x4e1cc
movq %r14, %rdi
movq %r15, %rsi
callq 0x27cc6
incl %ebp
movl 0x20(%rbx), %eax
decl %eax
cmpl %eax, %ebp
jl 0x4ec2d
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3CatmullRomSpline.cpp
// Function: gaps::R3CatmullRomSpline::Outline(double) const
void R3CatmullRomSpline::
Outline(RNScalar sample_spacing) const
{
  // Determine sample spacing
  const int default_nsegments = 100;
  if (sample_spacing == 0) sample_spacing =  (EndParameter() - StartParameter()) / default_nsegments;
  if (sample_spacing == 0) return;
  
  // Draw spline
  R3BeginLine();
  for (RNScalar u = StartParameter(); u <= EndParameter(); u += sample_spacing) 
    R3LoadPoint(PointPosition(u));
  R3EndLine();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4ecd8
jp 0x4ecd8
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x220(%rax)
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x218(%rax)
xorpd %xmm1, %xmm1
movsd 0x8(%rsp), %xmm2
subsd %xmm0, %xmm2
movapd %xmm2, %xmm0
divsd 0x5a348(%rip), %xmm0    # 0xa9020
ucomisd %xmm1, %xmm0
jne 0x4ece4
jnp 0x4ed73
movl $0x3, %edi
movsd %xmm0, 0x8(%rsp)
callq 0xe110
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x218(%rax)
movsd %xmm0, (%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x220(%rax)
movsd (%rsp), %xmm1
ucomisd %xmm1, %xmm0
jb 0x4ed6e
movapd %xmm1, %xmm0
leaq 0x10(%rsp), %r14
movsd %xmm0, (%rsp)
movq (%rbx), %rax
movq %r14, %rdi
movq %rbx, %rsi
movsd (%rsp), %xmm0
callq *0x238(%rax)
movq %r14, %rdi
callq 0xe130
movsd (%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x220(%rax)
ucomisd (%rsp), %xmm0
movsd (%rsp), %xmm0
jae 0x4ed25
callq 0xe5d0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Polyline.cpp
// Function: gaps::R3Polyline::R3Polyline(gaps::R3Polyline const&)
R3Polyline::
R3Polyline(const R3Polyline& polyline)
  : vertex_positions(NULL),
    vertex_parameters(NULL),
    vertex_datas(NULL),
    nvertices(polyline.nvertices),
    bbox(polyline.BBox())
{
  // Copy vertex_positions and parameters
  if (nvertices > 0) {
    this->vertex_positions = new R3Point [ nvertices ];
    this->vertex_parameters = new RNScalar [ nvertices ];
    for (int i = 0; i < nvertices; i++) {
      this->vertex_positions[i] = polyline.vertex_positions[i];
      this->vertex_parameters[i] = polyline.vertex_parameters[i];
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x50308
leaq 0x93795(%rip), %rax     # 0xe2590
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
movl 0x20(%r15), %eax
movl %eax, 0x20(%rbx)
leaq 0x28(%rbx), %rdi
movq (%r15), %rax
movq %rdi, (%rsp)
movq %r15, %rsi
callq *0x88(%rax)
movslq 0x20(%rbx), %rax
testq %rax, %rax
jle 0x4eeca
shlq $0x3, %rax
leaq (%rax,%rax,2), %r12
movq %r12, %rdi
callq 0xe030
movq %rax, %r13
leaq 0x8(%rbx), %rbp
xorl %r14d, %r14d
leaq (%r14,%r13), %rdi
callq 0x3c530
addq $0x18, %r14
cmpq %r14, %r12
jne 0x4ee4f
movq %r13, 0x8(%rbx)
movslq 0x20(%rbx), %r14
leaq (,%r14,8), %rax
testq %r14, %r14
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0xe030
movq %rax, 0x10(%rbx)
testl %r14d, %r14d
jle 0x4eeca
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%r15), %rsi
addq %r12, %rsi
movq (%rbp), %rdi
addq %r12, %rdi
callq 0x3c89a
movq 0x10(%r15), %rax
movsd (%rax,%r13,8), %xmm0
movq 0x10(%rbx), %rax
movsd %xmm0, (%rax,%r13,8)
incq %r13
movslq 0x20(%rbx), %rax
addq $0x18, %r12
cmpq %rax, %r13
jl 0x4ee93
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x4eefc
jmp 0x4eee0
movq %rax, %r15
jmp 0x4eef3
movq %rax, %r15
movq %r13, %rdi
movq %r12, %rsi
callq 0xe8c0
movq (%rsp), %rdi
callq 0x280f4
movq %rbx, %rdi
callq 0x50314
movq %r15, %rdi
callq 0xe7e0
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Polyline.cpp
// Function: gaps::R3Polyline::R3Polyline(gaps::RNArray<gaps::R3Point*> const&)
R3Polyline::
R3Polyline(const RNArray<R3Point *>& points)
  : vertex_positions(NULL),
    vertex_parameters(NULL),
    vertex_datas(NULL),
    nvertices(points.NEntries()),
    bbox(FLT_MAX, FLT_MAX, FLT_MAX, -FLT_MAX, -FLT_MAX, -FLT_MAX)
{
  // Copy vertex_positions
  if (points.NEntries() > 0) {
    this->vertex_positions = new R3Point [ points.NEntries() ];
    for (int i = 0; i < points.NEntries(); i++) {
      this->vertex_positions[i] = *(points[i]);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x50308
leaq 0x93667(%rip), %rax     # 0xe2590
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
movl 0xc(%r15), %eax
movl %eax, 0x20(%rbx)
leaq 0x28(%rbx), %rdi
movsd 0x530f2(%rip), %xmm0    # 0xa2040
movsd 0x53d62(%rip), %xmm3    # 0xa2cb8
movq %rdi, (%rsp)
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
movaps %xmm3, %xmm4
movaps %xmm3, %xmm5
callq 0x27374
movslq 0xc(%r15), %rax
testq %rax, %rax
jle 0x4efd4
shlq $0x3, %rax
leaq (%rax,%rax,2), %r12
movq %r12, %rdi
callq 0xe030
movq %rax, %r13
leaq 0x8(%rbx), %rbp
xorl %r14d, %r14d
leaq (%r14,%r13), %rdi
callq 0x3c530
addq $0x18, %r14
cmpq %r14, %r12
jne 0x4ef8e
movq %r13, (%rbp)
cmpl $0x0, 0xc(%r15)
jle 0x4efd4
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%r15), %rax
movq (%rax,%r13,8), %rsi
movq (%rbp), %rdi
addq %r12, %rdi
callq 0x3c89a
incq %r13
movslq 0xc(%r15), %rax
addq $0x18, %r12
cmpq %rax, %r13
jl 0x4efb1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4efea
movq %rax, %r15
jmp 0x4f006
movq %rax, %r15
jmp 0x4effd
movq %rax, %r15
movq %r13, %rdi
movq %r12, %rsi
callq 0xe8c0
movq (%rsp), %rdi
callq 0x280f4
movq %rbx, %rdi
callq 0x50314
movq %r15, %rdi
callq 0xe7e0
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Polyline.cpp
// Function: gaps::R3Polyline::R3Polyline(gaps::R3Point const*, int)
R3Polyline::
R3Polyline(const R3Point *points, int npoints)
  : vertex_positions(NULL),
    vertex_parameters(NULL),
    vertex_datas(NULL),
    nvertices(npoints),
    bbox(FLT_MAX, FLT_MAX, FLT_MAX, -FLT_MAX, -FLT_MAX, -FLT_MAX)
{
  // Copy vertex_positions
  if (npoints > 0) {
    this->vertex_positions = new R3Point [ npoints ];
    for (int i = 0; i < npoints; i++) {
      this->vertex_positions[i] = points[i];
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x50308
leaq 0x9355b(%rip), %rax     # 0xe2590
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
movl %ebp, 0x20(%rbx)
leaq 0x28(%rbx), %rdi
movsd 0x52fea(%rip), %xmm0    # 0xa2040
movsd 0x53c5a(%rip), %xmm3    # 0xa2cb8
movq %rdi, (%rsp)
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
movaps %xmm3, %xmm4
movaps %xmm3, %xmm5
callq 0x27374
testl %ebp, %ebp
jle 0x4f0c5
movl %ebp, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %r12
movq %r12, %rdi
callq 0xe030
movq %rax, %r13
leaq 0x8(%rbx), %rbp
xorl %r14d, %r14d
leaq (%r14,%r13), %rdi
callq 0x3c530
addq $0x18, %r14
cmpq %r14, %r12
jne 0x4f093
movq %r13, (%rbp)
xorl %r13d, %r13d
leaq (%r15,%r13), %rsi
movq (%rbp), %rdi
addq %r13, %rdi
callq 0x3c89a
addq $0x18, %r13
cmpq %r13, %r12
jne 0x4f0ac
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4f0db
movq %rax, %r15
jmp 0x4f0f7
movq %rax, %r15
jmp 0x4f0ee
movq %rax, %r15
movq %r13, %rdi
movq %r12, %rsi
callq 0xe8c0
movq (%rsp), %rdi
callq 0x280f4
movq %rbx, %rdi
callq 0x50314
movq %r15, %rdi
callq 0xe7e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Polyline.cpp
// Function: gaps::R3Polyline::R3Polyline(gaps::R3Point const*, double const*, int)
R3Polyline::
R3Polyline(const R3Point *points, const RNScalar *parameters, int npoints)
  : vertex_positions(NULL),
    vertex_parameters(NULL),
    vertex_datas(NULL),
    nvertices(npoints),
    bbox(FLT_MAX, FLT_MAX, FLT_MAX, -FLT_MAX, -FLT_MAX, -FLT_MAX)
{
  // Copy vertex_positions and parameters
  if (npoints > 0) {
    this->vertex_positions = new R3Point [ npoints ];
    this->vertex_parameters = new RNScalar [ npoints ];
    for (int i = 0; i < npoints; i++) {
      this->vertex_positions[i] = points[i];
      this->vertex_parameters[i] = parameters[i];
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x50308
leaq 0x93463(%rip), %rax     # 0xe2590
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
movl %ebp, 0x20(%rbx)
leaq 0x28(%rbx), %rdi
movsd 0x52ef2(%rip), %xmm0    # 0xa2040
movsd 0x53b62(%rip), %xmm3    # 0xa2cb8
movq %rdi, 0x8(%rsp)
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
movaps %xmm3, %xmm4
movaps %xmm3, %xmm5
callq 0x27374
testl %ebp, %ebp
jle 0x4f203
movq %r15, 0x10(%rsp)
movq %r14, 0x18(%rsp)
movl %ebp, %ebp
leaq (,%rbp,8), %rax
movq %rax, 0x20(%rsp)
leaq (%rax,%rax,2), %r13
movq %r13, %rdi
callq 0xe030
movq %rax, %r14
leaq 0x8(%rbx), %r15
xorl %r12d, %r12d
leaq (%r14,%r12), %rdi
callq 0x3c530
addq $0x18, %r12
cmpq %r12, %r13
jne 0x4f1a3
movq %r14, (%r15)
movq 0x20(%rsp), %rdi
callq 0xe030
movq %rax, 0x10(%rbx)
xorl %r14d, %r14d
movq 0x18(%rsp), %r12
movq 0x10(%rsp), %r13
leaq (,%r14,8), %rax
leaq (%rax,%rax,2), %rdi
leaq (%rdi,%r13), %rsi
addq (%r15), %rdi
callq 0x3c89a
movsd (%r12,%r14,8), %xmm0
movq 0x10(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
cmpq %rbp, %r14
jne 0x4f1d3
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x4f236
jmp 0x4f219
movq %rax, %r15
jmp 0x4f22c
movq %rax, %r15
movq %r14, %rdi
movq %r13, %rsi
callq 0xe8c0
movq 0x8(%rsp), %rdi
callq 0x280f4
movq %rbx, %rdi
callq 0x50314
movq %r15, %rdi
callq 0xe7e0
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Polyline.cpp
// Function: gaps::R3Polyline::IsPoint() const
const RNBoolean R3Polyline::
IsPoint(void) const
{
  // Return whether spline covers one point
  if (nvertices == 0) return FALSE;
  if (nvertices == 1) return TRUE;

  // Look for vertices at different positions
  for (int i = 1; i < nvertices; i++) {
    if (!R3Contains(vertex_positions[0], vertex_positions[i])) {
      return FALSE;
    }
  }

  // All vertices are at same position
  return TRUE;
}

// Assembly:
movl 0x20(%rdi), %ecx
cmpl $0x2, %ecx
jb 0x4f5cc
movl $0x1, %ecx
jl 0x4f5cc
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %r14d
movl $0x18, %r15d
movq 0x8(%rbx), %rdi
leaq (%rdi,%r15), %rsi
callq 0x4652b
testl %eax, %eax
je 0x4f5c0
incq %r14
movslq 0x20(%rbx), %rcx
addq $0x18, %r15
cmpq %rcx, %r14
jl 0x4f59f
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
popq %rbx
popq %r14
popq %r15
movl %ecx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Polyline.cpp
// Function: gaps::R3Polyline::IsLinear() const
const RNBoolean R3Polyline::
IsLinear(void) const
{
  // Return whether spline lies on one line
  if (nvertices == 0) return FALSE;
  if (nvertices <= 2) return TRUE;

  // Check if vertices all line on same line
  R3Line line;
  int line_npositions = 0;
  R3Point line_positions[2];
  for (int i = 0; i < nvertices; i++) {
    if (line_npositions == 0) {
      line_positions[line_npositions++] = vertex_positions[i];
    }
    else if ((line_npositions == 1) && !R3Contains(line_positions[0], vertex_positions[i])) {
      line_positions[line_npositions++] = vertex_positions[i];
      line.Reset(line_positions[0], line_positions[1] - line_positions[0]);
    }
    else if (!R3Contains(line, vertex_positions[i])) {
      return FALSE;
    }
  }

  // All vertices are on same line
  return TRUE;
}

// Assembly:
movl 0x20(%rdi), %ecx
testl %ecx, %ecx
je 0x4f6eb
movl $0x1, %eax
cmpl $0x3, %ecx
jl 0x4f705
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x3c208
xorl %r14d, %r14d
leaq (%rsp,%r14), %rdi
addq $0x30, %rdi
callq 0x3c530
addq $0x18, %r14
cmpq $0x30, %r14
jne 0x4f605
movl $0x1, %eax
cmpl $0x0, 0x20(%rbx)
jle 0x4f6f7
xorl %r15d, %r15d
leaq 0x30(%rsp), %r12
movq %rsp, %rbp
xorl %r13d, %r13d
xorl %r14d, %r14d
cmpl $0x1, %r14d
je 0x4f65e
testl %r14d, %r14d
jne 0x4f671
movq 0x8(%rbx), %rsi
addq %r15, %rsi
movq %r12, %rdi
callq 0x3c89a
movl $0x1, %r14d
jmp 0x4f684
movq 0x8(%rbx), %rsi
addq %r15, %rsi
movq %r12, %rdi
callq 0x4652b
testl %eax, %eax
je 0x4f696
movq 0x8(%rbx), %rsi
addq %r15, %rsi
movq %rbp, %rdi
callq 0x4679f
testl %eax, %eax
je 0x4f6f5
incq %r13
movslq 0x20(%rbx), %rax
addq $0x18, %r15
cmpq %rax, %r13
jl 0x4f63c
jmp 0x4f6ee
movq 0x8(%rbx), %rsi
addq %r15, %rsi
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x3c89a
leaq 0x60(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x3c78e
movq %rsp, %rdi
movq %r12, %rsi
callq 0x3c89a
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
movq %rsp, %rbp
callq 0x3d752
movq %r14, %rdi
callq 0x3d2dc
movl $0x2, %r14d
jmp 0x4f684
xorl %eax, %eax
retq
movl $0x1, %eax
jmp 0x4f6f7
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Polyline.cpp
// Function: gaps::R3Polyline::IsPlanar() const
const RNBoolean R3Polyline::
IsPlanar(void) const
{
  // Return whether spline lies on one line
  if (nvertices == 0) return FALSE;
  if (nvertices <= 3) return TRUE;

  // Check if vertices all line on same plane
  R3Plane plane;
  int plane_npositions = 0;
  R3Point plane_positions[3];
  for (int i = 0; i < nvertices; i++) {
    if (plane_npositions == 0) {
      plane_positions[plane_npositions++] = vertex_positions[i];
    }
    else if ((plane_npositions == 1) &&
             !R3Contains(plane_positions[0], vertex_positions[i])) {
      plane_positions[plane_npositions++] = vertex_positions[i];
    }
    else if ((plane_npositions == 2) &&
             !R3Contains(plane_positions[0], vertex_positions[i]) &&
             !R3Contains(plane_positions[1], vertex_positions[i])) {
      plane_positions[plane_npositions++] = vertex_positions[i];
      R3Vector v1 = plane_positions[1] - plane_positions[0];
      R3Vector v2 = plane_positions[2] - plane_positions[0];
      R3Vector normal = v1 % v2; normal.Normalize();
      plane.Reset(plane_positions[0], normal);
    }
    else if (!R3Contains(plane, vertex_positions[i])) {
      return FALSE;
    }
  }

  // All vertices are on same plane
  return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl 0x20(%rdi), %eax
testl %eax, %eax
je 0x4f891
movl $0x1, %ebp
cmpl $0x4, %eax
jl 0x4f893
movq %rdi, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3b020
xorl %r14d, %r14d
leaq (%rsp,%r14), %rdi
callq 0x3c530
addq $0x18, %r14
cmpq $0x48, %r14
jne 0x4f740
movl $0x1, %ebp
cmpl $0x0, 0x20(%rbx)
jle 0x4f893
xorl %r13d, %r13d
movq %rsp, %r12
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpl $0x2, %r15d
je 0x4f7c2
cmpl $0x1, %r15d
je 0x4f796
testl %r15d, %r15d
jne 0x4f7ea
movq 0x8(%rbx), %rsi
addq %r13, %rsi
movq %r12, %rdi
callq 0x3c89a
movl $0x1, %r15d
jmp 0x4f803
movq 0x8(%rbx), %rsi
addq %r13, %rsi
movq %r12, %rdi
callq 0x4652b
testl %eax, %eax
jne 0x4f7ea
movq 0x8(%rbx), %rsi
addq %r13, %rsi
leaq 0x18(%rsp), %rdi
callq 0x3c89a
movl $0x2, %r15d
jmp 0x4f803
movq 0x8(%rbx), %rsi
addq %r13, %rsi
movq %r12, %rdi
callq 0x4652b
testl %eax, %eax
jne 0x4f7ea
movq 0x8(%rbx), %rsi
addq %r13, %rsi
leaq 0x18(%rsp), %rdi
callq 0x4652b
testl %eax, %eax
je 0x4f819
movq 0x8(%rbx), %rsi
addq %r13, %rsi
leaq 0x50(%rsp), %rdi
callq 0x46f51
testl %eax, %eax
je 0x4f891
incq %r14
movslq 0x20(%rbx), %rax
addq $0x18, %r13
cmpq %rax, %r14
jl 0x4f76e
jmp 0x4f893
movq 0x8(%rbx), %rsi
addq %r13, %rsi
leaq 0x30(%rsp), %rdi
callq 0x3c89a
leaq 0x88(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movq %r12, %rdx
callq 0x3c78e
leaq 0x70(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq %r12, %rdx
callq 0x3c78e
leaq 0xa0(%rsp), %r15
movq %r15, %rdi
leaq 0x88(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x3d8fa
movq %r15, %rdi
callq 0x3d2dc
leaq 0x50(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3b884
movl $0x3, %r15d
jmp 0x4f803
xorl %ebp, %ebp
movl %ebp, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Polyline.cpp
// Function: gaps::R3Polyline::Length() const
const RNLength R3Polyline::
Length(void) const
{
  // For now, return length of control polygon
  RNLength length = 0;
  for (int i = 1; i < nvertices; i++) {
    length += R3Distance(vertex_positions[i-1], vertex_positions[i]);
  }
  return length;
}

// Assembly:
xorpd %xmm0, %xmm0
cmpl $0x2, 0x20(%rdi)
jl 0x4f917
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movl $0x1, %r14d
movl $0x18, %r15d
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rsi
leaq (%rsi,%r15), %rdi
addq $-0x18, %rdi
addq %r15, %rsi
callq 0x49404
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
incq %r14
movslq 0x20(%rbx), %rax
addq $0x18, %r15
cmpq %rax, %r14
jl 0x4f8ce
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Polyline.cpp
// Function: gaps::R3Polyline::Centroid() const
const R3Point R3Polyline::
Centroid(void) const
{
  // Compute centroid of vertices weighted by parameters
  RNScalar weight = 0;
  R3Point sum = R3zero_point;
  for (int i = 0; i < nvertices; i++) {
    if (i > 0) weight += VertexParameter(i) - VertexParameter(i-1);
    if (i < nvertices-1) weight += VertexParameter(i+1) - VertexParameter(i);
    sum += weight * vertex_positions[i];
  }

  // Or, if no weight, recompute without weighting
  if (weight == 0) {
    sum = R3zero_point;
    for (int i = 0; i < nvertices; i++) {
      sum += vertex_positions[i];
      weight += 1;
    }
  }
  
  // Return weighted average
  if (weight == 0) return R3zero_point;
  return sum / weight;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x49712d(%rip), %rsi    # 0x4e6a60
leaq 0x8(%rsp), %rdi
callq 0x3c542
movl 0x20(%r14), %eax
xorpd %xmm0, %xmm0
testl %eax, %eax
jle 0x4fa1d
movsd %xmm0, (%rsp)
xorl %r13d, %r13d
leaq 0x20(%rsp), %r15
leaq 0x8(%rsp), %r12
xorl %ebp, %ebp
testq %rbp, %rbp
je 0x4f981
movq 0x10(%r14), %rcx
testq %rcx, %rcx
movsd (%rsp), %xmm0
je 0x4f988
movsd -0x8(%rcx,%rbp,8), %xmm1
movsd (%rcx,%rbp,8), %xmm2
jmp 0x4f999
movsd (%rsp), %xmm0
jmp 0x4f9a1
xorps %xmm2, %xmm2
cvtsi2sd %ebp, %xmm2
leal -0x1(%rbp), %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
subsd %xmm1, %xmm2
addsd %xmm2, %xmm0
decl %eax
cltq
cmpq %rax, %rbp
jge 0x4f9d9
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x4f9c0
movsd (%rax,%rbp,8), %xmm1
movsd 0x8(%rax,%rbp,8), %xmm2
jmp 0x4f9d1
leal 0x1(%rbp), %eax
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
xorps %xmm1, %xmm1
cvtsi2sd %ebp, %xmm1
subsd %xmm1, %xmm2
addsd %xmm2, %xmm0
incq %rbp
movq 0x8(%r14), %rsi
addq %r13, %rsi
movq %r15, %rdi
movsd %xmm0, (%rsp)
callq 0x3cf76
movq %r12, %rdi
movq %r15, %rsi
callq 0x3ce6c
movslq 0x20(%r14), %rax
addq $0x18, %r13
cmpq %rax, %rbp
jl 0x4f961
xorpd %xmm1, %xmm1
movsd (%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x4fa82
jp 0x4fa82
movsd %xmm0, (%rsp)
leaq 0x497037(%rip), %rsi    # 0x4e6a60
leaq 0x8(%rsp), %rdi
callq 0x3c89a
cmpl $0x0, 0x20(%r14)
jle 0x4fa7d
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
xorl %r13d, %r13d
movsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x8(%r14), %rsi
addq %r12, %rsi
movq %r15, %rdi
callq 0x3ce6c
movsd (%rsp), %xmm0
addsd 0x525cd(%rip), %xmm0    # 0xa2038
incq %r13
movslq 0x20(%r14), %rax
addq $0x18, %r12
cmpq %rax, %r13
jl 0x4fa4a
jmp 0x4fa82
movsd (%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4fa9f
jp 0x4fa9f
leaq 0x496fcb(%rip), %rsi    # 0x4e6a60
movq %rbx, %rdi
callq 0x3c542
jmp 0x4faac
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3cf98
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Polyline.cpp
// Function: gaps::R3Polyline::BBox() const
const R3Box R3Polyline::
BBox(void) const
{
  // Return bounding box
  if (bbox[0][0] == FLT_MAX) 
    ((R3Polyline *) this)->UpdateBBox();
  return bbox;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x30(%rsi), %xmm0
ucomisd 0x52565(%rip), %xmm0    # 0xa2040
jne 0x4faeb
jp 0x4faeb
movq (%r14), %rax
movq %r14, %rdi
callq *0x288(%rax)
addq $0x28, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x272d4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Polyline.cpp
// Function: gaps::R3Polyline::VertexIndex(double) const
int R3Polyline::
VertexIndex(RNScalar u) const
{
  // Return index at start of segment containing u
  if (u < 0) return 0;
  else if (nvertices < 3) return 0;
  else if (u >= VertexParameter(nvertices-2)) return nvertices-2;
  else if (!vertex_parameters) return (int) u;
  else return BinarySearchForVertexIndex(this, 0, nvertices-2, u);
}

// Assembly:
xorl %eax, %eax
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x4fb7e
movl 0x20(%rdi), %esi
cmpl $0x3, %esi
jl 0x4fb7e
addl $-0x2, %esi
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x4fb7f
movl %esi, %eax
ucomisd (%rcx,%rax,8), %xmm0
jae 0x4fb7c
xorl %edx, %edx
movl %esi, %eax
movslq %edx, %rsi
movsd 0x8(%rcx,%rsi,8), %xmm1
ucomisd %xmm0, %xmm1
ja 0x4fb93
movslq %eax, %rsi
ucomisd (%rcx,%rsi,8), %xmm0
ja 0x4fb7e
leal (%rax,%rdx), %edi
movl %edi, %esi
shrl $0x1f, %esi
addl %edi, %esi
sarl %esi
movslq %esi, %rdi
movsd (%rcx,%rdi,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x4fb68
jnp 0x4fb7c
jbe 0x4fb74
decl %esi
movl %esi, %eax
cmpl %esi, %edx
jne 0x4fb42
jmp 0x4fb93
movl %esi, %edx
cmpl %eax, %esi
jne 0x4fb33
jmp 0x4fb7e
movl %esi, %eax
retq
xorps %xmm1, %xmm1
cvtsi2sd %esi, %xmm1
ucomisd %xmm1, %xmm0
movl %esi, %eax
jae 0x4fb7e
cvttsd2si %xmm0, %eax
retq
movl %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Polyline.cpp
// Function: gaps::R3Polyline::PointPosition(double) const
R3Point R3Polyline::
PointPosition(RNScalar u) const
{
  // Return position at parametric value u

  // Get index variables
  int i = VertexIndex(u);
  double denom = VertexParameter(i+1) - VertexParameter(i);
  if (RNIsZero(denom)) return VertexPosition(i);
  double t = (u - VertexParameter(i)) / denom;

  // Get control vertex_positions
  R3Point P1 = VertexPosition(i);
  R3Point P2 = VertexPosition(i+1);

  // Return interpolated position
  return (1-t)*P1 + t*P2;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
movsd %xmm0, (%rsp)
callq *0x268(%rax)
leal 0x1(%rax), %esi
movq 0x10(%r14), %rdx
movslq %eax, %rcx
movslq %esi, %r12
testq %rdx, %rdx
je 0x4fbff
movsd (%rdx,%r12,8), %xmm0
subsd (%rdx,%rcx,8), %xmm0
leaq 0x95fbc(%rip), %rsi     # 0xe5b98
movsd (%rsi), %xmm1
movapd 0x52438(%rip), %xmm2    # 0xa2020
xorpd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jb 0x4fbf8
ucomisd %xmm0, %xmm1
jae 0x4fc31
movsd (%rdx,%rcx,8), %xmm1
jmp 0x4fc4c
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
leaq 0x95f83(%rip), %rdx     # 0xe5b98
movsd (%rdx), %xmm2
movapd 0x523ff(%rip), %xmm3    # 0xa2020
xorpd %xmm2, %xmm3
ucomisd %xmm3, %xmm0
jb 0x4fc4c
ucomisd %xmm0, %xmm2
jb 0x4fc4c
cltq
leaq (%rax,%rax,2), %rsi
shlq $0x3, %rsi
addq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x3c542
jmp 0x4fcd0
movsd (%rsp), %xmm2
subsd %xmm1, %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, (%rsp)
leaq (%rcx,%rcx,2), %rsi
shlq $0x3, %rsi
addq 0x8(%r14), %rsi
leaq 0x50(%rsp), %r15
movq %r15, %rdi
callq 0x3c542
leaq (%r12,%r12,2), %rsi
shlq $0x3, %rsi
addq 0x8(%r14), %rsi
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x3c542
movsd 0x523a0(%rip), %xmm0    # 0xa2038
subsd (%rsp), %xmm0
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3cf76
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movsd (%rsp), %xmm0
callq 0x3cf76
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3cf30
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Polyline.cpp
// Function: gaps::R3Polyline::PointDerivative(double) const
R3Vector R3Polyline::
PointDerivative(RNScalar u) const
{
  // Return tangent vector at parametric value u

  // Get index variables
  int i = VertexIndex(u);
  R3Point p1 = VertexPosition(i);
  R3Point p2 = VertexPosition(i+1);
  RNScalar u1 = VertexParameter(i);
  RNScalar u2 = VertexParameter(i+1);
  if (u2 <= u1) return R3zero_vector;
  else return (p2 - p1) / (u2 - u1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x268(%rax)
movl %eax, %ebp
movslq %eax, %r15
leaq (%r15,%r15,2), %rsi
shlq $0x3, %rsi
addq 0x8(%r14), %rsi
leaq 0x28(%rsp), %rdi
callq 0x3c542
leal 0x1(%r15), %r12d
movslq %r12d, %r13
leaq (,%r13,2), %rsi
addq %r13, %rsi
shlq $0x3, %rsi
addq 0x8(%r14), %rsi
leaq 0x10(%rsp), %rdi
callq 0x3c542
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x4fd56
movsd (%rax,%r15,8), %xmm1
movsd (%rax,%r13,8), %xmm0
jmp 0x4fd62
cvtsi2sd %ebp, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %r12d, %xmm0
ucomisd %xmm0, %xmm1
jae 0x4fda2
leaq 0x40(%rsp), %r14
leaq 0x10(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %r14, %rdi
movsd %xmm0, (%rsp)
movsd %xmm1, 0x8(%rsp)
callq 0x3c78e
movsd (%rsp), %xmm0
subsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3dcac
jmp 0x4fdb1
leaq 0x58937(%rip), %rsi     # 0xa86e0
movq %rbx, %rdi
callq 0x3cfd6
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Polyline.cpp
// Function: gaps::R3Polyline::operator=(gaps::R3Polyline const&)
R3Polyline& R3Polyline::
operator=(const R3Polyline& polyline)
{
  // Delete previous everything
  if (vertex_positions) delete [] vertex_positions;
  if (vertex_parameters) delete [] vertex_parameters;
  if (vertex_datas) delete [] vertex_datas;
  this->vertex_positions = NULL;
  this->vertex_parameters = NULL;
  this->vertex_datas = NULL;
  
  // Copy properties
  this->nvertices = polyline.nvertices;
  this->bbox = polyline.BBox();

  // Copy vertex_positions and parameters
  if (nvertices > 0) {
    this->vertex_positions = new R3Point [ nvertices ];
    this->vertex_parameters = new RNScalar [ nvertices ];
    for (int i = 0; i < nvertices; i++) {
      this->vertex_positions[i] = polyline.vertex_positions[i];
      this->vertex_parameters[i] = polyline.vertex_parameters[i];
    }
  }

  // Return this
  return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x4fde5
callq 0xe5b0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x4fdf3
callq 0xe5b0
leaq 0x8(%rbx), %r15
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x4fe05
callq 0xe5b0
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movq (%r14), %rax
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *0x88(%rax)
leaq 0x30(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3c89a
leaq 0x48(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x3c89a
leaq 0x8(%rsp), %rdi
callq 0x280f4
movslq 0x20(%rbx), %rax
testq %rax, %rax
jle 0x4fef0
shlq $0x3, %rax
leaq (%rax,%rax,2), %r15
movq %r15, %rdi
callq 0xe030
movq %rax, %r12
xorl %r13d, %r13d
leaq (%r12,%r13), %rdi
callq 0x3c530
addq $0x18, %r13
cmpq %r13, %r15
jne 0x4fe75
movq %r12, 0x8(%rbx)
movslq 0x20(%rbx), %r15
leaq (,%r15,8), %rax
testq %r15, %r15
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0xe030
movq %rax, 0x10(%rbx)
testq %r15, %r15
jle 0x4fef0
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %rsi
addq %r15, %rsi
movq 0x8(%rbx), %rdi
addq %r15, %rdi
callq 0x3c89a
movq 0x10(%r14), %rax
movsd (%rax,%r12,8), %xmm0
movq 0x10(%rbx), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
movslq 0x20(%rbx), %rax
addq $0x18, %r15
cmpq %rax, %r12
jl 0x4feb9
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x280f4
jmp 0x4ff1e
movq %rax, %rbx
movq %r12, %rdi
movq %r15, %rsi
callq 0xe8c0
movq %rbx, %rdi
callq 0xe7e0
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Polyline.cpp
// Function: gaps::R3Polyline::Transform(gaps::R3Transformation const&)
void R3Polyline::
Transform(const R3Transformation& transformation)
{
  // Transform vertices
  for (int i = 0; i < nvertices; i++) {
    vertex_positions[i].Transform(transformation);
  }

  // Mark bbox as out of date
  bbox[0][0] = bbox[0][1] = bbox[0][2] = FLT_MAX;
  bbox[1][0] = bbox[1][1] = bbox[1][2] = -FLT_MAX;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x20(%rdi)
jle 0x4ff5f
movq %rsi, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%rbx), %rdi
addq %r15, %rdi
movq %r14, %rsi
callq 0x3ce48
incq %r12
movslq 0x20(%rbx), %rax
addq $0x18, %r15
cmpq %rax, %r12
jl 0x4ff40
movaps 0x5910a(%rip), %xmm0    # 0xa9070
movups %xmm0, 0x30(%rbx)
movaps 0x5910f(%rip), %xmm0    # 0xa9080
movups %xmm0, 0x50(%rbx)
movaps 0x59114(%rip), %xmm0    # 0xa9090
movups %xmm0, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Polyline.cpp
// Function: gaps::R3Polyline::SetVertexPosition(int, gaps::R3Point const&)
void R3Polyline::
SetVertexPosition(int k, const R3Point& position)
{
  // Set vertex position
  vertex_positions[k] = position;

  // Mark bbox as out of date
  bbox[0][0] = bbox[0][1] = bbox[0][2] = FLT_MAX;
  bbox[1][0] = bbox[1][1] = bbox[1][2] = -FLT_MAX;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq %esi, %rax
leaq (%rax,%rax,2), %rdi
shlq $0x3, %rdi
addq 0x8(%rbx), %rdi
movq %rdx, %rsi
callq 0x3c89a
movaps 0x590c2(%rip), %xmm0    # 0xa9070
movups %xmm0, 0x30(%rbx)
movaps 0x590c7(%rip), %xmm0    # 0xa9080
movups %xmm0, 0x50(%rbx)
movaps 0x590cc(%rip), %xmm0    # 0xa9090
movups %xmm0, 0x40(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Polyline.cpp
// Function: gaps::R3Polyline::SetVertexData(int, void*)
void R3Polyline::
SetVertexData(int k, void *data)
{
  // Allocate vertex datas
  if (!vertex_datas) {
    vertex_datas = new void * [ NVertices() ];
    if (!vertex_datas) {
      RNFail("Unable to allocate vertex datas\n");
      return;
    }
  }

  // Set vertex data
  vertex_datas[k] = data;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq 0x18(%rdi), %rax
testq %rax, %rax
jne 0x501fe
movq %rdi, %r14
movslq 0x20(%rdi), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0xe030
movq %rax, 0x18(%r14)
movslq %ebp, %rcx
movq %rbx, (%rax,%rcx,8)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Polyline.cpp
// Function: gaps::R3Polyline::UpdateBBox()
void R3Polyline::
UpdateBBox(void) 
{
  // Initialize bounding box
  bbox = R3null_box;

  // Union vertex_positions
  for (int i = 0; i < nvertices; i++) {
    bbox.Union(VertexPosition(i));
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
addq $0x30, %rdi
leaq 0x95c73(%rip), %r14     # 0xe5e98
leaq 0x8(%r14), %rsi
callq 0x3c89a
leaq 0x48(%rbx), %rdi
addq $0x20, %r14
movq %r14, %rsi
callq 0x3c89a
cmpl $0x0, 0x20(%rbx)
jle 0x5027d
leaq 0x28(%rbx), %r14
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
xorl %r13d, %r13d
movq 0x8(%rbx), %rsi
addq %r12, %rsi
movq %r15, %rdi
callq 0x3c542
movq %r14, %rdi
movq %r15, %rsi
callq 0x27cc6
incq %r13
movslq 0x20(%rbx), %rax
addq $0x18, %r12
cmpq %rax, %r13
jl 0x50253
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Polyline.cpp
// Function: gaps::R3Polyline::Outline(gaps::RNFlags) const
void R3Polyline::
Outline(const R3DrawFlags flags) const
{
  // Draw polyline
  R3BeginLine();
  for (int i = 0; i < nvertices; i++) 
    R3LoadPoint(VertexPosition(i));
  R3EndLine();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x3, %edi
callq 0xe110
cmpl $0x0, 0x20(%rbx)
jle 0x502ec
xorl %r15d, %r15d
movq %rsp, %r14
xorl %r12d, %r12d
movq 0x8(%rbx), %rsi
addq %r15, %rsi
movq %r14, %rdi
callq 0x3c542
movq %r14, %rdi
callq 0xe130
incq %r12
movslq 0x20(%rbx), %rax
addq $0x18, %r15
cmpq %rax, %r12
jl 0x502c5
callq 0xe5d0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Rectangle.cpp
// Function: gaps::R3Rectangle::operator==(gaps::R3Rectangle const&) const
RNBoolean R3Rectangle::
operator==(const R3Rectangle& rectangle) const
{
    // Return whether rectangle is equal
    return ((Center() == Center()) &&
            (Axis(0) == rectangle.Axis(0)) && 
	    (Axis(1) == rectangle.Axis(1)) && 
	    (Radius(0) == rectangle.Radius(0)) && 
	    (Radius(1) == rectangle.Radius(1)));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
addq $0x8, %rdi
movq %rdi, %rsi
callq 0x3c5f8
xorl %ebx, %ebx
testl %eax, %eax
je 0x50986
leaq 0x20(%r14), %rdi
leaq 0x20(%r15), %rsi
callq 0x3d278
testl %eax, %eax
je 0x50986
leaq 0x38(%r14), %rdi
leaq 0x38(%r15), %rsi
callq 0x3d278
testl %eax, %eax
je 0x50986
movsd 0x68(%r14), %xmm0
ucomisd 0x68(%r15), %xmm0
jne 0x50986
jp 0x50986
movsd 0x70(%r15), %xmm0
cmpeqsd 0x70(%r14), %xmm0
movq %xmm0, %rbx
andl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Rectangle.cpp
// Function: gaps::R3Rectangle::BBox() const
const R3Box R3Rectangle::
BBox(void) const
{
    // Check if rectangle is empty
    if (IsEmpty()) return R3null_box;

    // Return bounding box 
    R3Box bbox = R3null_box;
    for (int i = 0; i < RN_NUM_QUADRANTS; i++) 
      bbox.Union(Corner(i));
    return bbox;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x68(%rsi), %xmm0
minsd 0x70(%rsi), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x95443(%rip), %rsi     # 0xe5e98
callq 0x272d4
xorpd %xmm0, %xmm0
ucomisd 0x8(%rsp), %xmm0
ja 0x50b2f
leaq 0x8(%r14), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%r14), %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%r14), %r13
xorl %r12d, %r12d
leaq 0x18(%rsp), %rbp
leaq 0x30(%rsp), %r15
movsd 0x68(%r14), %xmm0
minsd 0x70(%r14), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x50b08
movq %rbp, %rdi
movq 0x8(%rsp), %rsi
callq 0x3c542
movsd 0x68(%r14), %xmm0
cmpl $0x2, %r12d
jae 0x50ac4
xorpd 0x5155c(%rip), %xmm0    # 0xa2020
movq %r15, %rdi
movq 0x10(%rsp), %rsi
callq 0x3d962
movq %rbp, %rdi
movq %r15, %rsi
callq 0x3c914
movsd 0x70(%r14), %xmm0
testb $0x1, %r12b
jne 0x50af0
xorpd 0x51530(%rip), %xmm0    # 0xa2020
movq %r15, %rdi
movq %r13, %rsi
callq 0x3d962
movq %rbp, %rdi
movq %r15, %rsi
callq 0x3c914
jmp 0x50b17
movq %rbp, %rdi
leaq 0x495f4e(%rip), %rsi    # 0x4e6a60
callq 0x3c542
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x27cc6
incl %r12d
cmpl $0x4, %r12d
jne 0x50a8d
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x280f4
movq %r14, %rdi
callq 0xe7e0
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Rectangle.cpp
// Function: gaps::R3Rectangle::BSphere() const
const R3Sphere R3Rectangle::
BSphere(void) const
{
    // Check if rectangle is empty
    if (IsEmpty()) return R3null_sphere;

    // Return BSphere
    return R3Sphere(Center(), DiagonalRadius());
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movsd 0x68(%rsi), %xmm0
movsd 0x70(%rsi), %xmm1
movapd %xmm0, %xmm2
minsd %xmm1, %xmm2
xorpd %xmm3, %xmm3
ucomisd %xmm2, %xmm3
ja 0x50b92
addq $0x8, %rsi
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x26eba
jmp 0x50ba1
leaq 0x951a7(%rip), %rsi     # 0xe5d40
movq %rbx, %rdi
callq 0x26e6e
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Ellipse.cpp
// Function: gaps::R3Ellipse::Empty()
void R3Ellipse::
Empty(void)
{
    // Empty ellipse
    cs = R3xyz_coordinate_system;
    radii = R2null_vector;
    bbox = R3null_box;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x8, %rdi
leaq 0x94f74(%rip), %r14     # 0xe6110
movq %r14, %rsi
callq 0x3c89a
leaq 0x20(%rbx), %rdi
leaq 0x18(%r14), %rsi
callq 0x3d752
leaq 0x38(%rbx), %rdi
leaq 0x30(%r14), %rsi
callq 0x3d752
leaq 0x50(%rbx), %rdi
addq $0x48, %r14
movq %r14, %rsi
callq 0x3d752
leaq 0x68(%rbx), %rdi
leaq 0x58857(%rip), %rsi     # 0xa9a30
callq 0x68720
leaq 0x80(%rbx), %rdi
leaq 0x94cac(%rip), %r14     # 0xe5e98
leaq 0x8(%r14), %rsi
callq 0x3c89a
addq $0x98, %rbx
addq $0x20, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3c89a
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Circle.cpp
// Function: gaps::R3InitCircle()
int 
R3InitCircle()
{
    // Initialize circle angles and points 
    for (int i = 0; i < R3circle_npoints; i++) {
        R3circle_angles[i] = ((RNScalar) i * RN_TWO_PI) / (RNScalar) R3circle_npoints;
        R3circle_points[i] = R3Point(cos(R3circle_angles[i]), sin(R3circle_angles[i]), 0.0);
        R3circle_texcoords[i] = R2Point(0.5 * (R3circle_points[i].X() + 1.0), 0.5 * (R3circle_points[i].Y() + 1.0));
    }

    /* Return success */
    return TRUE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
leaq 0x58c44(%rip), %rax     # 0xa9fe8
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x495fbb(%rip), %rbx    # 0x4e7370
leaq 0x495cb4(%rip), %r14    # 0x4e7070
leaq 0x495bad(%rip), %r12    # 0x4e6f70
xorl %r13d, %r13d
leaq 0x18(%rsp), %r15
xorps %xmm0, %xmm0
cvtsi2sd %r13d, %xmm0
mulsd 0x8(%rsp), %xmm0
mulsd 0x57d27(%rip), %xmm0    # 0xa9108
movsd %xmm0, (%r12)
callq 0xe860
movsd %xmm0, 0x10(%rsp)
movsd (%r12), %xmm0
callq 0xe0f0
movaps %xmm0, %xmm1
xorps %xmm2, %xmm2
movq %r15, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x3c532
movq %r14, %rdi
movq %r15, %rsi
callq 0x3c89a
movsd (%r14), %xmm0
movsd 0x50c0f(%rip), %xmm2    # 0xa2038
addsd %xmm2, %xmm0
movsd 0x50bfb(%rip), %xmm3    # 0xa2030
mulsd %xmm3, %xmm0
movsd 0x8(%r14), %xmm1
addsd %xmm2, %xmm1
mulsd %xmm3, %xmm1
movq %r15, %rdi
callq 0x680a6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x681de
incq %r13
addq $0x10, %rbx
addq $0x18, %r14
addq $0x8, %r12
cmpq $0x20, %r13
jne 0x513cb
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Circle.cpp
// Function: gaps::R3Circle::Transform(gaps::R3Transformation const&)
void R3Circle::
Transform (const R3Transformation& transformation)
{
    // Transform circle ???
    center.Transform(transformation);
    plane.Transform(transformation);
    if (!transformation.IsIsotropic()) RNWarning("Circle transformed by anisotropic transformation");
    radius *= transformation.ScaleFactor();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x3ce48
leaq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0x3b73a
movq (%r14), %rax
movq %r14, %rdi
callq *0x30(%rax)
testl %eax, %eax
jne 0x517de
leaq 0x57957(%rip), %rdi     # 0xa912e
xorl %eax, %eax
callq 0x71a8d
movq (%r14), %rax
movq %r14, %rdi
callq *0xc0(%rax)
mulsd 0x20(%rbx), %xmm0
movsd %xmm0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::~R3TriangleArray()
R3TriangleArray::
~R3TriangleArray(void)
{
    // Delete triangles and vertices
    for (int i = 0; i < triangles.NEntries(); i++) delete triangles[i];
    for (int i = 0; i < vertices.NEntries(); i++) delete vertices[i];

    // Delete vbo
    if (vbo_id > 0) glDeleteBuffers(1, &vbo_id);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x91645(%rip), %rax     # 0xe3208
movq %rax, (%rdi)
leaq 0x18(%rdi), %r14
movl 0x24(%rdi), %eax
testl %eax, %eax
jle 0x51bf4
xorl %r15d, %r15d
movq (%r14), %rcx
movq (%rcx,%r15,8), %rdi
testq %rdi, %rdi
je 0x51be9
movq (%rdi), %rax
callq *0x8(%rax)
movl 0x24(%rbx), %eax
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0x51bd4
cmpl $0x0, 0x14(%rbx)
jle 0x51c1b
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
movl $0x68, %esi
callq 0xe450
incq %r15
movslq 0x14(%rbx), %rax
cmpq %rax, %r15
jl 0x51bfd
cmpl $0x0, 0x68(%rbx)
je 0x51c33
leaq 0x68(%rbx), %rsi
movq 0x933a4(%rip), %rax     # 0xe4fd0
movl $0x1, %edi
callq *(%rax)
leaq 0x8(%rbx), %r15
leaq 0x28(%rbx), %rdi
callq 0x280f4
movq %r14, %rdi
callq 0x6f876
movq %r15, %rdi
callq 0x6f876
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5460c
movq %rax, %rdi
callq 0x23b83
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::IsPoint() const
const RNBoolean R3TriangleArray::
IsPoint (void) const
{
  // Check if all vertices are at same position
  if (vertices.NEntries() > 1) {
    const R3Point& p0 = vertices[0]->Position();
    for (int i = 1; i < vertices.NEntries(); i++) 
      if (!R3Contains(p0, vertices[i]->Position())) return FALSE;
  }
  return TRUE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0x1, %ebx
cmpl $0x2, 0x14(%rdi)
jl 0x51cc5
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq (%rax), %r15
movl $0x1, %r12d
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rsi
movq %r15, %rdi
callq 0x4652b
testl %eax, %eax
je 0x51cc3
incq %r12
movslq 0x14(%r14), %rax
cmpq %rax, %r12
jl 0x51ca1
jmp 0x51cc5
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::IsPlanar() const
const RNBoolean R3TriangleArray::
IsPlanar(void) const
{
  // Check if all triangles are on same plane
  if (triangles.NEntries() > 1) {
    const R3Plane& p0 = triangles[0]->Plane();
    for (int i = 1; i < triangles.NEntries(); i++) 
      if (!R3Contains(p0, triangles[i]->Plane())) return FALSE;
  }
  return TRUE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0x1, %ebx
cmpl $0x2, 0x24(%rdi)
jl 0x51d27
movq %rdi, %r14
movq 0x18(%rdi), %rax
movq (%rax), %r15
addq $0x20, %r15
movl $0x1, %r12d
movq 0x18(%r14), %rax
movq (%rax,%r12,8), %rsi
addq $0x20, %rsi
movq %r15, %rdi
callq 0x470b7
testl %eax, %eax
je 0x51d25
incq %r12
movslq 0x24(%r14), %rax
cmpq %rax, %r12
jl 0x51cff
jmp 0x51d27
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::Length() const
const RNLength R3TriangleArray::
Length (void) const
{
    // Return cumulative perimeter of triangles
    RNLength length = 0.0;
    for (int i = 0; i < triangles.NEntries(); i++)
      length += triangles[i]->Length();
    return length;
}

// Assembly:
cmpl $0x0, 0x24(%rdi)
jle 0x51da2
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorpd %xmm0, %xmm0
xorl %r14d, %r14d
movsd %xmm0, (%rsp)
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incq %r14
movslq 0x24(%rbx), %rax
cmpq %rax, %r14
jl 0x51d68
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::Centroid() const
const R3Point R3TriangleArray::
Centroid(void) const
{
    // Return centroid of vertices
    R3Point centroid = R3zero_point;
    for (int i = 0; i < vertices.NEntries(); i++) 
      centroid += vertices[i]->Position();
    centroid /= (RNScalar) vertices.NEntries();
    return centroid;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x494c56(%rip), %rsi    # 0x4e6a60
callq 0x3c542
movl 0x14(%r14), %eax
testl %eax, %eax
jle 0x51e36
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x3ce6c
incq %r15
movslq 0x14(%r14), %rax
cmpq %rax, %r15
jl 0x51e1a
cvtsi2sd %eax, %xmm0
movq %rbx, %rdi
callq 0x3ceea
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop