LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x50f3c
leaq 0x9288d(%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 0x5231c(%rip), %xmm0    # 0xa2040
movsd 0x52f94(%rip), %xmm3    # 0xa2cc0
movq %rdi, 0x8(%rsp)
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
movaps %xmm3, %xmm4
movaps %xmm3, %xmm5
callq 0x27590
testl %ebp, %ebp
jle 0x4fdd9
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 0x3ca24
addq $0x18, %r12
cmpq %r12, %r13
jne 0x4fd79
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 0x3cd94
movsd (%r12,%r14,8), %xmm0
movq 0x10(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
cmpq %rbp, %r14
jne 0x4fda9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x4fe0c
jmp 0x4fdef
movq %rax, %r15
jmp 0x4fe02
movq %rax, %r15
movq %r14, %rdi
movq %r13, %rsi
callq 0xe8c0
movq 0x8(%rsp), %rdi
callq 0x28348
movq %rbx, %rdi
callq 0x50f48
movq %r15, %rdi
callq 0xe7e0
// File: /workspace/github_cpp_makefile_star2_O1/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), %eax
cmpl $0x2, %eax
jb 0x501aa
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, 0x20(%rdi)
setl %bpl
jl 0x5019c
movq 0x8(%rbx), %rdi
leaq 0x18(%rdi), %rsi
callq 0x46e1b
testl %eax, %eax
je 0x5019c
movl $0x1, %r14d
movl $0x30, %r15d
incq %r14
movslq 0x20(%rbx), %rax
cmpq %rax, %r14
setge %bpl
jge 0x5019c
movq 0x8(%rbx), %rdi
leaq (%rdi,%r15), %rsi
addq $0x18, %r15
callq 0x46e1b
testl %eax, %eax
jne 0x50177
movzbl %bpl, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x502bf
movl $0x1, %eax
cmpl $0x3, %ecx
jl 0x502d7
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x3c6fc
xorl %r14d, %r14d
leaq (%rsp,%r14), %rdi
addq $0x30, %rdi
callq 0x3ca24
addq $0x18, %r14
cmpq $0x30, %r14
jne 0x501e1
cmpl $0x0, 0x20(%rbx)
setle %r13b
jle 0x502c2
xorl %r14d, %r14d
leaq 0x30(%rsp), %r12
xorl %r15d, %r15d
xorl %ebp, %ebp
cmpl $0x1, %ebp
je 0x50232
testl %ebp, %ebp
jne 0x50245
movq 0x8(%rbx), %rsi
addq %r14, %rsi
movq %r12, %rdi
callq 0x3cd94
movl $0x1, %ebp
jmp 0x50258
movq 0x8(%rbx), %rsi
addq %r14, %rsi
movq %r12, %rdi
callq 0x46e1b
testl %eax, %eax
je 0x5026e
movq 0x8(%rbx), %rsi
addq %r14, %rsi
movq %rsp, %rdi
callq 0x4708f
testl %eax, %eax
je 0x502c2
incq %r15
movslq 0x20(%rbx), %rax
addq $0x18, %r14
cmpq %rax, %r15
setge %r13b
jl 0x50213
jmp 0x502c2
movq 0x8(%rbx), %rsi
addq %r14, %rsi
leaq 0x48(%rsp), %r13
movq %r13, %rdi
callq 0x3cd94
leaq 0x60(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x3cc88
movq %rsp, %rdi
movq %r12, %rsi
callq 0x3cd94
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %rbp, %rsi
callq 0x3dc6a
movq %r13, %rdi
callq 0x3d7e0
movl $0x2, %ebp
jmp 0x50258
xorl %eax, %eax
retq
movzbl %r13b, %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/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 0x504f9
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 0x49efc
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 0x504b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x49654b(%rip), %rsi    # 0x4e6a60
leaq 0x8(%rsp), %rdi
callq 0x3ca36
movl 0x20(%r14), %eax
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
testl %eax, %eax
jle 0x50601
movsd %xmm0, (%rsp)
xorl %r13d, %r13d
leaq 0x20(%rsp), %r15
leaq 0x8(%rsp), %r12
xorl %ebp, %ebp
testq %rbp, %rbp
je 0x50562
movq 0x10(%r14), %rcx
testq %rcx, %rcx
movsd (%rsp), %xmm0
je 0x50569
movsd (%rcx,%rbp,8), %xmm2
jmp 0x50570
movsd (%rsp), %xmm0
jmp 0x5058f
xorps %xmm2, %xmm2
cvtsi2sd %ebp, %xmm2
testq %rcx, %rcx
je 0x5057d
movsd -0x8(%rcx,%rbp,8), %xmm1
jmp 0x50587
leal -0x1(%rbp), %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
subsd %xmm1, %xmm2
addsd %xmm2, %xmm0
decl %eax
cltq
cmpq %rax, %rbp
jge 0x505ce
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x505a9
movsd 0x8(%rax,%rbp,8), %xmm2
jmp 0x505b3
leal 0x1(%rbp), %ecx
xorps %xmm2, %xmm2
cvtsi2sd %ecx, %xmm2
testq %rax, %rax
je 0x505bf
movsd (%rax,%rbp,8), %xmm1
jmp 0x505c6
xorps %xmm1, %xmm1
cvtsi2sd %ebp, %xmm1
subsd %xmm1, %xmm2
addsd %xmm2, %xmm0
movq 0x8(%r14), %rsi
addq %r13, %rsi
movq %r15, %rdi
movsd %xmm0, (%rsp)
callq 0x3d470
movq %r12, %rdi
movq %r15, %rsi
callq 0x3d366
incq %rbp
movslq 0x20(%r14), %rax
addq $0x18, %r13
cmpq %rax, %rbp
jl 0x50548
movsd (%rsp), %xmm0
ucomisd 0x51bda(%rip), %xmm0    # 0xa21e8
jne 0x50672
jp 0x50672
leaq 0x496447(%rip), %rsi    # 0x4e6a60
leaq 0x8(%rsp), %rdi
callq 0x3cd94
cmpl $0x0, 0x20(%r14)
jle 0x5066d
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 0x3d366
movsd (%rsp), %xmm0
addsd 0x519dd(%rip), %xmm0    # 0xa2038
incq %r13
movslq 0x20(%r14), %rax
addq $0x18, %r12
cmpq %rax, %r13
jl 0x5063a
jmp 0x50672
movsd (%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x5068f
jp 0x5068f
leaq 0x4963db(%rip), %rsi    # 0x4e6a60
movq %rbx, %rdi
callq 0x3ca36
jmp 0x5069c
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3d492
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_O1/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 0x51975(%rip), %xmm0    # 0xa2040
jne 0x506db
jp 0x506db
movq (%r14), %rax
movq %r14, %rdi
callq *0x288(%rax)
addq $0x28, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x274f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5073c
movslq 0x20(%rdi), %rdx
cmpq $0x3, %rdx
jl 0x5073c
leal -0x2(%rdx), %eax
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x50720
movsd -0x10(%rcx,%rdx,8), %xmm1
jmp 0x50727
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
ucomisd %xmm1, %xmm0
jae 0x5073c
testq %rcx, %rcx
je 0x50738
xorl %esi, %esi
movl %eax, %edx
jmp 0x5073d
cvttsd2si %xmm0, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Polyline.cpp
// Function: gaps::BinarySearchForVertexIndex(gaps::R3Polyline const*, int, int, double)
static int
BinarySearchForVertexIndex(const R3Polyline *spline, int min_index, int max_index, RNScalar u)
{
  // Binary search for vertex index
  if (min_index == max_index) return min_index;
  if (spline->VertexParameter(min_index+1) > u) return min_index;
  if (spline->VertexParameter(max_index) < u) return max_index;
  int mid_index = (min_index + max_index)/2;
  RNScalar mid_u = spline->VertexParameter(mid_index);
  if (u == mid_u) return mid_index;
  else if (u < mid_u) return BinarySearchForVertexIndex(spline, min_index, mid_index-1, u);
  else return BinarySearchForVertexIndex(spline, mid_index, max_index, u);
}

// Assembly:
movl %esi, %eax
leal 0x1(%rax), %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
movslq %ecx, %rcx
cmpl %edx, %eax
je 0x507cc
movq 0x10(%rdi), %rsi
testq %rsi, %rsi
je 0x50760
movsd (%rsi,%rcx,8), %xmm2
jmp 0x50764
movapd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
ja 0x507cc
testq %rsi, %rsi
je 0x5077a
movslq %edx, %r8
movsd (%rsi,%r8,8), %xmm2
jmp 0x50781
xorps %xmm2, %xmm2
cvtsi2sd %edx, %xmm2
ucomisd %xmm2, %xmm0
ja 0x507ca
leal (%rdx,%rax), %r9d
movl %r9d, %r8d
shrl $0x1f, %r8d
addl %r9d, %r8d
sarl %r8d
testq %rsi, %rsi
je 0x507a8
movslq %r8d, %r9
movsd (%rsi,%r9,8), %xmm2
jmp 0x507b0
xorps %xmm2, %xmm2
cvtsi2sd %r8d, %xmm2
ucomisd %xmm0, %xmm2
jne 0x507b8
jnp 0x507cd
jbe 0x507c2
decl %r8d
movl %r8d, %edx
jmp 0x5074c
movl %r8d, %eax
jmp 0x5073f
movl %edx, %eax
retq
movl %r8d, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %edx
movq 0x10(%r14), %rcx
movslq %edx, %r12
testq %rcx, %rcx
je 0x5080b
movsd (%rcx,%r12,8), %xmm0
jmp 0x50812
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
movslq %eax, %rdx
testq %rcx, %rcx
je 0x50821
movsd (%rcx,%rdx,8), %xmm1
jmp 0x50825
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
leaq 0x95368(%rip), %rsi     # 0xe5b98
movsd (%rsi), %xmm1
movapd 0x517e4(%rip), %xmm2    # 0xa2020
xorpd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jb 0x50865
ucomisd %xmm0, %xmm1
jb 0x50865
leaq (%rdx,%rdx,2), %rsi
shlq $0x3, %rsi
addq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x3ca36
jmp 0x508fc
testq %rcx, %rcx
je 0x50871
movsd (%rcx,%rdx,8), %xmm1
jmp 0x50878
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movsd (%rsp), %xmm2
subsd %xmm1, %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, (%rsp)
leaq (%rdx,%rdx,2), %rsi
shlq $0x3, %rsi
addq 0x8(%r14), %rsi
leaq 0x50(%rsp), %r15
movq %r15, %rdi
callq 0x3ca36
leaq (%r12,%r12,2), %rsi
shlq $0x3, %rsi
addq 0x8(%r14), %rsi
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x3ca36
movsd 0x51774(%rip), %xmm0    # 0xa2038
subsd (%rsp), %xmm0
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3d470
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movsd (%rsp), %xmm0
callq 0x3d470
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3d42a
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3ca36
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 0x3ca36
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x5097c
movsd (%rax,%r15,8), %xmm0
jmp 0x50983
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
testq %rax, %rax
je 0x50990
movsd (%rax,%r13,8), %xmm1
jmp 0x50995
cvtsi2sd %r12d, %xmm1
ucomisd %xmm1, %xmm0
jae 0x509d5
leaq 0x40(%rsp), %r14
leaq 0x10(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %r14, %rdi
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, (%rsp)
callq 0x3cc88
movsd (%rsp), %xmm0
subsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3e200
jmp 0x509e4
leaq 0x57d04(%rip), %rsi     # 0xa86e0
movq %rbx, %rdi
callq 0x3d4ce
movq %rbx, %rax
addq $0x58, %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/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 0x50a17
callq 0xe5b0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x50a25
callq 0xe5b0
leaq 0x8(%rbx), %r15
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x50a37
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 0x3cd94
leaq 0x48(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x3cd94
leaq 0x8(%rsp), %rdi
callq 0x28348
movslq 0x20(%rbx), %rax
testq %rax, %rax
jle 0x50b23
shlq $0x3, %rax
leaq (%rax,%rax,2), %r15
movq %r15, %rdi
callq 0xe030
movq %rax, %r12
xorl %r13d, %r13d
leaq (%r12,%r13), %rdi
callq 0x3ca24
addq $0x18, %r13
cmpq %r13, %r15
jne 0x50aa7
movq %r12, 0x8(%rbx)
movslq 0x20(%rbx), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0xe030
movq %rax, 0x10(%rbx)
cmpl $0x0, 0x20(%rbx)
jle 0x50b23
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %rsi
addq %r15, %rsi
movq 0x8(%rbx), %rdi
addq %r15, %rdi
callq 0x3cd94
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 0x50aec
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 0x28348
jmp 0x50b51
movq %rax, %rbx
movq %r12, %rdi
movq %r15, %rsi
callq 0xe8c0
movq %rbx, %rdi
callq 0xe7e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x50b93
movq %rsi, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%rbx), %rdi
addq %r15, %rdi
movq %r14, %rsi
callq 0x3d342
incq %r12
movslq 0x20(%rbx), %rax
addq $0x18, %r15
cmpq %rax, %r12
jl 0x50b74
movaps 0x584d6(%rip), %xmm0    # 0xa9070
movups %xmm0, 0x30(%rbx)
movaps 0x584db(%rip), %xmm0    # 0xa9080
movups %xmm0, 0x50(%rbx)
movaps 0x584e0(%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_O1/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 0x3cd94
movaps 0x5848e(%rip), %xmm0    # 0xa9070
movups %xmm0, 0x30(%rbx)
movaps 0x58493(%rip), %xmm0    # 0xa9080
movups %xmm0, 0x50(%rbx)
movaps 0x58498(%rip), %xmm0    # 0xa9090
movups %xmm0, 0x40(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %r14
cmpq $0x0, 0x18(%rdi)
jne 0x50e30
movslq 0x20(%r14), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0xe030
movq %rax, 0x18(%r14)
movq 0x18(%r14), %rax
movslq %ebp, %rcx
movq %rbx, (%rax,%rcx,8)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9503d(%rip), %r14     # 0xe5e98
leaq 0x8(%r14), %rsi
callq 0x3cd94
leaq 0x48(%rbx), %rdi
addq $0x20, %r14
movq %r14, %rsi
callq 0x3cd94
cmpl $0x0, 0x20(%rbx)
jle 0x50eb3
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 0x3ca36
movq %r14, %rdi
movq %r15, %rsi
callq 0x27f0e
incq %r13
movslq 0x20(%rbx), %rax
addq $0x18, %r12
cmpq %rax, %r13
jl 0x50e89
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x50f22
xorl %r15d, %r15d
movq %rsp, %r14
xorl %r12d, %r12d
movq 0x8(%rbx), %rsi
addq %r15, %rsi
movq %r14, %rdi
callq 0x3ca36
movq %r14, %rdi
callq 0xe130
incq %r12
movslq 0x20(%rbx), %rax
addq $0x18, %r15
cmpq %rax, %r12
jl 0x50efb
callq 0xe5d0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3caec
xorl %ebx, %ebx
testl %eax, %eax
je 0x515a4
leaq 0x20(%r14), %rdi
leaq 0x20(%r15), %rsi
callq 0x3d77c
testl %eax, %eax
je 0x515a4
leaq 0x38(%r14), %rdi
leaq 0x38(%r15), %rsi
callq 0x3d77c
testl %eax, %eax
je 0x515a4
movsd 0x68(%r14), %xmm0
ucomisd 0x68(%r15), %xmm0
jne 0x515a4
jp 0x515a4
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_O1/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 %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x68(%rsi), %xmm0
minsd 0x70(%rsi), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x94829(%rip), %rsi     # 0xe5e98
callq 0x274f0
xorpd %xmm0, %xmm0
ucomisd 0x8(%rsp), %xmm0
ja 0x516a6
xorl %ebp, %ebp
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x51a36
movq %rbx, %rdi
movq %r15, %rsi
callq 0x27f0e
incl %ebp
cmpl $0x4, %ebp
jne 0x51687
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x28348
movq %r14, %rdi
callq 0xe7e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0x68(%rsi), %xmm0
movsd 0x70(%rsi), %xmm1
movapd %xmm0, %xmm3
minsd %xmm1, %xmm3
xorpd %xmm2, %xmm2
ucomisd %xmm3, %xmm2
ja 0x5170a
movq %rsi, %r14
addq $0x8, %r14
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jb 0x5171b
sqrtsd %xmm0, %xmm0
jmp 0x51720
leaq 0x9462f(%rip), %rsi     # 0xe5d40
movq %rbx, %rdi
callq 0x2708a
jmp 0x5172b
callq 0xe340
movq %rbx, %rdi
movq %r14, %rsi
callq 0x270d6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x94334(%rip), %r14     # 0xe6110
movq %r14, %rsi
callq 0x3cd94
leaq 0x20(%rbx), %rdi
leaq 0x18(%r14), %rsi
callq 0x3dc6a
leaq 0x38(%rbx), %rdi
leaq 0x30(%r14), %rsi
callq 0x3dc6a
leaq 0x50(%rbx), %rdi
addq $0x48, %r14
movq %r14, %rsi
callq 0x3dc6a
leaq 0x68(%rbx), %rdi
leaq 0x57bff(%rip), %rsi     # 0xa9a18
callq 0x6950a
leaq 0x80(%rbx), %rdi
leaq 0x9406c(%rip), %r14     # 0xe5e98
leaq 0x8(%r14), %rsi
callq 0x3cd94
addq $0x98, %rbx
addq $0x20, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3cd94
// File: /workspace/github_cpp_makefile_star2_O1/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 0x57fe4(%rip), %rax     # 0xa9fc8
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x49537b(%rip), %rbx    # 0x4e7370
leaq 0x495074(%rip), %r14    # 0x4e7070
leaq 0x494f6d(%rip), %r12    # 0x4e6f70
xorl %r13d, %r13d
leaq 0x18(%rsp), %r15
xorps %xmm0, %xmm0
cvtsi2sd %r13d, %xmm0
mulsd 0x8(%rsp), %xmm0
mulsd 0x570e7(%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 0x3ca26
movq %r14, %rdi
movq %r15, %rsi
callq 0x3cd94
movsd (%r14), %xmm0
movsd 0x4ffcf(%rip), %xmm2    # 0xa2038
addsd %xmm2, %xmm0
movsd 0x4ffbb(%rip), %xmm3    # 0xa2030
mulsd %xmm3, %xmm0
movsd 0x8(%r14), %xmm1
addsd %xmm2, %xmm1
mulsd %xmm3, %xmm1
movq %r15, %rdi
callq 0x68e2e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x68f66
incq %r13
addq $0x10, %rbx
addq $0x18, %r14
addq $0x8, %r12
cmpq $0x20, %r13
jne 0x5200b
movl $0x1, %eax
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/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 0x3d342
leaq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0x3bc30
movq (%r14), %rax
movq %r14, %rdi
callq *0x30(%rax)
testl %eax, %eax
jne 0x5241e
leaq 0x56d17(%rip), %rdi     # 0xa912e
xorl %eax, %eax
callq 0x72ad9
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_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x90a02(%rip), %rax     # 0xe3208
movq %rax, (%rdi)
leaq 0x18(%rdi), %r14
cmpl $0x0, 0x24(%rdi)
jle 0x52834
xorl %r15d, %r15d
movq (%r14), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x52828
movq (%rdi), %rax
callq *0x8(%rax)
incq %r15
movslq 0x24(%rbx), %rax
cmpq %rax, %r15
jl 0x52816
leaq 0x8(%rbx), %r15
cmpl $0x0, 0x14(%rbx)
jle 0x52863
xorl %r12d, %r12d
movq (%r15), %rax
movq (%rax,%r12,8), %rdi
testq %rdi, %rdi
je 0x52857
movl $0x68, %esi
callq 0xe450
incq %r12
movslq 0x14(%rbx), %rax
cmpq %rax, %r12
jl 0x52841
cmpl $0x0, 0x68(%rbx)
je 0x5287b
leaq 0x68(%rbx), %rsi
movq 0x9275c(%rip), %rax     # 0xe4fd0
movl $0x1, %edi
callq *(%rax)
leaq 0x28(%rbx), %rdi
callq 0x28348
movq %r14, %rdi
callq 0x70656
movq %r15, %rdi
callq 0x70656
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5528c
movq %rax, %rdi
callq 0x23e11
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, 0x14(%rdi)
jl 0x5292e
movq %rdi, %rbx
cmpl $0x2, 0x14(%rdi)
setge %bpl
jl 0x5292e
movq 0x8(%rbx), %rax
movq (%rax), %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0x46e1b
testl %eax, %eax
je 0x52927
movl $0x2, %r15d
movslq 0x14(%rbx), %rax
cmpq %rax, %r15
setl %bpl
jge 0x5292e
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x46e1b
incq %r15
testl %eax, %eax
jne 0x52903
xorl %eax, %eax
testb %bpl, %bpl
jne 0x52933
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, 0x24(%rdi)
jl 0x529b4
movq %rdi, %rbx
cmpl $0x2, 0x24(%rdi)
setge %bpl
jl 0x529b4
movq 0x18(%rbx), %rax
movq (%rax), %r14
addq $0x20, %r14
movq 0x18(%rbx), %rax
movq 0x8(%rax), %rsi
addq $0x20, %rsi
movq %r14, %rdi
callq 0x479a7
testl %eax, %eax
je 0x529ad
movl $0x2, %r15d
movslq 0x24(%rbx), %rax
cmpq %rax, %r15
setl %bpl
jge 0x529b4
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rsi
addq $0x20, %rsi
movq %r14, %rdi
callq 0x479a7
incq %r15
testl %eax, %eax
jne 0x52985
xorl %eax, %eax
testb %bpl, %bpl
jne 0x529b9
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x52a30
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 0x529f6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::Area() const
const RNArea R3TriangleArray::
Area(void) const
{
    // Return cumulative area of triangles
    RNArea area = 0.0;
    for (int i = 0; i < triangles.NEntries(); i++)
      area += triangles[i]->Area();
    return area;
}

// Assembly:
cmpl $0x0, 0x24(%rdi)
jle 0x52a82
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 *0x58(%rax)
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incq %r14
movslq 0x24(%rbx), %rax
cmpq %rax, %r14
jl 0x52a48
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x493fc8(%rip), %rsi    # 0x4e6a60
callq 0x3ca36
movl 0x14(%r14), %eax
testl %eax, %eax
jle 0x52ac4
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x3d366
incq %r15
movslq 0x14(%r14), %rax
cmpq %rax, %r15
jl 0x52aa8
cvtsi2sd %eax, %xmm0
movq %rbx, %rdi
callq 0x3d3e4
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::ClosestPoint(gaps::R3Point const&) const
const R3Point R3TriangleArray::
ClosestPoint(const R3Point& point) const
{
    // Find closest point
    R3Point closest_point = R3zero_point;
    RNLength closest_dd = RN_INFINITY * RN_INFINITY;
    for (int i = 0; i < triangles.NEntries(); i++) {
      R3Triangle *triangle = triangles.Kth(i);
      R3Point p = triangle->ClosestPoint(point);
      RNLength dd = R3SquaredDistance(p, point);
      if (dd < closest_dd) {
        closest_point = p;
        closest_dd = dd;
      }
    }
        
    // Return closest point
    return closest_point;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x493f69(%rip), %rsi    # 0x4e6a60
callq 0x3ca36
cmpl $0x0, 0x24(%r15)
jle 0x52b69
leaq 0x9309e(%rip), %rax     # 0xe5ba8
movsd (%rax), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, (%rsp)
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movq 0x18(%r15), %rax
movq (%rax,%r13,8), %rsi
movq (%rsi), %rax
movq %r12, %rdi
movq %rbx, %rdx
callq *0x70(%rax)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x49ed3
movapd %xmm0, %xmm1
movsd (%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x52b5d
movq %r14, %rdi
movq %r12, %rsi
movsd %xmm1, (%rsp)
callq 0x3cd94
incq %r13
movslq 0x24(%r15), %rax
cmpq %rax, %r13
jl 0x52b1f
movq %r14, %rax
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/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::FurthestPoint(gaps::R3Point const&) const
const R3Point R3TriangleArray::
FurthestPoint(const R3Point& point) const
{
    // Find furthest point
    R3Point furthest_point = R3zero_point;
    RNLength furthest_dd = 0;
    for (int i = 0; i < vertices.NEntries(); i++) {
      R3TriangleVertex *vertex = vertices.Kth(i);
      R3Point p = vertex->Position();
      RNLength dd = R3SquaredDistance(p, point);
      if (dd > furthest_dd) {
        furthest_point = p;
        furthest_dd = dd;
      }
    }

    // Return furthest point
    return furthest_point;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x493ec9(%rip), %rsi    # 0x4e6a60
callq 0x3ca36
cmpl $0x0, 0x14(%r15)
jle 0x52bf2
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movq 0x8(%r15), %rax
movq (%rax,%r13,8), %rsi
movq %r12, %rdi
callq 0x3ca36
movq %r12, %rdi
movq %rbx, %rsi
callq 0x49ed3
ucomisd (%rsp), %xmm0
jbe 0x52be6
movq %r14, %rdi
movq %r12, %rsi
movsd %xmm0, (%rsp)
callq 0x3cd94
incq %r13
movslq 0x14(%r15), %rax
cmpq %rax, %r13
jl 0x52bb4
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::Flip()
void R3TriangleArray::
Flip (void)
{
    // Flip the triangles
    for (int i = 0; i < triangles.NEntries(); i++)
      triangles[i]->Flip();

    // Update
    Update();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x24(%rdi)
jle 0x52e15
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
movq (%rdi), %rax
callq *0x220(%rax)
incq %r14
movslq 0x24(%rbx), %rax
cmpq %rax, %r14
jl 0x52df8
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x248(%rax)
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::Mirror(gaps::R3Plane const&)
void R3TriangleArray::
Mirror (const R3Plane& plane)
{
    // Mirror vertices
    for (int i = 0; i < vertices.NEntries(); i++) 
      vertices[i]->Mirror(plane);

    // Update the triangles
    for (int i = 0; i < triangles.NEntries(); i++)
      triangles[i]->Update();

    // Update the bounding box
    Update();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x14(%rdi)
jle 0x52e58
movq %rsi, %r14
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
callq 0x54432
incq %r15
movslq 0x14(%rbx), %rax
cmpq %rax, %r15
jl 0x52e3c
cmpl $0x0, 0x24(%rbx)
jle 0x52e7e
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
movq (%rdi), %rax
callq *0x250(%rax)
incq %r14
movslq 0x24(%rbx), %rax
cmpq %rax, %r14
jl 0x52e61
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x248(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::Transform(gaps::R3Transformation const&)
void R3TriangleArray::
Transform (const R3Transformation& transformation) 
{
    // Transform vertices
    for (int i = 0; i < vertices.NEntries(); i++) 
      vertices[i]->Transform(transformation);

    // Update the triangles
    for (int i = 0; i < triangles.NEntries(); i++)
      triangles[i]->Update();

    // Check if need to flip triangles
    if (transformation.IsMirrored()) Flip();

    // Update the bounding box
    Update();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x14(%rdi)
jle 0x52ec0
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
callq 0x54458
incq %r15
movslq 0x14(%rbx), %rax
cmpq %rax, %r15
jl 0x52ea4
cmpl $0x0, 0x24(%rbx)
jle 0x52ee6
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
callq *0x250(%rax)
incq %r15
movslq 0x24(%rbx), %rax
cmpq %rax, %r15
jl 0x52ec9
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
testl %eax, %eax
je 0x52eff
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x218(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x248(%rax)
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::MoveVertex(gaps::R3TriangleVertex*, gaps::R3Point const&)
void R3TriangleArray::
MoveVertex(R3TriangleVertex *vertex, const R3Point& position)
{
    // Move vertex
    vertex->SetPosition(position);

    // Update triangles
    for (int i = 0; i < triangles.NEntries(); i++) {
      R3Triangle *triangle = triangles.Kth(i);
      for (int j = 0; j < 3; j++) {
        if (triangle->Vertex(i) == vertex) {
          triangle->Update();
          break;
        }
      }
    }

    // Update
    Update();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x3cd94
cmpl $0x0, 0x24(%rbx)
jle 0x537e3
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
cmpq %r14, 0x8(%rdi,%r15,8)
jne 0x537d7
movq (%rdi), %rax
callq *0x250(%rax)
incq %r15
movslq 0x24(%rbx), %rax
cmpq %rax, %r15
jl 0x537bf
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x248(%rax)
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::Update()
void R3TriangleArray::
Update(void)
{
  // Mark vertices as shared
  for (int i = 0; i < vertices.NEntries(); i++) {
    R3TriangleVertex *v = vertices.Kth(i);
    v->SetSharedFlag();
  }
    
  // Recompute bounding box
  bbox = R3null_box;
  for (int i = 0; i < vertices.NEntries(); i++) {
    R3TriangleVertex *v = vertices.Kth(i);
    bbox.Union(v->Position());
  }

  // Recompute flags
  flags.Add(R3_EVERYTHING_DRAW_FLAGS);
  for (int i = 0; i < vertices.NEntries(); i++) {
    R3TriangleVertex *v = vertices.Kth(i);
    RNFlags vertex_flags = v->Flags();
    if (!(vertex_flags[R3_VERTEX_NORMALS_DRAW_FLAG]))
      flags.Remove(R3_VERTEX_NORMALS_DRAW_FLAG);
    if (!(vertex_flags[R3_VERTEX_COLORS_DRAW_FLAG]))
      flags.Remove(R3_VERTEX_COLORS_DRAW_FLAG);
    if (!(vertex_flags[R3_VERTEX_TEXTURE_COORDS_DRAW_FLAG]))
      flags.Remove(R3_VERTEX_TEXTURE_COORDS_DRAW_FLAG);
  }

  // Invalidate VBO
  InvalidateVBO();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0x14(%rdi), %rax
testq %rax, %rax
jle 0x53ab9
movq 0x8(%rbx), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
orq $0x10000, 0x58(%rsi)    # imm = 0x10000
incq %rdx
cmpq %rdx, %rax
jne 0x53aa5
leaq 0x30(%rbx), %rdi
leaq 0x923d4(%rip), %r14     # 0xe5e98
leaq 0x8(%r14), %rsi
callq 0x3cd94
leaq 0x48(%rbx), %rdi
addq $0x20, %r14
movq %r14, %rsi
callq 0x3cd94
movl 0x14(%rbx), %ecx
testl %ecx, %ecx
jle 0x53b07
leaq 0x28(%rbx), %r14
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x27f0e
incq %r15
movslq 0x14(%rbx), %rcx
cmpq %rcx, %r15
jl 0x53aeb
orw $0x7777, 0x60(%rbx)     # imm = 0x7777
testl %ecx, %ecx
jle 0x53b70
movq 0x8(%rbx), %rax
movq 0x60(%rbx), %rsi
movl %ecx, %ecx
xorl %edx, %edx
movq (%rax,%rdx,8), %rdi
movl 0x58(%rdi), %edi
movq %rsi, %r8
andq $-0x101, %r8            # imm = 0xFEFF
btl $0x8, %edi
cmovbq %rsi, %r8
movq %r8, %r9
andq $-0x401, %r9            # imm = 0xFBFF
btl $0xa, %edi
cmovbq %r8, %r9
movq %r9, %rsi
andq $-0x201, %rsi           # imm = 0xFDFF
btl $0x9, %edi
cmovbq %r9, %rsi
notl %edi
testl $0x700, %edi            # imm = 0x700
je 0x53b68
movq %rsi, 0x60(%rbx)
incq %rdx
cmpq %rdx, %rcx
jne 0x53b1d
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x250(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::R3Triangle(gaps::R3Triangle const&)
R3Triangle::
R3Triangle(const R3Triangle& triangle)
  : plane(triangle.plane),
    bbox(triangle.bbox),
    flags(triangle.flags),
    mark(0)
{
    // Copy vertices 
    if (!triangle.v[0] || triangle.v[0]->Flags()[R3_VERTEX_SHARED_FLAG]) v[0] = triangle.v[0];
    else v[0] = new R3TriangleVertex(*(triangle.v[0]));
    if (!triangle.v[1] || triangle.v[1]->Flags()[R3_VERTEX_SHARED_FLAG]) v[1] = triangle.v[1];
    else v[1] = new R3TriangleVertex(*(triangle.v[1]));
    if (!triangle.v[2] || triangle.v[2]->Flags()[R3_VERTEX_SHARED_FLAG]) v[2] = triangle.v[2];
    else v[2] = new R3TriangleVertex(*(triangle.v[2]));

    // Update the triangle
    Update();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0x55280
leaq 0x8ef89(%rip), %rax     # 0xe3498
movq %rax, (%rbx)
leaq 0x20(%rbx), %rdi
leaq 0x20(%r15), %rsi
callq 0x3b51a
leaq 0x40(%rbx), %r14
leaq 0x40(%r15), %rsi
movq %r14, %rdi
callq 0x274f0
movq 0x78(%r15), %rax
movq %rax, 0x78(%rbx)
movl $0x0, 0x80(%rbx)
movq 0x8(%r15), %r12
testq %r12, %r12
je 0x5456d
testb $0x1, 0x5a(%r12)
jne 0x5456d
movl $0x68, %edi
callq 0xe440
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x540c2
movq %r13, %r12
movq %r12, 0x8(%rbx)
movq 0x10(%r15), %r12
testq %r12, %r12
je 0x5459d
testb $0x1, 0x5a(%r12)
jne 0x5459d
movl $0x68, %edi
callq 0xe440
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x540c2
movq %r13, %r12
movq %r12, 0x10(%rbx)
movq 0x18(%r15), %r15
testq %r15, %r15
je 0x545cc
testb $0x1, 0x5a(%r15)
jne 0x545cc
movl $0x68, %edi
callq 0xe440
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x540c2
movq %r12, %r15
movq %r15, 0x18(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x250(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
movl $0x68, %esi
movq %r12, %rdi
jmp 0x54600
jmp 0x545f5
movq %rax, %r15
movl $0x68, %esi
movq %r13, %rdi
callq 0xe450
jmp 0x5460a
movq %rax, %r15
movq %r14, %rdi
callq 0x28348
jmp 0x54617
movq %rax, %r15
movq %rbx, %rdi
callq 0x5528c
movq %r15, %rdi
callq 0xe7e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::IsFinite() const
const RNBoolean R3Triangle::
IsFinite (void) const
{
    // Check each point
    if (!(v[0]->Position().IsFinite())) return FALSE;
    if (!(v[1]->Position().IsFinite())) return FALSE;
    if (!(v[2]->Position().IsFinite())) return FALSE;
    return TRUE;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x3ca72
xorl %ebx, %ebx
testl %eax, %eax
je 0x5487d
movq 0x10(%r14), %rdi
callq 0x3ca72
testl %eax, %eax
je 0x5487d
movq 0x18(%r14), %rdi
callq 0x3ca72
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop