LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNPolynomial.cpp
// Function: gaps::RNPolynomial::Evaluate(double const*) const
RNScalar RNPolynomial::
Evaluate(const RNScalar *x) const
{
  // Return sum of terms
  RNScalar sum = 0;
  for (int i = 0; i < NTerms(); i++) {
    RNPolynomialTerm *term = Term(i);
    sum += term->Evaluate(x);
  }
  return sum;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x3f5c0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x3de80
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x3f5d0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x3de90
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x3de29
movsd 0x20(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNPolynomial.cpp
// Function: gaps::RNPolynomialTerm::Evaluate(double const*) const
RNScalar RNPolynomialTerm::
Evaluate(const RNScalar *x) const
{
  // Evaluate the term
  RNScalar result = c;
  for (int i = 0; i < NVariables(); i++) {
    int k = Variable(i);
    if (e[i] == 1.0) result *= x[k];
    else if (e[i] == 2.0) result *= x[k] *x[k];
    else if ((e[i] < 0) && RNIsZero(x[k])) result *= RN_INFINITY;
    else result *= pow(x[k], e[i]);
  }
  return result;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x3f6b0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x3e022
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x3f6e0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x18(%rsp)
movq 0x20(%rax), %rax
movslq 0x1c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x6d116(%rip), %xmm1    # 0xab020
ucomisd %xmm1, %xmm0
jne 0x3df32
jp 0x3df32
movq 0x28(%rsp), %rax
movslq 0x18(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x3e010
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x1c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x6da8b(%rip), %xmm1    # 0xab9d8
ucomisd %xmm1, %xmm0
jne 0x3df84
jp 0x3df84
movq 0x28(%rsp), %rax
movslq 0x18(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x28(%rsp), %rax
movslq 0x18(%rsp), %rcx
mulsd (%rax,%rcx,8), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x3e00e
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x1c(%rsp), %rcx
xorps %xmm0, %xmm0
ucomisd (%rax,%rcx,8), %xmm0
jbe 0x3dfd9
movq 0x28(%rsp), %rax
movslq 0x18(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x8c326(%rip), %rax     # 0xca2d8
movsd (%rax), %xmm1
callq 0xb660
cmpl $0x0, %eax
je 0x3dfd9
leaq 0x8c321(%rip), %rax     # 0xca2e8
movsd (%rax), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x3e00c
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movslq 0x18(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x20(%rax), %rax
movslq 0x1c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm1
callq 0x44a0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x3e00e
jmp 0x3e010
jmp 0x3e012
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x3debb
movsd 0x20(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNPolynomial.cpp
// Function: gaps::RNPolynomial::Evaluate(double const* const*) const
RNScalar RNPolynomial::
Evaluate(double const* const* x) const
{
  // Evaluate polynomial (in format suitable for CERES)
  RNScalar sum = 0;
  for (int i = 0; i < NTerms(); i++) {
    RNPolynomialTerm *term = Term(i);
    sum += term->Evaluate(x);
  }
  return sum;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x3f5c0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x3e0b0
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x3f5d0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x3e0c0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x3e059
movsd 0x20(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNPolynomial.cpp
// Function: gaps::RNPolynomialTerm::Evaluate(double const* const*) const
RNScalar RNPolynomialTerm::
Evaluate(double const* const* x) const
{
  // Evaluate the term (in format suitable for CERES)
  RNScalar result = c;
  for (int i = 0; i < NVariables(); i++) {
    int k = Variable(i);
    if (e[i] == 1.0) result *= x[k][0];
    else if (e[i] == 2.0) result *= x[k][0] * x[k][0];
    else if ((e[i] < 0) && RNIsZero(x[k][0])) result *= RN_INFINITY;
    else result *= pow(x[k][0], e[i]);
  }
  return result;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x3f6b0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x3e261
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x3f6e0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x18(%rsp)
movq 0x20(%rax), %rax
movslq 0x1c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x6cee6(%rip), %xmm1    # 0xab020
ucomisd %xmm1, %xmm0
jne 0x3e165
jp 0x3e165
movq 0x28(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x3e24f
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x1c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x6d858(%rip), %xmm1    # 0xab9d8
ucomisd %xmm1, %xmm0
jne 0x3e1bd
jp 0x3e1bd
movq 0x28(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
movq 0x28(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
mulsd (%rax), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x3e24d
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x1c(%rsp), %rcx
xorps %xmm0, %xmm0
ucomisd (%rax,%rcx,8), %xmm0
jbe 0x3e215
movq 0x28(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
leaq 0x8c0ea(%rip), %rax     # 0xca2d8
movsd (%rax), %xmm1
callq 0xb660
cmpl $0x0, %eax
je 0x3e215
leaq 0x8c0e5(%rip), %rax     # 0xca2e8
movsd (%rax), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x3e24b
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movslq 0x18(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movsd (%rcx), %xmm0
movq 0x20(%rax), %rax
movslq 0x1c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm1
callq 0x44a0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x3e24d
jmp 0x3e24f
jmp 0x3e251
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x3e0eb
movsd 0x20(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNPolynomial.cpp
// Function: gaps::RNPolynomial::PartialDerivative(double const*, int) const
RNScalar RNPolynomial::
PartialDerivative(const RNScalar *x, int variable) const
{
  // Return sum of term partial derivatives for variable
  RNScalar sum = 0;
  for (int i = 0; i < NTerms(); i++) {
    RNPolynomialTerm *term = Term(i);
    sum += term->PartialDerivative(x, variable);
  }
  return sum;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x3f5c0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x3e2f8
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x3f5d0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl 0x34(%rsp), %edx
callq 0x3e310
addsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x3e29d
movsd 0x28(%rsp), %xmm0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNPolynomial.cpp
// Function: gaps::RNPolynomial::PartialDerivative(double const* const*, int) const
RNScalar RNPolynomial::
PartialDerivative(double const* const* x, int variable) const
{
  // Return sum of term partial derivatives for variable
  RNScalar sum = 0;
  for (int i = 0; i < NTerms(); i++) {
    RNPolynomialTerm *term = Term(i);
    sum += term->PartialDerivative(x, variable);
  }
  return sum;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x3f5c0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x3e6c8
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x3f5d0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl 0x34(%rsp), %edx
callq 0x3e6e0
addsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x3e66d
movsd 0x28(%rsp), %xmm0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNPolynomial.cpp
// Function: gaps::RNPolynomial::Print(_IO_FILE*) const
void RNPolynomial::
Print(FILE *fp) const
{
  // Print polynomial
  printf("{ ");
  for (int i = 0; i < NTerms(); i++) {
    RNPolynomialTerm *term = Term(i);
    fprintf(fp, "  ");
    term->Print(fp);
  }
  printf(" }\n");
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x6ddd7(%rip), %rdi     # 0xac816
movb $0x0, %al
callq 0x4050
movl $0x0, 0x24(%rsp)
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x3f5c0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x3eaac
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x3f5d0
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x6e04e(%rip), %rsi     # 0xacad7
movb $0x0, %al
callq 0x43e0
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x3eac0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x3ea4e
leaq 0x6dd66(%rip), %rdi     # 0xac819
movb $0x0, %al
callq 0x4050
addq $0x38, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNPolynomial.cpp
// Function: gaps::RNPolynomialTerm::Print(_IO_FILE*) const
void RNPolynomialTerm::
Print(FILE *fp) const
{
  // Print term
  fprintf(fp, "%g ", Coefficient());
  for (int j = 0; j < NVariables(); j++) {
    fprintf(fp, "(%d^%g) ", Variable(j), Exponent(j));
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x3f6a0
movq 0x18(%rsp), %rdi
leaq 0x6d4d1(%rip), %rsi     # 0xabfc4
movb $0x1, %al
callq 0x43e0
movl $0x0, 0x24(%rsp)
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x3f6b0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x3eb6a
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movl 0x24(%rsp), %esi
callq 0x3f6e0
movq 0x10(%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x24(%rsp), %esi
callq 0x3f700
movq (%rsp), %rdi
movl 0x8(%rsp), %edx
leaq 0x6dcc7(%rip), %rsi     # 0xac81d
movb $0x1, %al
callq 0x43e0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x3eb02
addq $0x38, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNPolynomial.cpp
// Function: gaps::RNPolynomialTerm::HasVariables(int, int const*, double const*) const
RNBoolean RNPolynomialTerm::
HasVariables(int query_n, const int *query_v, const RNScalar *query_e) const
{
  // Check if query has same number of variables
  if (n != query_n) return FALSE;

  // Compare variables and exponents 
  for (int i = 0; i < n; i++) {
    // This assumes variables are sorted
    if (v[i] != query_v[i]) return FALSE;
    if (e[i] != query_e[i]) return FALSE;
  }

  // Passed all tests
  return TRUE;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x38(%rsp)
movl 0x8(%rax), %eax
cmpl -0x14(%rsp), %eax
je 0x3eba3
movl $0x0, -0x4(%rsp)
jmp 0x3ec2c
movl $0x0, -0x2c(%rsp)
movq -0x38(%rsp), %rcx
movl -0x2c(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0x3ec24
movq -0x38(%rsp), %rax
movq 0x18(%rax), %rax
movslq -0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x20(%rsp), %rcx
movslq -0x2c(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x3ebe3
movl $0x0, -0x4(%rsp)
jmp 0x3ec2c
movq -0x38(%rsp), %rax
movq 0x20(%rax), %rax
movslq -0x2c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rsp), %rax
movslq -0x2c(%rsp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jne 0x3ec0b
jp 0x3ec0b
jmp 0x3ec15
movl $0x0, -0x4(%rsp)
jmp 0x3ec2c
jmp 0x3ec17
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0x3ebab
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNPolynomial.cpp
// Function: gaps::RNPolynomial::FindTermWithVariables(int, int*, double*) const
RNPolynomialTerm *RNPolynomial::
FindTermWithVariables(int n, int *v, RNScalar *e) const
{
  // Check if query has variables
  if (n == 0) {
    // Check for constant term (must be first)
    RNPolynomialTerm *term = Term(0);
    if (term->IsConstant()) return term;
    else return NULL;
  }
  else {
    // Find matching term
    for (int i = 0; i < NTerms(); i++) {
      RNPolynomialTerm *term = Term(i);
      assert((i == 0) || (!term->IsConstant()));
      if (term->HasVariables(n, v, e)) return term;
    }
  }

  // Did not find matching term
  return NULL;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x44(%rsp)
jne 0x3eca2
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x3f5d0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x3d0f0
cmpl $0x0, %eax
je 0x3ec97
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x3ed1c
movq $0x0, 0x50(%rsp)
jmp 0x3ed1c
movl $0x0, 0x24(%rsp)
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x3f5c0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x3ed11
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x3f5d0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl 0x44(%rsp), %esi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
callq 0x3eb70
cmpl $0x0, %eax
je 0x3ed02
movq 0x18(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x3ed1c
jmp 0x3ed04
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x3ecaa
jmp 0x3ed13
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNPolynomial.cpp
// Function: gaps::RNPolynomialTerm::UpdateVariableRange(int&, int&) const
void RNPolynomialTerm::
UpdateVariableRange(int& min_v, int& max_v) const
{
  // Update indices
  for (int i = 0; i < n; i++) {
    if (v[i] > max_v) max_v = v[i];
    if (v[i] < min_v) min_v = v[i];
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movl $0x0, -0x1c(%rsp)
movq -0x28(%rsp), %rcx
movl -0x1c(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0x3edd5
movq -0x28(%rsp), %rax
movq 0x18(%rax), %rax
movslq -0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rsp), %rcx
cmpl (%rcx), %eax
jle 0x3ed91
movq -0x28(%rsp), %rax
movq 0x18(%rax), %rax
movslq -0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movq -0x28(%rsp), %rax
movq 0x18(%rax), %rax
movslq -0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x3edc3
movq -0x28(%rsp), %rax
movq 0x18(%rax), %rax
movslq -0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x10(%rsp), %rax
movl %ecx, (%rax)
jmp 0x3edc5
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x3ed51
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNPolynomial.cpp
// Function: gaps::RNPolynomialTerm::UpdateVariableIndex(int, int&, int*, int, int*, int*, int) const
void RNPolynomialTerm::
UpdateVariableIndex(int max_variables, int& variable_count, 
  int *variable_marks, int current_mark, 
  int *index_to_variable, int *variable_to_index,
  RNBoolean remap_variables) const
{
  // Just checking
  assert(variable_to_index || !remap_variables);

  // Process each variable
  for (int i = 0; i < n; i++) {
    assert((v[i] >= 0) && (v[i] < max_variables));
    // Update index
    if (variable_marks[v[i]] != current_mark) {
      if (index_to_variable) index_to_variable[variable_count] = v[i];
      if (variable_to_index) variable_to_index[v[i]] = variable_count;
      variable_marks[v[i]] = current_mark;
      variable_count++;
    }

    // Remap variable
    if (remap_variables) {
      v[i] = variable_to_index[v[i]];
    }
  }
}

// Assembly:
movl 0x10(%rsp), %eax
movq 0x8(%rsp), %rax
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movl %r8d, -0x24(%rsp)
movq %r9, -0x30(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x40(%rsp)
movl $0x0, -0x34(%rsp)
movq -0x40(%rsp), %rcx
movl -0x34(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0x3ef05
movq -0x40(%rsp), %rcx
movq -0x20(%rsp), %rax
movq 0x18(%rcx), %rcx
movslq -0x34(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x24(%rsp), %eax
je 0x3eec6
cmpq $0x0, -0x30(%rsp)
je 0x3ee73
movq -0x40(%rsp), %rax
movq 0x18(%rax), %rax
movslq -0x34(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x30(%rsp), %rax
movq -0x18(%rsp), %rcx
movslq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
cmpq $0x0, 0x8(%rsp)
je 0x3ee9c
movq -0x40(%rsp), %rcx
movq -0x18(%rsp), %rax
movl (%rax), %edx
movq 0x8(%rsp), %rax
movq 0x18(%rcx), %rcx
movslq -0x34(%rsp), %rsi
movslq (%rcx,%rsi,4), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x40(%rsp), %rcx
movl -0x24(%rsp), %edx
movq -0x20(%rsp), %rax
movq 0x18(%rcx), %rcx
movslq -0x34(%rsp), %rsi
movslq (%rcx,%rsi,4), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
cmpl $0x0, 0x10(%rsp)
je 0x3eef3
movq -0x40(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x18(%rax), %rdx
movslq -0x34(%rsp), %rsi
movslq (%rdx,%rsi,4), %rdx
movl (%rcx,%rdx,4), %edx
movq 0x18(%rax), %rax
movslq -0x34(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x3eef5
movl -0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rsp)
jmp 0x3ee18
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNPolynomial.cpp
// Function: gaps::RNPolynomialTerm::RNPolynomialTerm(gaps::RNPolynomialTerm const&)
RNPolynomialTerm::
RNPolynomialTerm(const RNPolynomialTerm& term)
  : n(term.n),
    c(term.c)
{
  // Copy stuff from term
  if (n == 0) {
#ifndef RN_POLYNOMIAL_TERM_STATIC_MEMORY
    v = NULL;
    e = NULL;
#endif
  }
  else {
#ifndef RN_POLYNOMIAL_TERM_STATIC_MEMORY
    v = new int [ n ];
    e = new RNScalar [ n ];
#endif
    for (int i = 0; i < n; i++) {
      v[i] = term.v[i];
      e[i] = term.e[i];
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
cmpl $0x0, 0x8(%rax)
jne 0x3f3a2
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
jmp 0x3f471
movq 0x8(%rsp), %rax
movslq 0x8(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4030
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movslq 0x8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4030
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0x3f46f
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq 0x14(%rsp), %rdx
movl (%rcx,%rdx,4), %esi
movq 0x18(%rax), %rcx
movslq 0x14(%rsp), %rdx
movl %esi, (%rcx,%rdx,4)
movq 0x18(%rsp), %rcx
movq 0x20(%rcx), %rcx
movslq 0x14(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x20(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x3f411
jmp 0x3f471
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNPolynomial.cpp
// Function: gaps::RNPolynomialTerm::~RNPolynomialTerm()
RNPolynomialTerm::
~RNPolynomialTerm(void)
{
  // Delete stuff
#ifndef RN_POLYNOMIAL_TERM_STATIC_MEMORY
  if (v) delete [] v;
  if (e) delete [] e;
#endif
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rax)
je 0x3f4ba
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x3f4b8
movq 0x10(%rsp), %rdi
callq 0x4360
jmp 0x3f4ba
movq 0x18(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3f4e6
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x3f4e4
movq 0x8(%rsp), %rdi
callq 0x4360
jmp 0x3f4e6
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNPolynomial.cpp
// Function: gaps::RNPolynomialTerm::Empty()
void RNPolynomialTerm::
Empty(void)
{
  // Delete stuff
#ifndef RN_POLYNOMIAL_TERM_STATIC_MEMORY
  if (v) delete [] v;
  if (e) delete [] e;
#endif
  c = 0;
  n = 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rax)
je 0x3f52a
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x3f528
movq 0x10(%rsp), %rdi
callq 0x4360
jmp 0x3f52a
movq 0x18(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3f556
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x3f554
movq 0x8(%rsp), %rdi
callq 0x4360
jmp 0x3f556
movq 0x18(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movl $0x0, 0x8(%rax)
addq $0x28, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::RNAlgebraic(gaps::RNPolynomial*)
RNAlgebraic::
RNAlgebraic(RNPolynomial *p)
  : operation(RN_ZERO_OPERATION),
    polynomial(NULL)
{
  // NOTE: THIS TAKES OVER MANAGEMENT OF MEMORY FOR POLYNOMIAL
  // SPECIFICALLY, POLYNOMIAL WILL BE DELETED WHEN ALGEBRAIC IS DECONSTRUCTED

  // Initialize operands
  operands[0] = NULL;
  operands[1] = NULL;

  // Check polynomial
  if (!p) {
    return;
  }
  else if (p->IsZero()) {
    delete p;
    return;
  }

  // Assign polynomial
  operation = RN_POLYNOMIAL_OPERATION;
  this->polynomial = p;

  // Just checking
  assert(IsValid());
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x89f49(%rip), %rcx     # 0xc9818
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
cmpq $0x0, 0x18(%rsp)
jne 0x3f8ff
jmp 0x3f950
movq 0x18(%rsp), %rdi
callq 0x3cf90
cmpl $0x0, %eax
je 0x3f939
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x3f937
movq 0x8(%rsp), %rdi
callq 0x3cac0
movq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x4290
jmp 0x3f950
jmp 0x3f93b
movq 0x10(%rsp), %rax
movl $0x1, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x20(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::RNAlgebraic(gaps::RNAlgebraic*)
RNAlgebraic::
RNAlgebraic(RNAlgebraic *algebraic)
  : operation(RN_ZERO_OPERATION),
    polynomial(NULL)
{
  // NOTE: THIS TAKES OVER MANAGEMENT OF MEMORY FOR ALGEBRAIC 
  // SPECIFICALLY, ALGEBRAIC WILL BE DELETED WHEN THIS ALGEBRAIC IS DECONSTRUCTED

  // Initialize operands
  operands[0] = NULL;
  operands[1] = NULL;

  // Check algebraic
  if (!algebraic) {
    return;
  }
  else if (algebraic->IsZero()) {
    delete algebraic;
    return;
  }

  // Copy stuff from algebraic
  operation = algebraic->operation;
  polynomial = algebraic->polynomial;
  operands[0] = algebraic->operands[0];
  operands[1] = algebraic->operands[1];

  // Delete algebraic
  algebraic->operation = RN_ZERO_OPERATION;
  algebraic->operands[0] = NULL;
  algebraic->operands[1] = NULL;
  algebraic->polynomial = NULL;
  delete algebraic;

  // Just checking
  assert(IsValid());
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x89e99(%rip), %rcx     # 0xc9818
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
cmpq $0x0, 0x18(%rsp)
jne 0x3f9b2
jmp 0x3fa66
movq 0x18(%rsp), %rdi
callq 0x3fa70
cmpl $0x0, %eax
je 0x3f9e1
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x3f9dc
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x3fa66
jmp 0x3f9e3
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x3fa66
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::IsZero() const
RNBoolean RNAlgebraic::
IsZero(void) const
{
  // Return if algebraic is definitely zero for all variable settings
  switch(operation) {
  case RN_ZERO_OPERATION:
    return TRUE;

  case RN_POLYNOMIAL_OPERATION:
    return polynomial->IsZero();

  case RN_ADD_OPERATION:
  case RN_SUBTRACT_OPERATION:
    return (operands[0]->IsZero() && operands[1]->IsZero());

  case RN_MULTIPLY_OPERATION:
    return (operands[0]->IsZero() || operands[1]->IsZero());

  case RN_DIVIDE_OPERATION:
    return (operands[0]->IsZero() && !operands[1]->IsZero());

  case RN_POW_OPERATION:
    return (operands[0]->IsZero());
  }

  // Should never get here
  RNAbort("Unrecognized operation %d in algebraic");
  return FALSE;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x8(%rax), %eax
movq %rax, 0x10(%rsp)
subq $0x6, %rax
ja 0x3fbad
movq 0x10(%rsp), %rax
leaq 0x6cd87(%rip), %rcx     # 0xac828
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, 0x24(%rsp)
jmp 0x3fbc3
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x3cf90
movl %eax, 0x24(%rsp)
jmp 0x3fbc3
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x3fa70
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x7(%rsp)
je 0x3fb01
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x3fa70
cmpl $0x0, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0x3fbc3
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x3fa70
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0x6(%rsp)
jne 0x3fb46
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x3fa70
cmpl $0x0, %eax
setne %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0x3fbc3
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x3fa70
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x5(%rsp)
je 0x3fb8a
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x3fa70
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, 0x5(%rsp)
movb 0x5(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0x3fbc3
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x3fa70
movl %eax, 0x24(%rsp)
jmp 0x3fbc3
leaq 0x6ce5f(%rip), %rdi     # 0xaca13
movb $0x0, %al
callq 0x4c6e0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::RNAlgebraic(double, int, double)
RNAlgebraic::
RNAlgebraic(RNScalar c, int v, RNScalar e)
  : operation(RN_ZERO_OPERATION),
    polynomial(NULL)
{
  // Initialize operands
  operands[0] = NULL;
  operands[1] = NULL;

  // Initialize polynomial
  if (c != 0) {
    polynomial = new RNPolynomial(c, v, e);
    operation = RN_POLYNOMIAL_OPERATION;
  }

  // Just checking
  assert(IsValid());
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movsd %xmm1, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x89c1e(%rip), %rcx     # 0xc9818
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movsd 0x38(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3fc33
jp 0x3fc33
jmp 0x3fc95
movl $0x10, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movsd 0x38(%rsp), %xmm0
movl 0x34(%rsp), %esi
movsd 0x28(%rsp), %xmm1
callq 0x3c670
jmp 0x3fc5f
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x20(%rax)
movl $0x1, 0x8(%rax)
jmp 0x3fc95
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x10, %esi
callq 0x4290
jmp 0x3fc9a
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x44b0
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::RNAlgebraic(double, int, int const*, double const*, int)
RNAlgebraic::
RNAlgebraic(RNScalar c, int nv, const int *v, const RNScalar *e, RNBoolean already_sorted)
  : operation(RN_ZERO_OPERATION),
    polynomial(NULL)
{
  // Initialize operands
  operands[0] = NULL;
  operands[1] = NULL;

  // Initialize polynomial
  if (c != 0) {
    polynomial = new RNPolynomial(c, nv, v, e, already_sorted);
    operation = RN_POLYNOMIAL_OPERATION;
  }

  // Just checking
  assert(IsValid());
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movsd %xmm0, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movl %r8d, 0x2c(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x89b35(%rip), %rcx     # 0xc9818
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movsd 0x48(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3fd1c
jp 0x3fd1c
jmp 0x3fd87
movl $0x10, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movsd 0x48(%rsp), %xmm0
movl 0x44(%rsp), %esi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movl 0x2c(%rsp), %r8d
callq 0x3c6e0
jmp 0x3fd51
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x20(%rax)
movl $0x1, 0x8(%rax)
jmp 0x3fd87
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x10, %esi
callq 0x4290
jmp 0x3fd8c
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x44b0
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::RNAlgebraic(gaps::RNPolynomial const&, int)
RNAlgebraic::
RNAlgebraic(const RNPolynomial& p, int dummy)
  : operation(RN_ZERO_OPERATION),
    polynomial(NULL)
{
  // Initialize operands
  operands[0] = NULL;
  operands[1] = NULL;

  // Check polynomial
  if (p.IsZero()) return;

  // Initialize polynomial
  this->operation = RN_POLYNOMIAL_OPERATION;
  this->polynomial = new RNPolynomial(p);

  // Just checking
  assert(IsValid());
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x89a55(%rip), %rcx     # 0xc9818
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq 0x28(%rsp), %rdi
callq 0x3cf90
cmpl $0x0, %eax
je 0x3fdfa
jmp 0x3fe33
movq 0x8(%rsp), %rax
movl $0x1, 0x8(%rax)
movl $0x10, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rsi
callq 0x3c530
jmp 0x3fe26
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x20(%rax)
addq $0x38, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x10, %esi
callq 0x4290
movq 0x18(%rsp), %rdi
callq 0x44b0
nop
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::RNAlgebraic(gaps::RNAlgebraic const&)
RNAlgebraic::
RNAlgebraic(const RNAlgebraic& algebraic)
  : operation(RN_ZERO_OPERATION),
    polynomial(NULL)
{
  // Initialize operands
  operands[0] = NULL;
  operands[1] = NULL;

  // Check algebraic
  if (algebraic.IsZero()) return;

  // Copy operands
  switch(algebraic.operation) {
  case RN_ZERO_OPERATION:
    break;

  case RN_POLYNOMIAL_OPERATION:
    assert(algebraic.polynomial);
    operation = algebraic.operation;
    polynomial = new RNPolynomial(*(algebraic.polynomial));
    break;

  default:
    assert(algebraic.operands[0]);
    assert(algebraic.operands[1]);
    operation = algebraic.operation;
    operands[0] = new RNAlgebraic(*(algebraic.operands[0]));
    operands[1] = new RNAlgebraic(*(algebraic.operands[1]));
    break;
  }

  // Just checking
  assert(IsValid());
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x89999(%rip), %rcx     # 0xc9818
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq 0x38(%rsp), %rdi
callq 0x3fa70
cmpl $0x0, %eax
je 0x3feb9
jmp 0x3fff8
movq 0x38(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x1c(%rsp)
testl %eax, %eax
je 0x3fed6
jmp 0x3fecb
movl 0x1c(%rsp), %eax
subl $0x1, %eax
je 0x3fedb
jmp 0x3ff45
jmp 0x3fff8
movq 0x20(%rsp), %rax
movq 0x38(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movl $0x10, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x3c530
jmp 0x3ff10
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x3fff8
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl $0x10, %esi
callq 0x4290
jmp 0x3fffd
movq 0x20(%rsp), %rax
movq 0x38(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x3fe60
jmp 0x3ff7a
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rax)
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x3fe60
jmp 0x3ffac
movq 0x20(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x3fff8
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x3fffd
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x3fffd
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x44b0
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::RNAlgebraic(int, double, double)
RNAlgebraic::
RNAlgebraic(int op, RNScalar operand1, RNScalar operand2)
  : operation(RN_ZERO_OPERATION),
    polynomial(NULL)
{
  // Initialize operands
  operands[0] = NULL;
  operands[1] = NULL;

  // Construct 
  Construct(op, operand1, operand2);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x897e3(%rip), %rax     # 0xc9818
addq $0x10, %rax
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
movq $0x0, 0x20(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movl 0x1c(%rsp), %esi
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
xorl %edx, %edx
callq 0x40080
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::RNAlgebraic(int, double, gaps::RNPolynomial*)
RNAlgebraic::
RNAlgebraic(int op, RNScalar operand1, RNPolynomial *operand2)
  : operation(RN_ZERO_OPERATION),
    polynomial(NULL)
{
  // Initialize operands
  operands[0] = NULL;
  operands[1] = NULL;

  // Construct 
  Construct(op, operand1, operand2);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x892c4(%rip), %rax     # 0xc9818
addq $0x10, %rax
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
movq $0x0, 0x20(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movl 0x1c(%rsp), %esi
movsd 0x10(%rsp), %xmm0
movq 0x8(%rsp), %rdx
xorl %ecx, %ecx
callq 0x405a0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::RNAlgebraic(int, double, gaps::RNAlgebraic*)
RNAlgebraic::
RNAlgebraic(int op, RNScalar operand1, RNAlgebraic *operand2)
  : operation(RN_ZERO_OPERATION),
    polynomial(NULL)
{
  // Initialize operands
  operands[0] = NULL;
  operands[1] = NULL;

  // Construct 
  Construct(op, operand1, operand2);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x88904(%rip), %rax     # 0xc9818
addq $0x10, %rax
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
movq $0x0, 0x20(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movl 0x1c(%rsp), %esi
movsd 0x10(%rsp), %xmm0
movq 0x8(%rsp), %rdx
xorl %ecx, %ecx
callq 0x40f60
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::Construct(int, double, gaps::RNAlgebraic*, int)
void RNAlgebraic::
Construct(int op, RNScalar operand1, RNAlgebraic *operand2, RNBoolean force)
{
  // NOTE: THIS TAKES OVER MANAGEMENT OF MEMORY FOR OPERAND2
  // SPECIFICALLY, OPERANDS WILL BE DELETED WHEN ALGEBRAIC IS DECONSTRUCTED
  assert(operand2);
  assert(operand2->IsValid());

  // Check type of operand2
  if (!force && (operand2->operation == RN_POLYNOMIAL_OPERATION)) {
    // Construct with polynomial
    Construct(op, operand1, operand2->polynomial);
    operand2->operation = RN_ZERO_OPERATION;
    operand2->operands[0] = NULL;
    operand2->operands[1] = NULL;
    operand2->polynomial = NULL;
    delete operand2;
  }
  else {
    // Construct with algebraic
    Construct(op, new RNAlgebraic(operand1, 0), operand2, TRUE);
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movsd %xmm0, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movl %ecx, 0x34(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x34(%rsp)
jne 0x41007
movq 0x38(%rsp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x41007
movq 0x18(%rsp), %rdi
movl 0x4c(%rsp), %esi
movsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rdx
xorl %ecx, %ecx
callq 0x405a0
movq 0x38(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x38(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x38(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x38(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x41005
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x4107c
movl 0x4c(%rsp), %eax
movl %eax, 0x4(%rsp)
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movsd 0x40(%rsp), %xmm0
xorl %r8d, %r8d
movl %r8d, %ecx
movl %r8d, %esi
movq %rcx, %rdx
callq 0x3fcb0
jmp 0x4103d
movq 0x8(%rsp), %rdx
movl 0x4(%rsp), %esi
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rcx
movl $0x1, %r8d
callq 0x42b30
jmp 0x4107c
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x41081
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x44b0
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::RNAlgebraic(int, gaps::RNPolynomial*, double)
RNAlgebraic::
RNAlgebraic(int op, RNPolynomial *operand1, RNScalar operand2)
  : operation(RN_ZERO_OPERATION),
    polynomial(NULL)
{
  // Initialize operands
  operands[0] = NULL;
  operands[1] = NULL;

  // Construct 
  Construct(op, operand1, operand2);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x88764(%rip), %rax     # 0xc9818
addq $0x10, %rax
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
movq $0x0, 0x20(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
movsd 0x8(%rsp), %xmm0
xorl %ecx, %ecx
callq 0x41100
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::RNAlgebraic(int, gaps::RNPolynomial*, gaps::RNPolynomial*)
RNAlgebraic::
RNAlgebraic(int op, RNPolynomial *operand1, RNPolynomial *operand2)
  : operation(RN_ZERO_OPERATION),
    polynomial(NULL)
{
  // Initialize operands
  operands[0] = NULL;
  operands[1] = NULL;

  // Construct 
  Construct(op, operand1, operand2);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x87ff5(%rip), %rax     # 0xc9818
addq $0x10, %rax
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
movq $0x0, 0x20(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
xorl %r8d, %r8d
callq 0x41870
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::RNAlgebraic(int, gaps::RNPolynomial*, gaps::RNAlgebraic*)
RNAlgebraic::
RNAlgebraic(int op, RNPolynomial *operand1, RNAlgebraic *operand2)
  : operation(RN_ZERO_OPERATION),
    polynomial(NULL)
{
  // Initialize operands
  operands[0] = NULL;
  operands[1] = NULL;

  // Construct 
  Construct(op, operand1, operand2);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x87355(%rip), %rax     # 0xc9818
addq $0x10, %rax
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
movq $0x0, 0x20(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
xorl %r8d, %r8d
callq 0x42510
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::Construct(int, gaps::RNPolynomial*, gaps::RNAlgebraic*, int)
void RNAlgebraic::
Construct(int op, RNPolynomial *operand1, RNAlgebraic *operand2, RNBoolean force)
{
  // NOTE: THIS TAKES OVER MANAGEMENT OF MEMORY FOR OPERANDS
  // SPECIFICALLY, OPERANDS WILL BE DELETED WHEN ALGEBRAIC IS DECONSTRUCTED

  // Check types of operands
  if (!force && (operand2->operation == RN_POLYNOMIAL_OPERATION)) {
    Construct(op, operand1, operand2->polynomial);
    operand2->operation = RN_ZERO_OPERATION;
    operand2->operands[0] = NULL;
    operand2->operands[1] = NULL;
    operand2->polynomial = NULL;
    delete operand2;
  }
  else if (!force && (operand1->NTerms() == 1) && (operand1->Term(0)->Degree() == 0)) {
    Construct(op, operand1->Term(0)->Coefficient(), operand2);
    delete operand1;
  }
  else {
    Construct(op, new RNAlgebraic(operand1), operand2, TRUE);
  }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movl %r8d, 0x44(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpl $0x0, 0x44(%rsp)
jne 0x425ba
movq 0x48(%rsp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x425ba
movq 0x28(%rsp), %rdi
movl 0x5c(%rsp), %esi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rax
movq 0x20(%rax), %rcx
xorl %r8d, %r8d
callq 0x41870
movq 0x48(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x48(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x48(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x48(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x425b5
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x426b9
cmpl $0x0, 0x44(%rsp)
jne 0x4264f
movq 0x50(%rsp), %rdi
callq 0x3f5c0
cmpl $0x1, %eax
jne 0x4264f
movq 0x50(%rsp), %rdi
xorl %esi, %esi
callq 0x3f5d0
movq %rax, %rdi
callq 0x3cc40
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4264f
jp 0x4264f
movl 0x5c(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x50(%rsp), %rdi
xorl %esi, %esi
callq 0x3f5d0
movq %rax, %rdi
callq 0x3f6a0
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x48(%rsp), %rdx
xorl %ecx, %ecx
callq 0x40f60
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x4264d
movq 0x18(%rsp), %rdi
callq 0x3cac0
movq 0x18(%rsp), %rdi
movl $0x10, %esi
callq 0x4290
jmp 0x426b7
movl 0x5c(%rsp), %eax
movl %eax, 0x4(%rsp)
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rsi
callq 0x3f8b0
jmp 0x42678
movq 0x8(%rsp), %rdx
movl 0x4(%rsp), %esi
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rcx
movl $0x1, %r8d
callq 0x42b30
jmp 0x426b7
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x426be
jmp 0x426b9
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x44b0
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::RNAlgebraic(int, gaps::RNAlgebraic*, double)
RNAlgebraic::
RNAlgebraic(int op, RNAlgebraic *operand1, RNScalar operand2)
  : operation(RN_ZERO_OPERATION),
    polynomial(NULL)
{
  // Initialize operands
  operands[0] = NULL;
  operands[1] = NULL;

  // Construct 
  Construct(op, operand1, operand2);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x87124(%rip), %rax     # 0xc9818
addq $0x10, %rax
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
movq $0x0, 0x20(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
movsd 0x8(%rsp), %xmm0
xorl %ecx, %ecx
callq 0x42740
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::Construct(int, gaps::RNAlgebraic*, double, int)
void RNAlgebraic::
Construct(int op, RNAlgebraic *operand1, RNScalar operand2, RNBoolean force)
{
  // Check type of operand1
  if (!force && (operand1->operation == RN_POLYNOMIAL_OPERATION)) {
    Construct(op, operand1->polynomial, operand2);
    operand1->operation = RN_ZERO_OPERATION;
    operand1->operands[0] = NULL;
    operand1->operands[1] = NULL;
    operand1->polynomial = NULL;
    delete operand1;
  }
  else {
    Construct(op, operand1, new RNAlgebraic(operand2, 0), TRUE);
  }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq %rdx, 0x50(%rsp)
movsd %xmm0, 0x48(%rsp)
movl %ecx, 0x44(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpl $0x0, 0x44(%rsp)
jne 0x427e7
movq 0x50(%rsp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x427e7
movq 0x28(%rsp), %rdi
movl 0x5c(%rsp), %esi
movq 0x50(%rsp), %rax
movq 0x20(%rax), %rdx
movsd 0x48(%rsp), %xmm0
xorl %ecx, %ecx
callq 0x41100
movq 0x50(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x50(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x50(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x50(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x427e5
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x42866
movl 0x5c(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movsd 0x48(%rsp), %xmm0
xorl %r8d, %r8d
movl %r8d, %ecx
movl %r8d, %esi
movq %rcx, %rdx
callq 0x3fcb0
jmp 0x42827
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %esi
movq 0x28(%rsp), %rdi
movl $0x1, %r8d
callq 0x42b30
jmp 0x42866
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x4286b
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x44b0
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::RNAlgebraic(int, gaps::RNAlgebraic*, gaps::RNPolynomial*)
RNAlgebraic::
RNAlgebraic(int op, RNAlgebraic *operand1, RNPolynomial *operand2)
  : operation(RN_ZERO_OPERATION),
    polynomial(NULL)
{
  // Initialize operands
  operands[0] = NULL;
  operands[1] = NULL;

  // Construct 
  Construct(op, operand1, operand2);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x86f75(%rip), %rax     # 0xc9818
addq $0x10, %rax
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
movq $0x0, 0x20(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
xorl %r8d, %r8d
callq 0x428f0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)