LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Relate.cpp
// Function: gaps::R2InteriorAngle(gaps::R2Vector const&, gaps::R2Vector const&)
RNAngle 
R2InteriorAngle(const R2Vector& vector1, const R2Vector& vector2)
{
    // Return angle between vectors
    RNScalar d1 = vector1.Length();
    if (RNIsZero(d1)) return 0.0;
    RNScalar d2 = vector2.Length();
    if (RNIsZero(d2)) return 0.0;
    RNScalar cosine = vector1.Dot(vector2) / (d1 * d2);
    assert(RNIsGreaterOrEqual(cosine, -1.0) && RNIsLessOrEqual(cosine, 1.0));
    if (cosine >= 1.0) return 0.0;
    else if (cosine <= -1.0) return RN_PI;
    else return acos(cosine); 
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xc3d60
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
leaq 0xab275(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x36b80
cmpl $0x0, %eax
je 0xcd287
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0xcd335
movq 0x20(%rsp), %rdi
callq 0xc3d60
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
leaq 0xab23c(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x36b80
cmpl $0x0, %eax
je 0xcd2bd
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0xcd335
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xc3f40
movsd 0x18(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd 0x65d18(%rip), %xmm1    # 0x133008
ucomisd %xmm1, %xmm0
jb 0xcd301
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0xcd335
movsd 0x65d0f(%rip), %xmm0    # 0x133018
ucomisd 0x8(%rsp), %xmm0
jb 0xcd324
leaq 0x695c0(%rip), %rax     # 0x1368d8
movsd (%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0xcd335
movsd 0x8(%rsp), %xmm0
callq 0xf470
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Relate.cpp
// Function: gaps::R2IntersectionArea(gaps::R2Box const&, gaps::R2Box const&)
RNArea 
R2IntersectionArea(const R2Box& box1, const R2Box& box2)
{
  R2Box intersection(box1);
  intersection.Intersect(box2);
  if (intersection.IsEmpty()) return 0;
  return intersection.Area();
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xbd3e0
movq 0x10(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0xbe7f0
jmp 0xcd433
leaq 0x28(%rsp), %rdi
callq 0xa36c0
movl %eax, 0xc(%rsp)
jmp 0xcd443
movl 0xc(%rsp), %eax
cmpl $0x0, %eax
je 0xcd479
xorps %xmm0, %xmm0
movsd %xmm0, 0x60(%rsp)
movl $0x1, 0x18(%rsp)
jmp 0xcd49d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x6bc50
jmp 0xcd4b2
leaq 0x28(%rsp), %rdi
callq 0xbe280
movsd %xmm0, (%rsp)
jmp 0xcd48a
movsd (%rsp), %xmm0
movsd %xmm0, 0x60(%rsp)
movl $0x1, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x6bc50
movsd 0x60(%rsp), %xmm0
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xf890
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Relate.cpp
// Function: gaps::R2Abuts(gaps::R2Box const&, gaps::R2Box const&)
RNBoolean 
R2Abuts(const R2Box& box1, const R2Box& box2) 
{
    // Return whether box1 abuts box2
    if (!R2Intersects(box1, box2)) return FALSE;
    if (RNIsEqual(box1.XMin(), box2.XMax())) return TRUE;
    if (RNIsEqual(box1.XMax(), box2.XMin())) return TRUE;
    if (RNIsEqual(box1.YMin(), box2.YMax())) return TRUE;
    if (RNIsEqual(box1.YMax(), box2.YMin())) return TRUE;
    return FALSE;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xa5640
cmpl $0x0, %eax
jne 0xcd8a3
movl $0x0, 0x34(%rsp)
jmp 0xcd9b7
movq 0x28(%rsp), %rdi
callq 0xa3750
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0xa3790
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
leaq 0xaac13(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x37170
cmpl $0x0, %eax
je 0xcd8e8
movl $0x1, 0x34(%rsp)
jmp 0xcd9b7
movq 0x28(%rsp), %rdi
callq 0xa3790
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0xa3750
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
leaq 0xaabce(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x37170
cmpl $0x0, %eax
je 0xcd92d
movl $0x1, 0x34(%rsp)
jmp 0xcd9b7
movq 0x28(%rsp), %rdi
callq 0xa3770
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0xa37b0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
leaq 0xaab89(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x37170
cmpl $0x0, %eax
je 0xcd96f
movl $0x1, 0x34(%rsp)
jmp 0xcd9b7
movq 0x28(%rsp), %rdi
callq 0xa37b0
movsd %xmm0, (%rsp)
movq 0x20(%rsp), %rdi
callq 0xa3770
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
leaq 0xaab49(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x37170
cmpl $0x0, %eax
je 0xcd9af
movl $0x1, 0x34(%rsp)
jmp 0xcd9b7
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Relate.cpp
// Function: gaps::R2Splits(gaps::R2Line const&, gaps::R2Span const&)
int 
R2Splits(const R2Line& line, const R2Span& span)
{
    // This is just a simple version 

    // Classify span
    // Result values: 0 = on, 1 = below, 2 = above, 3 = crossing
    RNScalar d1 = R2SignedDistance(line, span.Start());
    RNScalar d2 = R2SignedDistance(line, span.End());
    if (RNIsNegative(d1)) {
        if (RNIsPositive(d2)) return 3;
	else return 1;
    }
    else if (RNIsPositive(d1)) {
        if (RNIsNegative(d2)) return 3;
	else return 2;
    }
    else {
        if (RNIsNegative(d2)) return 1;
        else if (RNIsPositive(d2)) return 2;
	else return 0;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0xa3500
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xcb900
movsd %xmm0, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0xa3510
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xcb900
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
leaq 0xaaab9(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x38fd0
cmpl $0x0, %eax
je 0xcda6a
movsd 0x10(%rsp), %xmm0
leaq 0xaaa9e(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x36d50
cmpl $0x0, %eax
je 0xcda5d
movl $0x3, 0x34(%rsp)
jmp 0xcdb06
movl $0x1, 0x34(%rsp)
jmp 0xcdb06
movsd 0x18(%rsp), %xmm0
leaq 0xaaa69(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x36d50
cmpl $0x0, %eax
je 0xcdab4
movsd 0x10(%rsp), %xmm0
leaq 0xaaa4e(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x38fd0
cmpl $0x0, %eax
je 0xcdaaa
movl $0x3, 0x34(%rsp)
jmp 0xcdb06
movl $0x2, 0x34(%rsp)
jmp 0xcdb06
movsd 0x10(%rsp), %xmm0
leaq 0xaaa1f(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x38fd0
cmpl $0x0, %eax
je 0xcdad9
movl $0x1, 0x34(%rsp)
jmp 0xcdb06
movsd 0x10(%rsp), %xmm0
leaq 0xaa9fa(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x36d50
cmpl $0x0, %eax
je 0xcdafe
movl $0x2, 0x34(%rsp)
jmp 0xcdb06
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Align.cpp
// Function: gaps::R2Centroid(gaps::RNArray<gaps::R2Point*> const&, double const*)
R2Point 
R2Centroid(const RNArray<R2Point *>& points, const RNScalar *weights)
{
  // Compute center of mass
  R2Point centroid(0.0, 0.0);
  RNScalar total_weight = 0;
  for (int i = 0; i < points.NEntries(); i++) {
    RNScalar weight = (weights) ? weights[i] : 1;
    R2Point *point = points[i];
    centroid += *point * weight;
    total_weight += weight;
  }

  // Compute average
  if (total_weight > 0) centroid /= total_weight;

  // Return center of mass
  return centroid;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0xc3140
xorps %xmm0, %xmm0
movsd %xmm0, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x58(%rsp), %rdi
callq 0x13600
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0xce06d
cmpq $0x0, 0x50(%rsp)
je 0xcdffa
movq 0x50(%rsp), %rax
movslq 0x44(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rsp)
jmp 0xce009
movsd 0x65006(%rip), %xmm0    # 0x133008
movsd %xmm0, (%rsp)
jmp 0xce009
movsd (%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x58(%rsp), %rdi
movl 0x44(%rsp), %esi
callq 0xbd1e0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rsi
movsd 0x38(%rsp), %xmm0
leaq 0x20(%rsp), %rdi
callq 0xc3a60
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xc3430
movsd 0x38(%rsp), %xmm0
addsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0xcdfbc
movsd 0x48(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xce08c
movq 0x10(%rsp), %rdi
movsd 0x48(%rsp), %xmm0
callq 0xc3660
movq 0x18(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Align.cpp
// Function: gaps::R2AverageDistance(gaps::R2Point const&, gaps::RNArray<gaps::R2Point*> const&, double const*)
RNLength
R2AverageDistance(const R2Point& center, const RNArray<R2Point *>& points, const RNScalar *weights)
{
  // Compute sum of distances between a position on the surface and a center point
  RNScalar distance = 0.0;
  RNScalar total_weight = 0;
  for (int i = 0; i < points.NEntries(); i++) {
    RNScalar weight = (weights) ? weights[i] : 1;
    R2Point *point = points[i];
    distance += weight * R2Distance(*point, center);
    total_weight += weight;
  }

  // Compute average distance
  if (total_weight > 0) distance /= total_weight;

  // Return average distance
  return distance;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x48(%rsp), %rdi
callq 0x13600
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0xce823
cmpq $0x0, 0x40(%rsp)
je 0xce79c
movq 0x40(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0xce7ac
movsd 0x64864(%rip), %xmm0    # 0x133008
movsd %xmm0, 0x8(%rsp)
jmp 0xce7ac
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0xbd1e0
movq %rax, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0xcb540
movaps %xmm0, %xmm2
movsd (%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x20(%rsp), %xmm0
addsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xce75d
movsd 0x30(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xce848
movsd 0x30(%rsp), %xmm1
movsd 0x38(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x38(%rsp), %xmm0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Align.cpp
// Function: gaps::R2AlignError(gaps::RNArray<gaps::R2Point*> const&, gaps::RNArray<gaps::R2Point*> const&, gaps::R3Matrix const&, double const*)
RNScalar 
R2AlignError(const RNArray<R2Point *>& points1, const RNArray<R2Point *>& points2, 
  const R3Matrix& matrix, const RNScalar* weights)
{
  // Get number of points
  int count = points1.NEntries();
  if (points2.NEntries() < count) count = points2.NEntries();
  if (count == 0) return -1;

  // Compute sum of squared distances
  RNScalar ssd = 0;
  RNScalar total_weight = 0;
  for (int i = 0; i < count; i++) {
    RNScalar weight = (weights) ? weights[i] : 1;
    R2Point *point1 = points1[i];
    R2Point point2 = *(points2[i]);
    point2 = matrix * point2;
    R2Vector v = *point1 - point2;
    ssd += weight * v.Dot(v);
    total_weight += weight;
  }

  // Return RMSD
  if (total_weight == 0) return -1;
  else return sqrt(ssd / total_weight);
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq 0x88(%rsp), %rdi
callq 0x13600
movl %eax, 0x6c(%rsp)
movq 0x80(%rsp), %rdi
callq 0x13600
cmpl 0x6c(%rsp), %eax
jge 0xcec46
movq 0x80(%rsp), %rdi
callq 0x13600
movl %eax, 0x6c(%rsp)
cmpl $0x0, 0x6c(%rsp)
jne 0xcec63
movsd 0x643c3(%rip), %xmm0    # 0x133018
movsd %xmm0, 0x90(%rsp)
jmp 0xcedc5
xorps %xmm0, %xmm0
movsd %xmm0, 0x60(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x58(%rsp)
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
cmpl 0x6c(%rsp), %eax
jge 0xced87
cmpq $0x0, 0x70(%rsp)
je 0xcecaa
movq 0x70(%rsp), %rax
movslq 0x54(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0xcecba
movsd 0x64356(%rip), %xmm0    # 0x133008
movsd %xmm0, 0x8(%rsp)
jmp 0xcecba
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
movq 0x88(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0xbd1e0
movq %rax, 0x40(%rsp)
movq 0x80(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0xbd1e0
movq %rax, %rsi
leaq 0x30(%rsp), %rdi
callq 0xc3170
movq 0x78(%rsp), %rsi
leaq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0xc0f00
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xc33e0
movq 0x40(%rsp), %rsi
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0xc3830
movsd 0x48(%rsp), %xmm0
movsd %xmm0, (%rsp)
leaq 0x10(%rsp), %rsi
movq %rsi, %rdi
callq 0xc3f40
movaps %xmm0, %xmm2
movsd (%rsp), %xmm0
movsd 0x60(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x60(%rsp)
movsd 0x48(%rsp), %xmm0
addsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x58(%rsp)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0xcec7d
movsd 0x58(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xcedab
jp 0xcedab
movsd 0x64278(%rip), %xmm0    # 0x133018
movsd %xmm0, 0x90(%rsp)
jmp 0xcedc5
movsd 0x60(%rsp), %xmm0
divsd 0x58(%rsp), %xmm0
callq 0xf390
movsd %xmm0, 0x90(%rsp)
movsd 0x90(%rsp), %xmm0
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Arc.cpp
// Function: gaps::R2Arc::R2Arc(gaps::R2Point const&, double, double, double)
R2Arc::
R2Arc(const R2Point& center, RNLength radius, RNAngle theta1, RNAngle theta2)
    : circle(center, radius),
      start(theta1),
      stop(theta2)
{
    // Needed because don't know if RN_TWO_PI is initialized
    RNScalar TWO_PI = 2.0 * 3.14159265358979323846;
    while (start >= TWO_PI) start -= TWO_PI;
    while (start < 0.0) start += TWO_PI;
    while (stop >= (start + TWO_PI)) stop -= TWO_PI;
    while (stop < start) stop += TWO_PI;
    assert((0.0 <= start) && (start <= TWO_PI));
    assert((start <= stop) && (stop <= (start + TWO_PI)));
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movsd %xmm1, 0x28(%rsp)
movsd %xmm2, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xd0740
movq (%rsp), %rdi
leaq 0x9ea07(%rip), %rax     # 0x16e6d0
movq %rax, (%rdi)
addq $0x8, %rdi
movq 0x38(%rsp), %rsi
movsd 0x30(%rsp), %xmm0
callq 0xd0960
jmp 0xcfce2
movq (%rsp), %rax
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rax)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x30(%rax)
movsd 0x66b4c(%rip), %xmm0    # 0x136850
movsd %xmm0, 0x8(%rsp)
movq (%rsp), %rax
movsd 0x28(%rax), %xmm0
ucomisd 0x8(%rsp), %xmm0
jb 0xcfd51
movq (%rsp), %rax
movsd 0x8(%rsp), %xmm1
movsd 0x28(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rax)
jmp 0xcfd0a
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0xd0770
jmp 0xcfdde
jmp 0xcfd53
movq (%rsp), %rax
xorps %xmm0, %xmm0
ucomisd 0x28(%rax), %xmm0
jbe 0xcfd77
movq (%rsp), %rax
movsd 0x8(%rsp), %xmm0
addsd 0x28(%rax), %xmm0
movsd %xmm0, 0x28(%rax)
jmp 0xcfd53
jmp 0xcfd79
movq (%rsp), %rax
movsd 0x30(%rax), %xmm0
movsd 0x28(%rax), %xmm1
addsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jb 0xcfdad
movq (%rsp), %rax
movsd 0x8(%rsp), %xmm1
movsd 0x30(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rax)
jmp 0xcfd79
jmp 0xcfdaf
movq (%rsp), %rax
movsd 0x30(%rax), %xmm1
movsd 0x28(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xcfdd9
movq (%rsp), %rax
movsd 0x8(%rsp), %xmm0
addsd 0x30(%rax), %xmm0
movsd %xmm0, 0x30(%rax)
jmp 0xcfdaf
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xf890
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Arc.cpp
// Function: gaps::R2Arc::SetStartAngle(double)
void R2Arc::
SetStartAngle(RNAngle theta)
{
    // Set arc start angle
    start = theta;
    while (start >= RN_TWO_PI) start -= RN_TWO_PI;
    while (start < 0.0) start += RN_TWO_PI;
    while (stop >= (start + RN_TWO_PI)) { stop -= RN_TWO_PI; }
    while (stop < start) { stop += RN_TWO_PI; }
    assert((0.0 <= start) && (start <= RN_TWO_PI));
    assert((start <= stop) && (stop <= (start + RN_TWO_PI)));
}

// Assembly:
movq %rdi, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movsd -0x10(%rsp), %xmm0
movsd %xmm0, 0x28(%rax)
movq -0x18(%rsp), %rax
movsd 0x28(%rax), %xmm0
leaq 0x664f7(%rip), %rax     # 0x1368f8
ucomisd (%rax), %xmm0
jb 0xd0427
movq -0x18(%rsp), %rax
leaq 0x664e5(%rip), %rcx     # 0x1368f8
movsd (%rcx), %xmm1
movsd 0x28(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rax)
jmp 0xd03f0
jmp 0xd0429
movq -0x18(%rsp), %rax
xorps %xmm0, %xmm0
ucomisd 0x28(%rax), %xmm0
jbe 0xd0454
movq -0x18(%rsp), %rax
leaq 0x664b4(%rip), %rcx     # 0x1368f8
movsd (%rcx), %xmm0
addsd 0x28(%rax), %xmm0
movsd %xmm0, 0x28(%rax)
jmp 0xd0429
jmp 0xd0456
movq -0x18(%rsp), %rax
movsd 0x30(%rax), %xmm0
movsd 0x28(%rax), %xmm1
leaq 0x6648c(%rip), %rax     # 0x1368f8
addsd (%rax), %xmm1
ucomisd %xmm1, %xmm0
jb 0xd0496
movq -0x18(%rsp), %rax
leaq 0x66476(%rip), %rcx     # 0x1368f8
movsd (%rcx), %xmm1
movsd 0x30(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rax)
jmp 0xd0456
jmp 0xd0498
movq -0x18(%rsp), %rax
movsd 0x30(%rax), %xmm1
movsd 0x28(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xd04c9
movq -0x18(%rsp), %rax
leaq 0x6643f(%rip), %rcx     # 0x1368f8
movsd (%rcx), %xmm0
addsd 0x30(%rax), %xmm0
movsd %xmm0, 0x30(%rax)
jmp 0xd0498
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Arc.cpp
// Function: gaps::R2Arc::SetStopAngle(double)
void R2Arc::
SetStopAngle(RNAngle theta)
{
    // Set arc stop angle
    stop = theta;
    while (stop >= (start + RN_TWO_PI)) { stop -= RN_TWO_PI; }
    while (stop < start) { stop += RN_TWO_PI; }
    assert((0.0 <= start) && (start <= RN_TWO_PI));
    assert((start <= stop) && (stop <= (start + RN_TWO_PI)));
}

// Assembly:
movq %rdi, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movsd -0x10(%rsp), %xmm0
movsd %xmm0, 0x30(%rax)
movq -0x18(%rsp), %rax
movsd 0x30(%rax), %xmm0
movsd 0x28(%rax), %xmm1
leaq 0x663f2(%rip), %rax     # 0x1368f8
addsd (%rax), %xmm1
ucomisd %xmm1, %xmm0
jb 0xd0530
movq -0x18(%rsp), %rax
leaq 0x663dc(%rip), %rcx     # 0x1368f8
movsd (%rcx), %xmm1
movsd 0x30(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rax)
jmp 0xd04f0
jmp 0xd0532
movq -0x18(%rsp), %rax
movsd 0x30(%rax), %xmm1
movsd 0x28(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xd0563
movq -0x18(%rsp), %rax
leaq 0x663a5(%rip), %rcx     # 0x1368f8
movsd (%rcx), %xmm0
addsd 0x30(%rax), %xmm0
movsd %xmm0, 0x30(%rax)
jmp 0xd0532
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Circle.cpp
// Function: gaps::R2InitCircle()
int 
R2InitCircle()
{
    // Initialize circle angles and points 
    for (int i = 0; i < R2circle_npoints; i++) {
        R2circle_angles[i] = ((RNScalar) i * RN_TWO_PI) / (RNScalar) R2circle_npoints;
        R2circle_points[i] = R2Point(cos(R2circle_angles[i]), sin(R2circle_angles[i]));
    }

    /* Return success */
    return TRUE;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
cmpl $0x20, 0x24(%rsp)
jge 0xd0857
cvtsi2sdl 0x24(%rsp), %xmm0
leaq 0x66134(%rip), %rax     # 0x1368f8
mulsd (%rax), %xmm0
movsd 0x62a48(%rip), %xmm1    # 0x133218
divsd %xmm1, %xmm0
movslq 0x24(%rsp), %rcx
leaq 0x4aa820(%rip), %rax    # 0x57b000
movsd %xmm0, (%rax,%rcx,8)
movslq 0x24(%rsp), %rcx
leaq 0x4aa80f(%rip), %rax    # 0x57b000
movsd (%rax,%rcx,8), %xmm0
callq 0xf930
movsd %xmm0, 0x8(%rsp)
movslq 0x24(%rsp), %rcx
leaq 0x4aa7f3(%rip), %rax    # 0x57b000
movsd (%rax,%rcx,8), %xmm0
callq 0xf100
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
leaq 0x10(%rsp), %rdi
callq 0xc3140
movslq 0x24(%rsp), %rax
leaq 0x4aa8ca(%rip), %rdi    # 0x57b100
shlq $0x4, %rax
addq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0xc33e0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xd07ac
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Circle.cpp
// Function: gaps::R2Circle::Transform(gaps::R2Transformation const&)
void R2Circle::
Transform (const R2Transformation& transformation)
{
    // Transform center 
    center.Transform(transformation);

    // Scale radius 
    if (!transformation.IsIsotropic()) RNWarning("Circle transformed by anisotropic transformation");
    R2Vector v(R2ones_vector);
    v.Transform(transformation);
    radius *= v.Length() / RN_SQRT_TWO;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x8, %rdi
movq 0x18(%rsp), %rsi
callq 0xc3380
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x0, %eax
jne 0xd0c53
leaq 0x64e5a(%rip), %rdi     # 0x135aa6
movb $0x0, %al
callq 0xd5010
leaq 0x8(%rsp), %rdi
leaq 0x4aa249(%rip), %rsi    # 0x57aea8
callq 0xc3c60
movq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0xc4430
leaq 0x8(%rsp), %rdi
callq 0xc3d60
movq (%rsp), %rax
leaq 0x65c80(%rip), %rcx     # 0x136908
divsd (%rcx), %xmm0
mulsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/RNGrfx.cpp
// Function: gaps::RNInitGrfx()
int 
RNInitGrfx(void)
{
    // Check whether are already initialized 
    if ((RNgrfx_active_count++) > 0) return 1;

    // Initialize glew
#   ifdef GLEW_STATIC
        GLenum glew_status = glewInit();
        if (glew_status != GLEW_OK) {
            RNFail("Unable to initialize glew");
        }
#   endif
  
    // Initialize submodules 
    // ???

    // return OK status 
    return 1;
}

// Assembly:
pushq %rax
movl 0x4aa4a1(%rip), %eax    # 0x57b338
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x4aa496(%rip)    # 0x57b338
cmpl $0x0, %eax
jle 0xd0eb1
movl $0x1, 0x4(%rsp)
jmp 0xd0ed5
callq 0xf400
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
je 0xd0ecd
leaq 0x659da(%rip), %rdi     # 0x1368a0
movb $0x0, %al
callq 0xd4f30
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/RNGrfx.cpp
// Function: gaps::EncodePickColor(unsigned int, unsigned char, unsigned char*)
void
EncodePickColor(unsigned int index, unsigned char alpha, unsigned char color[4])
{
  // Pack index (after adding one to avoid zero)
  index++;
  color[0] = (index >> 0) & 0xFF;
  color[1] = (index >> 8) & 0xFF;
  color[2] = (index >> 16) & 0xFF;
  color[3] = alpha;
}

// Assembly:
movb %sil, %al
movl %edi, -0x4(%rsp)
movb %al, -0x5(%rsp)
movq %rdx, -0x10(%rsp)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0x0, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movb %cl, (%rax)
movl -0x4(%rsp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movb %cl, 0x1(%rax)
movl -0x4(%rsp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movb %cl, 0x2(%rax)
movb -0x5(%rsp), %cl
movq -0x10(%rsp), %rax
movb %cl, 0x3(%rax)
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/RNGrfx.cpp
// Function: gaps::DecodePickColor(unsigned char*, unsigned int*, unsigned char*)
void
DecodePickColor(unsigned char color[4], unsigned int *index, unsigned char *alpha)
{
  // Unpack index (and then subtract one)
  unsigned int k = 0;
  k |= color[0] << 0;
  k |= color[1] << 8;
  k |= color[2] << 16;
  if (alpha) *alpha = color[4];
  if (index) *index = k - 1;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movq -0x8(%rsp), %rax
movzbl (%rax), %eax
shll $0x0, %eax
orl -0x1c(%rsp), %eax
movl %eax, -0x1c(%rsp)
movq -0x8(%rsp), %rax
movzbl 0x1(%rax), %eax
shll $0x8, %eax
orl -0x1c(%rsp), %eax
movl %eax, -0x1c(%rsp)
movq -0x8(%rsp), %rax
movzbl 0x2(%rax), %eax
shll $0x10, %eax
orl -0x1c(%rsp), %eax
movl %eax, -0x1c(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0xd0fd9
movq -0x8(%rsp), %rax
movb 0x4(%rax), %cl
movq -0x18(%rsp), %rax
movb %cl, (%rax)
cmpq $0x0, -0x10(%rsp)
je 0xd0fef
movl -0x1c(%rsp), %ecx
subl $0x1, %ecx
movq -0x10(%rsp), %rax
movl %ecx, (%rax)
retq
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/RNGrfx.cpp
// Function: gaps::R2SetViewport(int, int, int, int)
void 
R2SetViewport(int xmin, int ymin, int xmax, int ymax)
{
    /* Update viewport */
    RNgrfx_viewport_xmin = xmin;
    RNgrfx_viewport_ymin = ymin;
    RNgrfx_viewport_xmax = xmax;
    RNgrfx_viewport_ymax = ymax;
    RNgrfx_viewport_xcenter = (RNgrfx_viewport_xmax + RNgrfx_viewport_xmin) / 2;
    RNgrfx_viewport_ycenter = (RNgrfx_viewport_ymax + RNgrfx_viewport_ymin) / 2;
    RNgrfx_viewport_width = RNgrfx_viewport_xmax - RNgrfx_viewport_xmin;
    RNgrfx_viewport_height = RNgrfx_viewport_ymax - RNgrfx_viewport_ymin;

    /* Update scale */
    RNgrfx_window_xscale = RNgrfx_viewport_width / RNgrfx_window_width;
    RNgrfx_window_yscale = RNgrfx_viewport_height / RNgrfx_window_height;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl %edx, -0xc(%rsp)
movl %ecx, -0x10(%rsp)
movl -0x4(%rsp), %eax
movl %eax, 0x4aa326(%rip)    # 0x57b330
movl -0x8(%rsp), %eax
movl %eax, 0x4aa320(%rip)    # 0x57b334
movl -0xc(%rsp), %eax
movl %eax, 0xa74b2(%rip)     # 0x1784d0
movl -0x10(%rsp), %eax
movl %eax, 0xa74ac(%rip)     # 0x1784d4
movl 0xa74a2(%rip), %eax     # 0x1784d0
addl 0x4aa2fc(%rip), %eax    # 0x57b330
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0xa7486(%rip)     # 0x1784c8
movl 0xa748c(%rip), %eax     # 0x1784d4
addl 0x4aa2e6(%rip), %eax    # 0x57b334
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0xa7470(%rip)     # 0x1784cc
movl 0xa746e(%rip), %eax     # 0x1784d0
subl 0x4aa2c8(%rip), %eax    # 0x57b330
movl %eax, 0xa7452(%rip)     # 0x1784c0
movl 0xa7460(%rip), %eax     # 0x1784d4
subl 0x4aa2ba(%rip), %eax    # 0x57b334
movl %eax, 0xa7444(%rip)     # 0x1784c4
cvtsi2ssl 0xa7438(%rip), %xmm0 # 0x1784c0
divss 0xa7418(%rip), %xmm0    # 0x1784a8
movss %xmm0, 0xa7408(%rip)    # 0x1784a0
cvtsi2ssl 0xa7424(%rip), %xmm0 # 0x1784c4
divss 0xa7404(%rip), %xmm0    # 0x1784ac
movss %xmm0, 0xa73f4(%rip)    # 0x1784a4
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/RNGrfx.cpp
// Function: gaps::R2SetWindow(float, float, float, float)
void 
R2SetWindow(float xmin, float ymin, float xmax, float ymax)
{
    /* Update window */
    RNgrfx_window_xmin = xmin;
    RNgrfx_window_ymin = ymin;
    RNgrfx_window_xmax = xmax;
    RNgrfx_window_ymax = ymax;
    RNgrfx_window_xcenter = (RNgrfx_window_xmax + RNgrfx_window_xmin) / 2.0;
    RNgrfx_window_ycenter = (RNgrfx_window_ymax + RNgrfx_window_ymin) / 2.0;
    RNgrfx_window_width = RNgrfx_window_xmax - RNgrfx_window_xmin;
    RNgrfx_window_height = RNgrfx_window_ymax - RNgrfx_window_ymin;

    /* Update scale */
    RNgrfx_window_xscale = RNgrfx_viewport_width / RNgrfx_window_width;
    RNgrfx_window_yscale = RNgrfx_viewport_height / RNgrfx_window_height;
}

// Assembly:
movss %xmm0, -0x4(%rsp)
movss %xmm1, -0x8(%rsp)
movss %xmm2, -0xc(%rsp)
movss %xmm3, -0x10(%rsp)
movss -0x4(%rsp), %xmm0
movss %xmm0, 0x4aa242(%rip)   # 0x57b328
movss -0x8(%rsp), %xmm0
movss %xmm0, 0x4aa238(%rip)   # 0x57b32c
movss -0xc(%rsp), %xmm0
movss %xmm0, 0xa73b6(%rip)    # 0x1784b8
movss -0x10(%rsp), %xmm0
movss %xmm0, 0xa73ac(%rip)    # 0x1784bc
movss 0xa73a0(%rip), %xmm0    # 0x1784b8
addss 0x4aa208(%rip), %xmm0   # 0x57b328
cvtss2sd %xmm0, %xmm0
movsd 0x620d4(%rip), %xmm1    # 0x133200
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xa7374(%rip)    # 0x1784b0
movss 0xa7378(%rip), %xmm0    # 0x1784bc
addss 0x4aa1e0(%rip), %xmm0   # 0x57b32c
cvtss2sd %xmm0, %xmm0
movsd 0x620a8(%rip), %xmm1    # 0x133200
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xa734c(%rip)    # 0x1784b4
movss 0xa7348(%rip), %xmm0    # 0x1784b8
subss 0x4aa1b0(%rip), %xmm0   # 0x57b328
movss %xmm0, 0xa7328(%rip)    # 0x1784a8
movss 0xa7334(%rip), %xmm0    # 0x1784bc
subss 0x4aa19c(%rip), %xmm0   # 0x57b32c
movss %xmm0, 0xa7314(%rip)    # 0x1784ac
cvtsi2ssl 0xa7320(%rip), %xmm0 # 0x1784c0
divss 0xa7300(%rip), %xmm0    # 0x1784a8
movss %xmm0, 0xa72f0(%rip)    # 0x1784a0
cvtsi2ssl 0xa730c(%rip), %xmm0 # 0x1784c4
divss 0xa72ec(%rip), %xmm0    # 0x1784ac
movss %xmm0, 0xa72dc(%rip)    # 0x1784a4
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/RNGrfx.cpp
// Function: gaps::R2ScaleWindow(float, float)
void 
R2ScaleWindow(float xscale, float yscale)
{
    /* Update window */
    RNgrfx_window_xmin = RNgrfx_window_xcenter - 0.5 * xscale * RNgrfx_window_width;
    RNgrfx_window_ymin = RNgrfx_window_ycenter - 0.5 * yscale * RNgrfx_window_height;
    RNgrfx_window_xmax = RNgrfx_window_xcenter + 0.5 * xscale * RNgrfx_window_width;
    RNgrfx_window_ymax = RNgrfx_window_ycenter + 0.5 * yscale * RNgrfx_window_height;
    RNgrfx_window_width = RNgrfx_window_xmax - RNgrfx_window_xmin;
    RNgrfx_window_height = RNgrfx_window_ymax - RNgrfx_window_ymin;

    /* Update scale */
    RNgrfx_window_xscale = RNgrfx_viewport_width / RNgrfx_window_width;
    RNgrfx_window_yscale = RNgrfx_viewport_height / RNgrfx_window_height;
}

// Assembly:
movss %xmm0, -0x4(%rsp)
movss %xmm1, -0x8(%rsp)
movss 0xa72cc(%rip), %xmm0    # 0x1784b0
cvtss2sd %xmm0, %xmm1
movss -0x4(%rsp), %xmm0
cvtss2sd %xmm0, %xmm2
movsd 0x61e16(%rip), %xmm0    # 0x133010
mulsd %xmm2, %xmm0
movss 0xa72a2(%rip), %xmm2    # 0x1784a8
cvtss2sd %xmm2, %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4aa0f3(%rip)   # 0x57b328
movss 0xa7277(%rip), %xmm0    # 0x1784b4
cvtss2sd %xmm0, %xmm1
movss -0x8(%rsp), %xmm0
cvtss2sd %xmm0, %xmm2
movsd 0x61dbd(%rip), %xmm0    # 0x133010
mulsd %xmm2, %xmm0
movss 0xa724d(%rip), %xmm2    # 0x1784ac
cvtss2sd %xmm2, %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4aa09e(%rip)   # 0x57b32c
movss 0xa721a(%rip), %xmm0    # 0x1784b0
cvtss2sd %xmm0, %xmm1
movss -0x4(%rsp), %xmm0
cvtss2sd %xmm0, %xmm2
movsd 0x61d64(%rip), %xmm0    # 0x133010
mulsd %xmm2, %xmm0
movss 0xa71f0(%rip), %xmm2    # 0x1784a8
cvtss2sd %xmm2, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xa71e8(%rip)    # 0x1784b8
movss 0xa71dc(%rip), %xmm0    # 0x1784b4
cvtss2sd %xmm0, %xmm1
movss -0x8(%rsp), %xmm0
cvtss2sd %xmm0, %xmm2
movsd 0x61d22(%rip), %xmm0    # 0x133010
mulsd %xmm2, %xmm0
movss 0xa71b2(%rip), %xmm2    # 0x1784ac
cvtss2sd %xmm2, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xa71aa(%rip)    # 0x1784bc
movss 0xa719e(%rip), %xmm0    # 0x1784b8
subss 0x4aa006(%rip), %xmm0   # 0x57b328
movss %xmm0, 0xa717e(%rip)    # 0x1784a8
movss 0xa718a(%rip), %xmm0    # 0x1784bc
subss 0x4a9ff2(%rip), %xmm0   # 0x57b32c
movss %xmm0, 0xa716a(%rip)    # 0x1784ac
cvtsi2ssl 0xa7176(%rip), %xmm0 # 0x1784c0
divss 0xa7156(%rip), %xmm0    # 0x1784a8
movss %xmm0, 0xa7146(%rip)    # 0x1784a0
cvtsi2ssl 0xa7162(%rip), %xmm0 # 0x1784c4
divss 0xa7142(%rip), %xmm0    # 0x1784ac
movss %xmm0, 0xa7132(%rip)    # 0x1784a4
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/RNGrfx.cpp
// Function: gaps::R2TranslateWindow(float, float)
void 
R2TranslateWindow(float xtranslate, float ytranslate)
{
    /* Update window */
    RNgrfx_window_xmin += xtranslate;
    RNgrfx_window_ymin += ytranslate;
    RNgrfx_window_xmax += xtranslate;
    RNgrfx_window_ymax += ytranslate;
    RNgrfx_window_xcenter = (RNgrfx_window_xmax + RNgrfx_window_xmin) / 2.0;
    RNgrfx_window_ycenter = (RNgrfx_window_ymax + RNgrfx_window_ymin) / 2.0;
}

// Assembly:
movss %xmm0, -0x4(%rsp)
movss %xmm1, -0x8(%rsp)
movss -0x4(%rsp), %xmm0
addss 0x4a9f8e(%rip), %xmm0   # 0x57b328
movss %xmm0, 0x4a9f86(%rip)   # 0x57b328
movss -0x8(%rsp), %xmm0
addss 0x4a9f7c(%rip), %xmm0   # 0x57b32c
movss %xmm0, 0x4a9f74(%rip)   # 0x57b32c
movss -0x4(%rsp), %xmm0
addss 0xa70f2(%rip), %xmm0    # 0x1784b8
movss %xmm0, 0xa70ea(%rip)    # 0x1784b8
movss -0x8(%rsp), %xmm0
addss 0xa70e0(%rip), %xmm0    # 0x1784bc
movss %xmm0, 0xa70d8(%rip)    # 0x1784bc
movss 0xa70cc(%rip), %xmm0    # 0x1784b8
addss 0x4a9f34(%rip), %xmm0   # 0x57b328
cvtss2sd %xmm0, %xmm0
movsd 0x61e00(%rip), %xmm1    # 0x133200
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xa70a0(%rip)    # 0x1784b0
movss 0xa70a4(%rip), %xmm0    # 0x1784bc
addss 0x4a9f0c(%rip), %xmm0   # 0x57b32c
cvtss2sd %xmm0, %xmm0
movsd 0x61dd4(%rip), %xmm1    # 0x133200
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xa7078(%rip)    # 0x1784b4
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/RNArray.cpp
// Function: gaps::RNVArray::operator=(gaps::RNVArray const&)
RNVArray& RNVArray::
operator=(const RNVArray& array)
{
    // Empty array
    Empty();

    // Copy array of entries
    if (array.nentries > 0) {
	// Allocate memory for entries
	Resize(array.nentries);
	
	// Copy entries from array
	for (int i = 0; i < array.nentries; i++) 
            entries[i] = array.entries[i];

	// Update number of entries
	nentries = array.nentries;
    }

    // Return array
    return *this;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
callq 0xd1d30
movq 0x18(%rsp), %rax
cmpl $0x0, 0xc(%rax)
jle 0xd1931
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0xc(%rax), %esi
callq 0xd1a80
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jge 0xd1921
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x14(%rsp), %rdx
movq (%rcx,%rdx,8), %rdx
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xd18e4
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/RNArray.cpp
// Function: gaps::RNVArray::FindEntry(void const*) const
RNArrayEntry *RNVArray::
FindEntry(const void *data) const
{
    // Search for entry matching data
    for (int i = 0; i < nentries; i++) 
        if (entries[i] == data) return &entries[i];

    // Entry was not found
    return NULL;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movl $0x0, -0x1c(%rsp)
movq -0x28(%rsp), %rcx
movl -0x1c(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0xd19dc
movq -0x28(%rsp), %rax
movq (%rax), %rax
movslq -0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rsp), %rax
jne 0xd19cd
movq -0x28(%rsp), %rax
movq (%rax), %rax
movslq -0x1c(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
jmp 0xd19e5
jmp 0xd19cf
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0xd198c
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/RNArray.cpp
// Function: gaps::RNVArray::InternalInsert(void*, int)
RNArrayEntry *RNVArray::
InternalInsert(void *data, int k)
{
    // Make sure there is enough storage for new entry
    Resize(nentries+1);

    // Increment number of entries
    nentries++;

    // Shift entries up one notch 
    if (k < (nentries-1)) Shift(k, 0, 1);

    // Copy data into kth entry
    entries[k] = data;

    // Return entry
    return &entries[k];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0xc(%rdi), %esi
addl $0x1, %esi
callq 0xd1a80
movq 0x8(%rsp), %rcx
movl 0xc(%rcx), %eax
addl $0x1, %eax
movl %eax, 0xc(%rcx)
movl 0x14(%rsp), %eax
movl 0xc(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xd1a48
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xd1bb0
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rsi
movq (%rax), %rcx
movslq 0x14(%rsp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/RNArray.cpp
// Function: gaps::RNVArray::Resize(int)
void RNVArray::
Resize(int length)
{
    // Check if length is valid
    assert(length >= nentries);
    assert(nentries <= nallocated);

    // Check if are growing array
    if (length > nallocated) {
	// Adjust length to be next greater power of 2
	int tmplength = RN_ARRAY_MIN_ALLOCATED;
	while (tmplength < length) tmplength *= 2;
	length = tmplength;

	// Allocate new entries
	RNArrayEntry *newentries = NULL;
	if (length > 0) {
	    newentries = (RNArrayEntry *) malloc(length * sizeof(RNArrayEntry));
	    assert(newentries);
	}

	// Copy old entries into new entries
	if (nentries > 0) {
	    assert(entries);
	    assert(newentries);
	    for (int i = 0; i < nentries; i++)
                newentries[i] = entries[i];
	}
 
	// Zero remaining new entries
	if (nentries < length) {
	    assert(newentries);
	    for (int i = nentries; i < length; i++)
                newentries[i] = NULL;
	}

	// Replace entries
	if (entries) free(entries);
	entries = newentries;

	// Update nallocated
	nallocated = length;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x8(%rcx), %eax
jle 0xd1ba4
movl $0x1, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0xd1ac1
movl 0x18(%rsp), %eax
shll %eax
movl %eax, 0x18(%rsp)
jmp 0xd1aab
movl 0x18(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq $0x0, 0x10(%rsp)
cmpl $0x0, 0x1c(%rsp)
jle 0xd1aec
movslq 0x1c(%rsp), %rdi
shlq $0x3, %rdi
callq 0xf6a0
movq %rax, 0x10(%rsp)
movq (%rsp), %rax
cmpl $0x0, 0xc(%rax)
jle 0xd1b38
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0xd1b36
movq (%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xd1afe
jmp 0xd1b38
movq (%rsp), %rax
movl 0xc(%rax), %eax
cmpl 0x1c(%rsp), %eax
jge 0xd1b7b
movq (%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0xd1b79
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xd1b50
jmp 0xd1b7b
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0xd1b91
movq (%rsp), %rax
movq (%rax), %rdi
callq 0xf5f0
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movl 0x1c(%rsp), %ecx
movl %ecx, 0x8(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/RNArray.cpp
// Function: gaps::RNVArray::Shift(int, int, int)
void RNVArray::
Shift(int start, int length, int delta)
{
    /* Compute number of entries to shift */
    if ((delta < 0) && (start < -delta)) start = -delta;
    int nshift = nentries - start;
    if (delta > 0) nshift -= delta;
    if (nshift <= 0) return;
    if ((length > 0) && (length < nshift)) nshift = length;

    /* Shift array entries */
    if (delta < 0) {
        for (int i = start; i < (start + nshift); i++) {
	    entries[i+delta]=entries[i];
	}
    }
    else if (delta > 0) {
        for (int i = (start + nshift - 1); i >= start; i--) {
	    entries[i+delta]=entries[i];
	}
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
cmpl $0x0, -0x14(%rsp)
jge 0xd1bea
movl -0xc(%rsp), %eax
xorl %ecx, %ecx
subl -0x14(%rsp), %ecx
cmpl %ecx, %eax
jge 0xd1bea
xorl %eax, %eax
subl -0x14(%rsp), %eax
movl %eax, -0xc(%rsp)
movq -0x28(%rsp), %rax
movl 0xc(%rax), %eax
subl -0xc(%rsp), %eax
movl %eax, -0x18(%rsp)
cmpl $0x0, -0x14(%rsp)
jle 0xd1c0f
movl -0x14(%rsp), %ecx
movl -0x18(%rsp), %eax
subl %ecx, %eax
movl %eax, -0x18(%rsp)
cmpl $0x0, -0x18(%rsp)
jg 0xd1c1b
jmp 0xd1cd9
cmpl $0x0, -0x10(%rsp)
jle 0xd1c34
movl -0x10(%rsp), %eax
cmpl -0x18(%rsp), %eax
jge 0xd1c34
movl -0x10(%rsp), %eax
movl %eax, -0x18(%rsp)
cmpl $0x0, -0x14(%rsp)
jge 0xd1c85
movl -0xc(%rsp), %eax
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movl -0xc(%rsp), %ecx
addl -0x18(%rsp), %ecx
cmpl %ecx, %eax
jge 0xd1c83
movq -0x28(%rsp), %rax
movq (%rax), %rcx
movslq -0x1c(%rsp), %rdx
movq (%rcx,%rdx,8), %rdx
movq (%rax), %rax
movl -0x1c(%rsp), %ecx
addl -0x14(%rsp), %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0xd1c43
jmp 0xd1cd9
cmpl $0x0, -0x14(%rsp)
jle 0xd1cd7
movl -0xc(%rsp), %eax
addl -0x18(%rsp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rsp)
movl -0x20(%rsp), %eax
cmpl -0xc(%rsp), %eax
jl 0xd1cd5
movq -0x28(%rsp), %rax
movq (%rax), %rcx
movslq -0x20(%rsp), %rdx
movq (%rcx,%rdx,8), %rdx
movq (%rax), %rax
movl -0x20(%rsp), %ecx
addl -0x14(%rsp), %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x20(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0xd1c9b
jmp 0xd1cd7
jmp 0xd1cd9
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/RNArray.cpp
// Function: gaps::RNVArray::Empty(int)
void RNVArray::
Empty(RNBoolean deallocate)
{
    // Remove all entries from array
    Truncate(0);

    // Deallocate memory
    if (deallocate) {
        if (entries) delete entries;
        entries = NULL;
        nallocated = 0;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
xorl %esi, %esi
callq 0xd1da0
cmpl $0x0, 0x1c(%rsp)
je 0xd1d97
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0xd1d84
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xd1d82
movq 0x8(%rsp), %rdi
movl $0x8, %esi
callq 0xf4d0
jmp 0xd1d84
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movl $0x0, 0x8(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/RNArray.cpp
// Function: gaps::RNVArray::Reverse(int, int)
void RNVArray::
Reverse(int start, int length)
{
    /* Compute number of entries to reverse */
    int nreverse = nentries - start;
    if (nreverse <= 0) return;
    if ((length > 0) && (length < nreverse)) nreverse = length;
    if (nreverse <= 0) return;

    // Reverse length at start
    int i, j;
    for (i = start, j = start + nreverse - 1; i < j; i++, j--) {
        Swap(i, j);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0xc(%rax), %eax
subl 0x1c(%rsp), %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jg 0xd1e4e
jmp 0xd1eba
cmpl $0x0, 0x18(%rsp)
jle 0xd1e67
movl 0x18(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0xd1e67
movl 0x18(%rsp), %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jg 0xd1e70
jmp 0xd1eba
movl 0x1c(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x1c(%rsp), %eax
addl 0x14(%rsp), %eax
subl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0xd1eba
movq (%rsp), %rdi
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
callq 0xd1ec0
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xd1e87
addq $0x28, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/RNArray.cpp
// Function: gaps::RNVArray::Append(gaps::RNVArray const&)
void RNVArray::
Append(const RNVArray& array)
{
    // Resize first
    Resize(NEntries() + array.NEntries());

    // Insert entries of array
    for (int i = 0; i < array.NEntries(); i++)
	Insert(array.Kth(i));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x13600
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rdi
callq 0x13600
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdi
addl %eax, %esi
callq 0xd1a80
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x13600
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jge 0xd1f95
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x139c0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x3c740
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xd1f53
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/RNArray.cpp
// Function: gaps::RNVArray::BubbleSort(int (*)(void*, void*, void*), void*)
void RNVArray::
BubbleSort(int (*compare)(void *data1, void *data2, void *appl), void *appl)
{
    // Sort vector entries
    for (int i = 0; i < NEntries(); i++) {
	for (int j = i+1; j < NEntries(); j++) {
	    if ((*compare)(entries[j], entries[i], appl) < 0) {
	        Swap(i, j);
	    }
	}
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x13600
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0xd209d
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, 0x8(%rsp)
callq 0x13600
movl %eax, %ecx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jge 0xd208b
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movq (%rcx), %rdx
movslq 0x18(%rsp), %rsi
movq (%rdx,%rsi,8), %rdi
movq (%rcx), %rcx
movslq 0x1c(%rsp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x20(%rsp), %rdx
callq *%rax
cmpl $0x0, %eax
jge 0xd207c
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0xd1ec0
jmp 0xd207e
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xd2020
jmp 0xd208d
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xd1ff5
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/RNArray.cpp
// Function: gaps::RNVArray::IsValid() const
RNBoolean RNVArray::
IsValid(void) const
{
    // Check invariants
    assert(nentries >= 0);
    assert(nallocated >= 0);
    assert(nentries <= nallocated);
    if (nallocated == 0) { assert(entries == NULL); }
    else { assert(entries != NULL); }

    // Check entries
    for (int i = 0; i < nentries; i++) {
        assert(entries[i]);
    }

    // Return success
    return TRUE;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpl $0x0, 0x8(%rax)
jne 0xd2107
jmp 0xd2109
jmp 0xd2109
movl $0x0, -0xc(%rsp)
movq -0x18(%rsp), %rcx
movl -0xc(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0xd212e
jmp 0xd2121
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0xd2111
movl $0x1, %eax
retq
nopw %cs:(%rax,%rax)
nop
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/RNSvd.cpp
// Function: gaps::rotate_cols(int, int, double, double, double*, int, int, int, int)
void rotate_cols(int i,int j,RNScalar cos,RNScalar sin,RNScalar* a,int start,int n,int mm,int nn)
{
    int end = start+n, k;
    RNScalar x,y;
    for (k=start; k<end; k++) {
	x = REF2D(a,mm,nn,k,i);
	y = REF2D(a,mm,nn,k,j);
	REF2D(a,mm,nn,k,i) =  cos*x + sin*y;
	REF2D(a,mm,nn,k,j) = -sin*x + cos*y;
    }
}

// Assembly:
movl 0x8(%rsp), %eax
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movsd %xmm1, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movl %ecx, -0x24(%rsp)
movl %r8d, -0x28(%rsp)
movl %r9d, -0x2c(%rsp)
movl -0x24(%rsp), %eax
addl -0x28(%rsp), %eax
movl %eax, -0x30(%rsp)
movl -0x24(%rsp), %eax
movl %eax, -0x34(%rsp)
movl -0x34(%rsp), %eax
cmpl -0x30(%rsp), %eax
jge 0xd2b68
movq -0x20(%rsp), %rax
movl 0x8(%rsp), %ecx
imull -0x34(%rsp), %ecx
addl -0x4(%rsp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rsp)
movq -0x20(%rsp), %rax
movl 0x8(%rsp), %ecx
imull -0x34(%rsp), %ecx
addl -0x8(%rsp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x48(%rsp)
movsd -0x10(%rsp), %xmm0
movsd -0x40(%rsp), %xmm2
movsd -0x18(%rsp), %xmm1
mulsd -0x48(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x20(%rsp), %rax
movl 0x8(%rsp), %ecx
imull -0x34(%rsp), %ecx
addl -0x4(%rsp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movsd -0x18(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd -0x40(%rsp), %xmm2
movsd -0x10(%rsp), %xmm1
mulsd -0x48(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x20(%rsp), %rax
movl 0x8(%rsp), %ecx
imull -0x34(%rsp), %ecx
addl -0x8(%rsp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rsp)
jmp 0xd2a7f
retq
nopl (%rax)