LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::R3Matrix::Transpose() const
const R3Matrix R3Matrix::
Transpose(void) const
{
    // Return transpose of matrix
    return R3Matrix(
        m[0][0], m[1][0], m[2][0], 
        m[0][1], m[1][1], m[2][1], 
        m[0][2], m[1][2], m[2][2]);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movsd (%rax), %xmm0
movsd 0x18(%rax), %xmm1
movsd 0x30(%rax), %xmm2
movsd 0x8(%rax), %xmm3
movsd 0x20(%rax), %xmm4
movsd 0x38(%rax), %xmm5
movsd 0x10(%rax), %xmm6
movsd 0x28(%rax), %xmm7
movsd 0x40(%rax), %xmm8
movsd %xmm8, (%rsp)
callq 0xbf7d0
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::R3Matrix::Translate(int, double)
void R3Matrix:: 
Translate(RNAxis axis, RNScalar offset)
{
    // Translate matrix along axis
    switch (axis) {
    case RN_XAXIS: 
	XTranslate(offset); 
	break;

    case RN_YAXIS: 
	YTranslate(offset); 
	break;

    default: 
	RNWarning("Matrix translate along undefined axis");
	break;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0xc0215
jmp 0xc020a
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0xc0226
jmp 0xc0237
movq (%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0xc0140
jmp 0xc0245
movq (%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0xc0190
jmp 0xc0245
leaq 0x73bd0(%rip), %rdi     # 0x133e0e
movb $0x0, %al
callq 0xd5010
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::R3Matrix::Scale(int, double)
void R3Matrix:: 
Scale(RNAxis axis, RNScalar scale)
{
    // Scale matrix along axis
    switch (axis) {
    case RN_XAXIS: 
	XScale(scale); 
	break;

    case RN_YAXIS: 
	YScale(scale); 
	break;

    default: 
	RNWarning("Matrix scale along undefined axis");
	break;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0xc0385
jmp 0xc037a
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0xc0396
jmp 0xc03a7
movq (%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0xc02e0
jmp 0xc03b5
movq (%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0xc0310
jmp 0xc03b5
leaq 0x73a86(%rip), %rdi     # 0x133e34
movb $0x0, %al
callq 0xd5010
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::R3Matrix::Rotate(double)
void R3Matrix:: 
Rotate(RNAngle radians)
{
    // rotate matrix counterclockwise 
    RNScalar c = cos(radians);
    RNScalar s = sin(radians);
    R3Matrix rotation(
        c,   -s,  0.0, 
        s,   c,   0.0, 
        0.0, 0.0, 1.0);
    *this *= rotation;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movsd %xmm0, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
movsd 0x68(%rsp), %xmm0
callq 0xf930
movsd %xmm0, 0x60(%rsp)
movsd 0x68(%rsp), %xmm0
callq 0xf100
movsd %xmm0, 0x58(%rsp)
movsd 0x60(%rsp), %xmm0
movsd 0x58(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movsd 0x58(%rsp), %xmm3
movsd 0x60(%rsp), %xmm4
leaq 0x10(%rsp), %rdi
xorps %xmm7, %xmm7
movsd 0x72b3d(%rip), %xmm8    # 0x133008
movaps %xmm7, %xmm2
movaps %xmm7, %xmm5
movaps %xmm7, %xmm6
movsd %xmm8, (%rsp)
callq 0xbf7d0
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xc1060
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::R3Matrix::operator=(gaps::R3Matrix const&)
R3Matrix& R3Matrix::
operator=(const R3Matrix& a)
{
    // Assign matrix entry-by-entry
    m[0][0] = a.m[0][0]; m[0][1] = a.m[0][1]; m[0][2] = a.m[0][2]; 
    m[1][0] = a.m[1][0]; m[1][1] = a.m[1][1]; m[1][2] = a.m[1][2]; 
    m[2][0] = a.m[2][0]; m[2][1] = a.m[2][1]; m[2][2] = a.m[2][2]; 
    return *this;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rsp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rsp), %rcx
movsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x10(%rsp), %rcx
movsd 0x18(%rcx), %xmm0
movsd %xmm0, 0x18(%rax)
movq -0x10(%rsp), %rcx
movsd 0x20(%rcx), %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x10(%rsp), %rcx
movsd 0x28(%rcx), %xmm0
movsd %xmm0, 0x28(%rax)
movq -0x10(%rsp), %rcx
movsd 0x30(%rcx), %xmm0
movsd %xmm0, 0x30(%rax)
movq -0x10(%rsp), %rcx
movsd 0x38(%rcx), %xmm0
movsd %xmm0, 0x38(%rax)
movq -0x10(%rsp), %rcx
movsd 0x40(%rcx), %xmm0
movsd %xmm0, 0x40(%rax)
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::R3Matrix::operator*=(double)
R3Matrix& R3Matrix::
operator*=(RNScalar a)
{
    // Scale matrix entry-by-entry
    m[0][0] *= a; m[0][1] *= a; m[0][2] *= a; 
    m[1][0] *= a; m[1][1] *= a; m[1][2] *= a; 
    m[2][0] *= a; m[2][1] *= a; m[2][2] *= a; 
    return *this;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movq -0x8(%rsp), %rax
movsd -0x10(%rsp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movsd -0x10(%rsp), %xmm0
mulsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x10(%rsp), %xmm0
mulsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
movsd -0x10(%rsp), %xmm0
mulsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
movsd -0x10(%rsp), %xmm0
mulsd 0x20(%rax), %xmm0
movsd %xmm0, 0x20(%rax)
movsd -0x10(%rsp), %xmm0
mulsd 0x28(%rax), %xmm0
movsd %xmm0, 0x28(%rax)
movsd -0x10(%rsp), %xmm0
mulsd 0x30(%rax), %xmm0
movsd %xmm0, 0x30(%rax)
movsd -0x10(%rsp), %xmm0
mulsd 0x38(%rax), %xmm0
movsd %xmm0, 0x38(%rax)
movsd -0x10(%rsp), %xmm0
mulsd 0x40(%rax), %xmm0
movsd %xmm0, 0x40(%rax)
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::operator-(gaps::R3Matrix const&)
R3Matrix 
operator-(const R3Matrix& a)
{
    // Negate matrix
    return R3Matrix(
   	-a.m[0][0], -a.m[0][1], -a.m[0][2], 
	-a.m[1][0], -a.m[1][1], -a.m[1][2], 
        -a.m[2][0], -a.m[2][1], -a.m[2][2]);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movsd (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq 0x18(%rsp), %rax
movsd 0x8(%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movq 0x18(%rsp), %rax
movsd 0x10(%rax), %xmm2
movq %xmm2, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm2
movq 0x18(%rsp), %rax
movsd 0x18(%rax), %xmm3
movq %xmm3, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm3
movq 0x18(%rsp), %rax
movsd 0x20(%rax), %xmm4
movq %xmm4, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm4
movq 0x18(%rsp), %rax
movsd 0x28(%rax), %xmm5
movq %xmm5, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm5
movq 0x18(%rsp), %rax
movsd 0x30(%rax), %xmm6
movq %xmm6, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm6
movq 0x18(%rsp), %rax
movsd 0x38(%rax), %xmm7
movq %xmm7, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm7
movq 0x18(%rsp), %rax
movsd 0x40(%rax), %xmm8
movq %xmm8, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm8
movsd %xmm8, (%rsp)
callq 0xbf7d0
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::operator+(gaps::R3Matrix const&, gaps::R3Matrix const&)
R3Matrix 
operator+(const R3Matrix& a, const R3Matrix& b) 
{
    // Sum matrix
    return R3Matrix(
  	a.m[0][0]+b.m[0][0], a.m[0][1]+b.m[0][1], a.m[0][2]+b.m[0][2], 
  	a.m[1][0]+b.m[1][0], a.m[1][1]+b.m[1][1], a.m[1][2]+b.m[1][2], 
  	a.m[2][0]+b.m[2][0], a.m[2][1]+b.m[2][1], a.m[2][2]+b.m[2][2]);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movsd (%rax), %xmm0
movq 0x10(%rsp), %rax
addsd (%rax), %xmm0
movq 0x18(%rsp), %rax
movsd 0x8(%rax), %xmm1
movq 0x10(%rsp), %rax
addsd 0x8(%rax), %xmm1
movq 0x18(%rsp), %rax
movsd 0x10(%rax), %xmm2
movq 0x10(%rsp), %rax
addsd 0x10(%rax), %xmm2
movq 0x18(%rsp), %rax
movsd 0x18(%rax), %xmm3
movq 0x10(%rsp), %rax
addsd 0x18(%rax), %xmm3
movq 0x18(%rsp), %rax
movsd 0x20(%rax), %xmm4
movq 0x10(%rsp), %rax
addsd 0x20(%rax), %xmm4
movq 0x18(%rsp), %rax
movsd 0x28(%rax), %xmm5
movq 0x10(%rsp), %rax
addsd 0x28(%rax), %xmm5
movq 0x18(%rsp), %rax
movsd 0x30(%rax), %xmm6
movq 0x10(%rsp), %rax
addsd 0x30(%rax), %xmm6
movq 0x18(%rsp), %rax
movsd 0x38(%rax), %xmm7
movq 0x10(%rsp), %rax
addsd 0x38(%rax), %xmm7
movq 0x18(%rsp), %rax
movsd 0x40(%rax), %xmm8
movq 0x10(%rsp), %rax
addsd 0x40(%rax), %xmm8
movsd %xmm8, (%rsp)
callq 0xbf7d0
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::operator-(gaps::R3Matrix const&, gaps::R3Matrix const&)
R3Matrix 
operator-(const R3Matrix& a, const R3Matrix& b) 
{
    // Subtract matrix
    return R3Matrix(
  	a.m[0][0]-b.m[0][0], a.m[0][1]-b.m[0][1], a.m[0][2]-b.m[0][2], 
  	a.m[1][0]-b.m[1][0], a.m[1][1]-b.m[1][1], a.m[1][2]-b.m[1][2], 
  	a.m[2][0]-b.m[2][0], a.m[2][1]-b.m[2][1], a.m[2][2]-b.m[2][2]);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movsd (%rax), %xmm0
movq 0x10(%rsp), %rax
subsd (%rax), %xmm0
movq 0x18(%rsp), %rax
movsd 0x8(%rax), %xmm1
movq 0x10(%rsp), %rax
subsd 0x8(%rax), %xmm1
movq 0x18(%rsp), %rax
movsd 0x10(%rax), %xmm2
movq 0x10(%rsp), %rax
subsd 0x10(%rax), %xmm2
movq 0x18(%rsp), %rax
movsd 0x18(%rax), %xmm3
movq 0x10(%rsp), %rax
subsd 0x18(%rax), %xmm3
movq 0x18(%rsp), %rax
movsd 0x20(%rax), %xmm4
movq 0x10(%rsp), %rax
subsd 0x20(%rax), %xmm4
movq 0x18(%rsp), %rax
movsd 0x28(%rax), %xmm5
movq 0x10(%rsp), %rax
subsd 0x28(%rax), %xmm5
movq 0x18(%rsp), %rax
movsd 0x30(%rax), %xmm6
movq 0x10(%rsp), %rax
subsd 0x30(%rax), %xmm6
movq 0x18(%rsp), %rax
movsd 0x38(%rax), %xmm7
movq 0x10(%rsp), %rax
subsd 0x38(%rax), %xmm7
movq 0x18(%rsp), %rax
movsd 0x40(%rax), %xmm8
movq 0x10(%rsp), %rax
subsd 0x40(%rax), %xmm8
movsd %xmm8, (%rsp)
callq 0xbf7d0
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::operator*(gaps::R3Matrix const&, double)
R3Matrix 
operator*(const R3Matrix& a, RNScalar b)
{
    // Scale matrix
    return R3Matrix(
  	a.m[0][0]*b, a.m[0][1]*b, a.m[0][2]*b, 
  	a.m[1][0]*b, a.m[1][1]*b, a.m[1][2]*b, 
  	a.m[2][0]*b, a.m[2][1]*b, a.m[2][2]*b);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movq 0x18(%rsp), %rax
movsd (%rax), %xmm0
mulsd 0x10(%rsp), %xmm0
movq 0x18(%rsp), %rax
movsd 0x8(%rax), %xmm1
mulsd 0x10(%rsp), %xmm1
movq 0x18(%rsp), %rax
movsd 0x10(%rax), %xmm2
mulsd 0x10(%rsp), %xmm2
movq 0x18(%rsp), %rax
movsd 0x18(%rax), %xmm3
mulsd 0x10(%rsp), %xmm3
movq 0x18(%rsp), %rax
movsd 0x20(%rax), %xmm4
mulsd 0x10(%rsp), %xmm4
movq 0x18(%rsp), %rax
movsd 0x28(%rax), %xmm5
mulsd 0x10(%rsp), %xmm5
movq 0x18(%rsp), %rax
movsd 0x30(%rax), %xmm6
mulsd 0x10(%rsp), %xmm6
movq 0x18(%rsp), %rax
movsd 0x38(%rax), %xmm7
mulsd 0x10(%rsp), %xmm7
movq 0x18(%rsp), %rax
movsd 0x40(%rax), %xmm8
mulsd 0x10(%rsp), %xmm8
movsd %xmm8, (%rsp)
callq 0xbf7d0
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::operator*(gaps::R3Matrix const&, gaps::R3Matrix const&)
R3Matrix 
operator*(const R3Matrix& a, const R3Matrix& b) 
{
    R3Matrix result;
    int r, c;

    // Multiply matrix
    for (r=0; r<3; r++)
	for (c=0; c<3; c++)
	    result.m[r][c] = a.m[r][0] * b.m[0][c] + 
		             a.m[r][1] * b.m[1][c] +
		             a.m[r][2] * b.m[2][c];

    // Return result
    return result;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
callq 0xbf720
movl $0x0, 0x1c(%rsp)
cmpl $0x3, 0x1c(%rsp)
jge 0xc0de8
movl $0x0, 0x18(%rsp)
cmpl $0x3, 0x18(%rsp)
jge 0xc0dd6
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movslq 0x1c(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movsd (%rcx), %xmm1
movq 0x20(%rsp), %rcx
movslq 0x18(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm2
movq 0x28(%rsp), %rcx
movslq 0x1c(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movsd 0x8(%rcx), %xmm0
movq 0x20(%rsp), %rcx
movslq 0x18(%rsp), %rdx
mulsd 0x18(%rcx,%rdx,8), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq 0x28(%rsp), %rcx
movslq 0x1c(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movsd 0x10(%rcx), %xmm0
movq 0x20(%rsp), %rcx
movslq 0x18(%rsp), %rdx
movsd 0x30(%rcx,%rdx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movslq 0x1c(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq 0x18(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xc0d20
jmp 0xc0dd8
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xc0d0d
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Span.cpp
// Function: gaps::R2Span::R2Span(gaps::R2Point const&, gaps::R2Vector const&)
R2Span::
R2Span(const R2Point& point, const R2Vector& vector)
    : end(point + vector)
{
    R2Vector v(vector);
    length = v.Length();
    if (RNIsNotZero(length)) v /= length;
    ray.Reset(point, v, TRUE);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xc2340
movq 0x8(%rsp), %rdi
addq $0x38, %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xc37a0
movq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0xc3c60
leaq 0x10(%rsp), %rdi
callq 0xc3d60
movq 0x8(%rsp), %rax
movsd %xmm0, 0x48(%rax)
movsd 0x48(%rax), %xmm0
leaq 0xb70b7(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x555a0
cmpl $0x0, %eax
je 0xc144b
movq 0x8(%rsp), %rax
movsd 0x48(%rax), %xmm0
leaq 0x10(%rsp), %rdi
callq 0xc4650
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movl $0x1, %ecx
callq 0xc20a0
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Span.cpp
// Function: gaps::R2Span::R2Span(gaps::R2Point const&, gaps::R2Point const&)
R2Span::
R2Span(const R2Point& point1, const R2Point& point2)
    : end(point2)
{
    R2Vector v(point2 - point1);
    length = v.Length();
    if (RNIsNotZero(length)) v /= length;
    ray.Reset(point1, v, TRUE);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xc2340
movq 0x8(%rsp), %rdi
addq $0x38, %rdi
movq 0x20(%rsp), %rsi
callq 0xc3170
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x10(%rsp), %rdi
callq 0xc3830
leaq 0x10(%rsp), %rdi
callq 0xc3d60
movq 0x8(%rsp), %rax
movsd %xmm0, 0x48(%rax)
movsd 0x48(%rax), %xmm0
leaq 0xb7007(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x555a0
cmpl $0x0, %eax
je 0xc14fb
movq 0x8(%rsp), %rax
movsd 0x48(%rax), %xmm0
leaq 0x10(%rsp), %rdi
callq 0xc4650
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movl $0x1, %ecx
callq 0xc20a0
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Span.cpp
// Function: gaps::R2Span::R2Span(double, double, double, double)
R2Span::
R2Span(RNCoord x1, RNCoord y1, RNCoord x2, RNCoord y2)
    : end(x2, y2)
{
    R2Point p1(x1, y1);
    R2Point p2(x2, y2);
    R2Vector v(p2 - p1);
    length = v.Length();
    if (RNIsNotZero(length)) v /= length;
    ray.Reset(R2Point(x1, y1), v, TRUE);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movsd %xmm0, 0x68(%rsp)
movsd %xmm1, 0x60(%rsp)
movsd %xmm2, 0x58(%rsp)
movsd %xmm3, 0x50(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xc2340
movq 0x8(%rsp), %rdi
addq $0x38, %rdi
movsd 0x58(%rsp), %xmm0
movsd 0x50(%rsp), %xmm1
callq 0xc3140
movsd 0x68(%rsp), %xmm0
movsd 0x60(%rsp), %xmm1
leaq 0x40(%rsp), %rdi
callq 0xc3140
movsd 0x58(%rsp), %xmm0
movsd 0x50(%rsp), %xmm1
leaq 0x30(%rsp), %rdi
callq 0xc3140
leaq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0xc3830
leaq 0x20(%rsp), %rdi
callq 0xc3d60
movq 0x8(%rsp), %rax
movsd %xmm0, 0x48(%rax)
movsd 0x48(%rax), %xmm0
leaq 0xb6f16(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x555a0
cmpl $0x0, %eax
je 0xc15ec
movq 0x8(%rsp), %rax
movsd 0x48(%rax), %xmm0
leaq 0x20(%rsp), %rdi
callq 0xc4650
movsd 0x68(%rsp), %xmm0
movsd 0x60(%rsp), %xmm1
leaq 0x10(%rsp), %rdi
callq 0xc3140
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movl $0x1, %ecx
callq 0xc20a0
addq $0x78, %rsp
retq
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Span.cpp
// Function: gaps::R2Span::BBox() const
const R2Box R2Span::
BBox(void) const
{
    // Return bounding box 
    R2Box bbox(Start(), Start());
    bbox.Union(End());
    return bbox;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movb $0x0, 0x47(%rsp)
callq 0xa3500
movq 0x20(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0xa3500
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
callq 0xbd460
movq 0x20(%rsp), %rdi
callq 0xa3510
movq %rax, 0x28(%rsp)
jmp 0xc1761
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0xbe470
jmp 0xc1772
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0xc17a4
jmp 0xc179a
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x6bc50
jmp 0xc17ae
movq 0x10(%rsp), %rdi
callq 0x6bc50
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xf890
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Span.cpp
// Function: gaps::R2Span::Reposition(int, gaps::R2Point const&)
void R2Span::
Reposition(int k, const R2Point& point)
{
    // Set one endpoint of span
    if (k == 0) ray = R2Ray(point, end);
    else { end = point; ray.Align(end - ray.Start()); }
    length = R2Distance(Start(), End());
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x6c(%rsp)
jne 0xc189c
movq 0x10(%rsp), %rdx
movq 0x60(%rsp), %rsi
addq $0x38, %rdx
leaq 0x28(%rsp), %rdi
callq 0xc2400
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xc20f0
jmp 0xc18e6
movq 0x10(%rsp), %rdi
movq 0x60(%rsp), %rsi
addq $0x38, %rdi
callq 0xc33e0
movq 0x10(%rsp), %rdi
movq %rdi, %rax
addq $0x38, %rax
movq %rax, 0x8(%rsp)
callq 0xa3560
movq 0x8(%rsp), %rsi
movq %rax, %rdx
leaq 0x18(%rsp), %rdi
callq 0xc3830
movq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xc2130
movq 0x10(%rsp), %rdi
callq 0xa3500
movq 0x10(%rsp), %rdi
movq %rax, (%rsp)
callq 0xa3510
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xcb540
movq 0x10(%rsp), %rax
movsd %xmm0, 0x48(%rax)
addq $0x78, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Span.cpp
// Function: gaps::R2Span::Project(gaps::R2Line const&)
void R2Span::
Project(const R2Line& line)
{
    // Project span onto line
    length *= Vector().Dot(line.Vector());
    if (length < 0.0) length = -length;
    ray.Project(line);
    end.Project(line);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xa61d0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0xa3540
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xc3f40
movq 0x10(%rsp), %rax
mulsd 0x48(%rax), %xmm0
movsd %xmm0, 0x48(%rax)
xorps %xmm0, %xmm0
ucomisd 0x48(%rax), %xmm0
jbe 0xc1998
movq 0x10(%rsp), %rax
movsd 0x48(%rax), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
movsd %xmm0, 0x48(%rax)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xc2630
movq 0x10(%rsp), %rdi
addq $0x38, %rdi
movq 0x18(%rsp), %rsi
callq 0xc3250
addq $0x28, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Span.cpp
// Function: gaps::R2Span::Flip()
void R2Span::
Flip(void)
{
    // Flip direction of span
    R2Point swap = Start();
    ray.Reposition(end);
    end = swap;
    ray.Flip();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xa3500
movq %rax, %rsi
leaq 0x10(%rsp), %rdi
callq 0xc3170
movq 0x8(%rsp), %rdi
movq %rdi, %rsi
addq $0x38, %rsi
callq 0xc2160
movq 0x8(%rsp), %rdi
addq $0x38, %rdi
leaq 0x10(%rsp), %rsi
callq 0xc33e0
movq 0x8(%rsp), %rdi
callq 0xc21a0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Ray.cpp
// Function: gaps::R2Ray::T(gaps::R2Point const&) const
const RNScalar R2Ray::
T(const R2Point& point) const
{
    // Return parametric value of closest point on ray
    RNScalar denom = Vector().Dot(Vector());
    if (RNIsZero(denom)) return 0.0;
    R2Vector topoint = point - Start();
    return (Vector().Dot(topoint) / denom);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xa35c0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0xa35c0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xc3f40
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
leaq 0xb5f64(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x36b80
cmpl $0x0, %eax
je 0xc2595
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0xc25dc
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
callq 0xa3560
movq (%rsp), %rsi
movq %rax, %rdx
leaq 0x18(%rsp), %rdi
callq 0xc3830
movq 0x8(%rsp), %rdi
callq 0xa35c0
movq %rax, %rdi
leaq 0x18(%rsp), %rsi
callq 0xc3f40
divsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Line.cpp
// Function: gaps::R2Line::Mirror(gaps::R2Line const&)
void R2Line::
Mirror(const R2Line& line)
{
    // Mirror line over another line
    R2Point p = (normal * -c).Point();
    p.Mirror(line);
    vector.Mirror(line);
    normal = R2Vector(vector.Y(), -(vector.X()));
    c = -(normal.X()*p.X() + normal.Y()*p.Y());
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, %rsi
addq $0x10, %rsi
movsd 0x20(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
leaq 0x38(%rsp), %rdi
callq 0xc42e0
leaq 0x48(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xc3e40
movq 0x58(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0xc3280
movq 0x18(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0xc4380
movq 0x18(%rsp), %rdi
callq 0x78ab0
movq 0x18(%rsp), %rdi
movsd %xmm0, (%rsp)
callq 0x78aa0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
leaq 0x28(%rsp), %rdi
callq 0xc3c30
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0x28(%rsp), %rsi
callq 0xc4350
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
callq 0x78aa0
movsd %xmm0, 0x20(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x38c50
movq 0x18(%rsp), %rdi
movsd %xmm0, 0x10(%rsp)
addq $0x10, %rdi
callq 0x78ab0
movsd %xmm0, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x38c60
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movq 0x18(%rsp), %rax
movaps %xmm0, %xmm3
movsd 0x20(%rsp), %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
movsd %xmm0, 0x20(%rax)
addq $0x68, %rsp
retq
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Line.cpp
// Function: gaps::R2Line::Align(gaps::R2Vector const&, int)
void R2Line::
Align(const R2Vector& vector, RNBoolean normalized)
{
    // Set vector of line
    this->vector = vector;
    if (!normalized) this->vector.Normalize();
    this->normal = R2Vector(this->vector.Y(), -this->vector.X());
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x28(%rsp), %rsi
callq 0xc4350
cmpl $0x0, 0x24(%rsp)
jne 0xc2eb7
movq 0x8(%rsp), %rdi
callq 0xc4090
movq 0x8(%rsp), %rdi
callq 0x78ab0
movq 0x8(%rsp), %rdi
movsd %xmm0, (%rsp)
callq 0x78aa0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
leaq 0x10(%rsp), %rdi
callq 0xc3c30
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x10(%rsp), %rsi
callq 0xc4350
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Line.cpp
// Function: gaps::R2Line::Transform(gaps::R2Transformation const&)
void R2Line::
Transform (const R2Transformation& transformation)
{
    // Transform line
    vector.Transform(transformation);
    vector.Normalize();
    normal = R2Vector(vector.Y(), -vector.X());
    R2Point p(Point());
    p.Transform(transformation);
    Reposition(p);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x38(%rsp), %rsi
callq 0xc4430
movq 0x10(%rsp), %rdi
callq 0xc4090
movq 0x10(%rsp), %rdi
callq 0x78ab0
movq 0x10(%rsp), %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x78aa0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
leaq 0x28(%rsp), %rdi
callq 0xc3c30
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
leaq 0x28(%rsp), %rsi
callq 0xc4350
movq 0x10(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0xa3630
movq 0x38(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0xc3380
movq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xc2de0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Line.cpp
// Function: gaps::R2Line::InverseTransform(gaps::R2Transformation const&)
void R2Line::
InverseTransform (const R2Transformation& transformation)
{
    // Inverse Transform line
    vector.InverseTransform(transformation);
    vector.Normalize();
    normal = R2Vector(vector.Y(), -vector.X());
    R2Point p(Point());
    p.InverseTransform(transformation);
    Reposition(p);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x38(%rsp), %rsi
callq 0xc4460
movq 0x10(%rsp), %rdi
callq 0xc4090
movq 0x10(%rsp), %rdi
callq 0x78ab0
movq 0x10(%rsp), %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x78aa0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
leaq 0x28(%rsp), %rdi
callq 0xc3c30
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
leaq 0x28(%rsp), %rsi
callq 0xc4350
movq 0x10(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0xa3630
movq 0x38(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0xc33b0
movq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xc2de0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Point.cpp
// Function: gaps::R2Point::operator*=(gaps::R3Matrix const&)
R2Point& R2Point::
operator*=(const R3Matrix& m)
{
    // Multiply point by matrix 
    RNCoord x = v[0], y = v[1];
    v[0] = x*m[0][0] + y*m[1][0] + m[2][0];
    v[1] = x*m[0][1] + y*m[1][1] + m[2][1];
    return *this;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x40(%rsp)
movsd (%rax), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x58(%rsp), %rdi
xorl %esi, %esi
callq 0xb9860
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x48(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x58(%rsp), %rdi
movl $0x1, %esi
callq 0xb9860
movsd (%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm2
mulsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x58(%rsp), %rdi
movl $0x2, %esi
callq 0xb9860
movsd 0x18(%rsp), %xmm0
movq %rax, %rcx
movq 0x40(%rsp), %rax
addsd (%rcx), %xmm0
movsd %xmm0, (%rax)
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x58(%rsp), %rdi
xorl %esi, %esi
callq 0xb9860
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x58(%rsp), %rdi
movl $0x1, %esi
callq 0xb9860
movsd 0x20(%rsp), %xmm1
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm2
mulsd 0x8(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x58(%rsp), %rdi
movl $0x2, %esi
callq 0xb9860
movsd 0x38(%rsp), %xmm0
movq %rax, %rcx
movq 0x40(%rsp), %rax
addsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
addq $0x68, %rsp
retq
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Vector.cpp
// Function: gaps::R2Vector::Angle() const
const RNAngle R2Vector::
Angle(void) const
{
    // Return angle to positive x axis
    RNLength length = Length();
    if (length == 0) return 0;
    RNCoord x = v[0] / length;
    if (x == 0) return RN_PI_OVER_TWO;
    RNCoord y = v[1] / length;
    return atan2(y, x);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xc3d60
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xc3dca
jp 0xc3dca
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0xc3e30
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
divsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xc3e03
jp 0xc3e03
leaq 0x72af1(%rip), %rax     # 0x1368e8
movsd (%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0xc3e30
movq 0x8(%rsp), %rax
movsd 0x8(%rax), %xmm0
divsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0xf0a0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Vector.cpp
// Function: gaps::R2Vector::Quadrant() const
const RNQuadrant R2Vector::
Quadrant(void) const
{
    // Return quadrant vector points into
    if (v[0] >= 0.0) {
        if (v[1] >= 0.0) return RN_PP_QUADRANT;
	else return RN_PN_QUADRANT;
    }
    else {
        if (v[1] >= 0.0) return RN_NP_QUADRANT;
	else return RN_NN_QUADRANT;
    }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x18(%rsp)
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xc3f13
movq -0x18(%rsp), %rax
movsd 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xc3f09
movl $0x3, -0x4(%rsp)
jmp 0xc3f38
movl $0x2, -0x4(%rsp)
jmp 0xc3f38
movq -0x18(%rsp), %rax
movsd 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xc3f30
movl $0x1, -0x4(%rsp)
jmp 0xc3f38
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Vector.cpp
// Function: gaps::R2Vector::Normalize()
void R2Vector::
Normalize(void)
{
    RNLength length = Length();
    if (length == 0.0) return;
    v[0] /= length;
    v[1] /= length;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xc3d60
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xc40c0
jp 0xc40c0
jmp 0xc40ea
movq (%rsp), %rax
movsd 0x8(%rsp), %xmm1
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movsd 0x8(%rsp), %xmm1
movsd 0x8(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
addq $0x18, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Vector.cpp
// Function: gaps::R2Vector::Project(gaps::R2Vector const&)
void R2Vector::
Project(const R2Vector& vector)
{
    // Project onto another vector    
    RNScalar dot = this->Dot(vector);
    RNLength length = vector.Length();
    if ((RNIsPositive(length)) && (length != 1.0)) 
	dot /= (length * length);
    *this = vector * dot;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x28(%rsp), %rsi
callq 0xc3f40
movsd %xmm0, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xc3d60
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
leaq 0xb426c(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x36d50
cmpl $0x0, %eax
je 0xc42b6
movsd 0x18(%rsp), %xmm0
movsd 0x6ed78(%rip), %xmm1    # 0x133008
ucomisd %xmm1, %xmm0
jne 0xc429a
jp 0xc429a
jmp 0xc42b6
movsd 0x18(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
movsd 0x20(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x28(%rsp), %rsi
movsd 0x20(%rsp), %xmm0
leaq 0x8(%rsp), %rdi
callq 0xc42e0
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xc4350
addq $0x38, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Vector.cpp
// Function: gaps::R2Vector::operator*=(gaps::R3Matrix const&)
R2Vector& R2Vector::
operator*=(const R3Matrix& m)
{
    // Multiply vector by matrix 
    RNCoord x = v[0], y = v[1];
    v[0] = x*m[0][0] + y*m[1][0];
    v[1] = x*m[0][1] + y*m[1][1];
    return *this;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movsd (%rax), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0xb9860
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
callq 0xb9860
movsd (%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm2
movq %rax, %rcx
movq 0x30(%rsp), %rax
mulsd (%rcx), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0xb9860
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
callq 0xb9860
movsd 0x18(%rsp), %xmm1
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm2
movq %rax, %rcx
movq 0x30(%rsp), %rax
mulsd 0x8(%rcx), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Image.cpp
// Function: gaps::R2Image::R2Image(int, int, int)
R2Image::
R2Image(int width, int height, int ncomponents)
  : width(width), 
    height(height),
    ncomponents(ncomponents),
    rowsize(0),
    pixels(NULL)
{
  // Initialize pixels
  rowsize = ncomponents * width;
  if ((rowsize % 4) != 0) rowsize = (rowsize / 4 + 1) * 4;
  int nbytes = rowsize * height;
  if (nbytes > 0) {
    pixels = new unsigned char [nbytes];
    assert(pixels);
    unsigned char *p = pixels;
    while (--nbytes) *(p++) = 0;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x1c(%rsp), %ecx
movl %ecx, (%rax)
movl 0x18(%rsp), %ecx
movl %ecx, 0x4(%rax)
movl 0x14(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl $0x0, 0xc(%rax)
movq $0x0, 0x10(%rax)
movl 0x14(%rsp), %ecx
imull 0x1c(%rsp), %ecx
movl %ecx, 0xc(%rax)
movl 0xc(%rax), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0xc507b
movq (%rsp), %rax
movl 0xc(%rax), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq (%rsp), %rax
addl $0x1, %ecx
shll $0x2, %ecx
movl %ecx, 0xc(%rax)
movq (%rsp), %rax
movl 0xc(%rax), %eax
imull 0x18(%rsp), %eax
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jle 0xc50d8
movslq 0x10(%rsp), %rdi
callq 0xf030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x10(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
cmpl $0x0, %eax
je 0xc50d6
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movb $0x0, (%rax)
jmp 0xc50b0
jmp 0xc50d8
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Image.cpp
// Function: gaps::R2Image::R2Image(int, int, int, unsigned char*)
R2Image::
R2Image(int width, int height, int ncomponents, unsigned char *data)
  : width(width), 
    height(height),
    ncomponents(ncomponents),
    rowsize(0),
    pixels(NULL)
{
  // Copy pixels (first pixel is lower-left)
  rowsize = ncomponents * width;
  if ((rowsize % 4) != 0) rowsize = (rowsize / 4 + 1) * 4;
  int nbytes = rowsize * height;
  if (nbytes > 0) {
    pixels = new unsigned char [nbytes];
    assert(pixels);
    unsigned char *p = pixels;
    while (--nbytes) *(p++) = *(data++);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq %r8, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movl 0x2c(%rsp), %ecx
movl %ecx, (%rax)
movl 0x28(%rsp), %ecx
movl %ecx, 0x4(%rax)
movl 0x24(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl $0x0, 0xc(%rax)
movq $0x0, 0x10(%rax)
movl 0x24(%rsp), %ecx
imull 0x2c(%rsp), %ecx
movl %ecx, 0xc(%rax)
movl 0xc(%rax), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0xc5160
movq (%rsp), %rax
movl 0xc(%rax), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq (%rsp), %rax
addl $0x1, %ecx
shll $0x2, %ecx
movl %ecx, 0xc(%rax)
movq (%rsp), %rax
movl 0xc(%rax), %eax
imull 0x28(%rsp), %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jle 0xc51cf
movslq 0x14(%rsp), %rdi
callq 0xf030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, %eax
je 0xc51cd
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rsp)
movb (%rax), %cl
movq 0x8(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rsp)
movb %cl, (%rax)
jmp 0xc5195
jmp 0xc51cf
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Image.cpp
// Function: gaps::R2Image::R2Image(gaps::R2Image const&)
R2Image::
R2Image(const R2Image& image)
  : width(image.width), 
    height(image.height),
    ncomponents(image.ncomponents),
    rowsize(image.rowsize),
    pixels(NULL)
{
  // Copy pixels
  int nbytes = rowsize * height;
  if (nbytes > 0) {
    pixels = new unsigned char [nbytes];
    assert(pixels);
    unsigned char *p = pixels;
    unsigned char *data = image.pixels;
    while (--nbytes) *(p++) = *(data++);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %eax
movl %eax, (%rcx)
movq 0x28(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x4(%rcx)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x8(%rcx)
movq 0x28(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0xc(%rcx)
movq $0x0, 0x10(%rcx)
movl 0xc(%rcx), %eax
imull 0x4(%rcx), %eax
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jle 0xc5513
movslq 0x24(%rsp), %rdi
callq 0xf030
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x24(%rsp)
cmpl $0x0, %eax
je 0xc5511
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movb (%rax), %cl
movq 0x18(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x18(%rsp)
movb %cl, (%rax)
jmp 0xc54d9
jmp 0xc5513
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Image.cpp
// Function: gaps::R2Image::PixelRGB(int, int) const
const RNRgb R2Image::
PixelRGB(int x, int y) const
{
  // Return pixel RGB at (x,y)
  RNScalar r, g, b;
  const unsigned char *pixel = Pixel(x, y);
  switch (ncomponents) {
  case 1: 
  case 2:
    r = *(pixel++) / 255.0;
    g = b = r;
    break;

  case 3:
  case 4:
    r = *(pixel++) / 255.0;
    g = *(pixel++) / 255.0;
    b = *(pixel++) / 255.0;
    break;

  default:
    r = b = g = 0;
    break;
  }
  return RNRgb(r, g, b);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movl %ecx, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl 0x44(%rsp), %esi
movl 0x40(%rsp), %edx
callq 0xca870
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x1c(%rsp)
decl %eax
subl $0x2, %eax
jb 0xc55c7
jmp 0xc55b6
movl 0x1c(%rsp), %eax
addl $-0x3, %eax
subl $0x2, %eax
jb 0xc5608
jmp 0xc5688
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rsp)
movzbl (%rax), %eax
cvtsi2sd %eax, %xmm0
movsd 0x6dc39(%rip), %xmm1    # 0x133220
divsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd %xmm0, 0x30(%rsp)
jmp 0xc56a3
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rsp)
movzbl (%rax), %eax
cvtsi2sd %eax, %xmm0
movsd 0x6dbf8(%rip), %xmm1    # 0x133220
divsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rsp)
movzbl (%rax), %eax
cvtsi2sd %eax, %xmm0
movsd 0x6dbce(%rip), %xmm1    # 0x133220
divsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rsp)
movzbl (%rax), %eax
cvtsi2sd %eax, %xmm0
movsd 0x6dba4(%rip), %xmm1    # 0x133220
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
jmp 0xc56a3
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
movq (%rsp), %rdi
movsd 0x38(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movsd 0x28(%rsp), %xmm2
callq 0xd14d0
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Image.cpp
// Function: gaps::R2Image::operator=(gaps::R2Image const&)
R2Image& R2Image::
operator=(const R2Image& image)
{
  // Assign values
  this->width = image.width;
  this->height = image.height;
  this->ncomponents = image.ncomponents;
  this->rowsize = image.rowsize;
  
  // Delete previous pixels
  if (this->pixels) delete [] pixels;
  this->pixels = NULL;

  // Copy pixels
  int nbytes = this->rowsize * this->height;
  if (nbytes > 0) {
    this->pixels = new unsigned char [nbytes];
    assert(this->pixels);
    unsigned char *p =this-> pixels;
    unsigned char *data = image.pixels;
    while (--nbytes) *(p++) = *(data++);
  }

  // Return this
  return *this;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq 0x28(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
movq 0x28(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x28(%rsp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
cmpq $0x0, 0x10(%rax)
je 0xc5737
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xc5735
movq (%rsp), %rdi
callq 0xf670
jmp 0xc5737
movq 0x8(%rsp), %rcx
movq $0x0, 0x10(%rcx)
movl 0xc(%rcx), %eax
imull 0x4(%rcx), %eax
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jle 0xc57bd
movslq 0x24(%rsp), %rdi
callq 0xf030
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x24(%rsp)
cmpl $0x0, %eax
je 0xc57bb
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movb (%rax), %cl
movq 0x18(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x18(%rsp)
movb %cl, (%rax)
jmp 0xc5783
jmp 0xc57bd
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Image.cpp
// Function: gaps::R2Image::Add(gaps::R2Image const&)
void R2Image::
Add(const R2Image& image)
{
  int nbytes = rowsize * height;
  unsigned char *p1 = pixels;
  unsigned char *p2 = image.pixels;
  while (--nbytes) {
    int value = *p1;
    value += *(p2++);
    if (value > 255) value = 255;
    *(p1++) = value;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl 0xc(%rax), %ecx
imull 0x4(%rax), %ecx
movl %ecx, -0x14(%rsp)
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rsp)
movl -0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rsp)
cmpl $0x0, %eax
je 0xc5c76
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
movl %eax, -0x2c(%rsp)
movq -0x28(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rsp)
movzbl (%rax), %eax
addl -0x2c(%rsp), %eax
movl %eax, -0x2c(%rsp)
cmpl $0xff, -0x2c(%rsp)
jle 0xc5c5b
movl $0xff, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
movb %al, %cl
movq -0x20(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rsp)
movb %cl, (%rax)
jmp 0xc5c11
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Image.cpp
// Function: gaps::R2Image::Subtract(gaps::R2Image const&)
void R2Image::
Subtract(const R2Image& image)
{
  int nbytes = rowsize * height;
  unsigned char *p1 = pixels;
  unsigned char *p2 = image.pixels;
  while (--nbytes) {
    int value = *p1 - *p2 + 128;
    if (value < 0) value = 0;
    if (value > 255) value = 255;
    *p1 = value;
    p1++;
    p2++;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl 0xc(%rax), %ecx
imull 0x4(%rax), %ecx
movl %ecx, -0x14(%rsp)
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rsp)
movl -0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rsp)
cmpl $0x0, %eax
je 0xc5d28
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
movq -0x28(%rsp), %rcx
movzbl (%rcx), %ecx
subl %ecx, %eax
addl $0x80, %eax
movl %eax, -0x2c(%rsp)
cmpl $0x0, -0x2c(%rsp)
jge 0xc5ceb
movl $0x0, -0x2c(%rsp)
cmpl $0xff, -0x2c(%rsp)
jle 0xc5cfd
movl $0xff, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
movb %al, %cl
movq -0x20(%rsp), %rax
movb %cl, (%rax)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0xc5cb1
retq
nopl (%rax)