LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::Construct(int, gaps::RNAlgebraic*, gaps::RNPolynomial*, int)
void RNAlgebraic::
Construct(int op, RNAlgebraic *operand1, RNPolynomial *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 && (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 if (!force && (operand2->NTerms() == 1) && (operand2->Term(0)->Degree() == 0)) {
    Construct(op, operand1, operand2->Term(0)->Coefficient());
    delete operand2;
  }
  else {
    Construct(op, operand1, new RNAlgebraic(operand2), TRUE);
  }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movl %r8d, 0x54(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpl $0x0, 0x54(%rsp)
jne 0x4299a
movq 0x60(%rsp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x4299a
movq 0x38(%rsp), %rdi
movl 0x6c(%rsp), %esi
movq 0x60(%rsp), %rax
movq 0x20(%rax), %rdx
movq 0x58(%rsp), %rcx
xorl %r8d, %r8d
callq 0x41870
movq 0x60(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x60(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x60(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x60(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, %rax
je 0x42995
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x42ab1
cmpl $0x0, 0x54(%rsp)
jne 0x42a3d
movq 0x58(%rsp), %rdi
callq 0x3f5c0
cmpl $0x1, %eax
jne 0x42a3d
movq 0x58(%rsp), %rdi
xorl %esi, %esi
callq 0x3f5d0
movq %rax, %rdi
callq 0x3cc40
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x42a3d
jp 0x42a3d
movl 0x6c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
xorl %esi, %esi
callq 0x3f5d0
movq %rax, %rdi
callq 0x3f6a0
movq 0x38(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq 0x20(%rsp), %rdx
xorl %ecx, %ecx
callq 0x42740
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x42a3b
movq 0x28(%rsp), %rdi
callq 0x3cac0
movq 0x28(%rsp), %rdi
movl $0x10, %esi
callq 0x4290
jmp 0x42aaf
movl 0x6c(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rsi
callq 0x3f8b0
jmp 0x42a70
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdx
movl 0x4(%rsp), %esi
movq 0x38(%rsp), %rdi
movl $0x1, %r8d
callq 0x42b30
jmp 0x42aaf
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x42ab6
jmp 0x42ab1
addq $0x78, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x44b0
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::RNAlgebraic(int, gaps::RNAlgebraic*, gaps::RNAlgebraic*)
RNAlgebraic::
RNAlgebraic(int op, RNAlgebraic *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 0x86d35(%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 0x42b30
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::~RNAlgebraic()
RNAlgebraic::
~RNAlgebraic(void)
{
  // Just checking
  assert(IsValid());

  // Delete everything
  if (polynomial) delete polynomial;
  if (operands[0]) delete operands[0];
  if (operands[1]) delete operands[1];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x8602e(%rip), %rcx     # 0xc9818
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x20(%rax)
je 0x43827
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x43825
movq 0x10(%rsp), %rdi
callq 0x3cac0
movq 0x10(%rsp), %rdi
movl $0x10, %esi
callq 0x4290
jmp 0x43827
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x43854
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x43852
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x43854
movq 0x18(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4387f
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x4387d
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x4387f
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::Negate()
void RNAlgebraic::
Negate(void)
{
  // Just checking
  assert(IsValid());

  // Flip sign
  switch(operation) {
  case RN_ZERO_OPERATION:
    return;

  case RN_POLYNOMIAL_OPERATION:
    polynomial->Negate();
    return;

  case RN_ADD_OPERATION:
    operands[0]->Negate();
    operands[1]->Negate();
    return;

  case RN_SUBTRACT_OPERATION: {
    RNAlgebraic *swap = operands[0];
    operands[0] = operands[1];
    operands[1] = swap;
    return; }

  case RN_MULTIPLY_OPERATION:
  case RN_DIVIDE_OPERATION:
    operands[0]->Negate();
    return;

  case RN_POW_OPERATION: 
    Multiply(-1.0);
    return;
  }

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x8(%rax), %eax
movq %rax, 0x10(%rsp)
subq $0x6, %rax
ja 0x43972
movq 0x10(%rsp), %rax
leaq 0x68fdf(%rip), %rcx     # 0xac8d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x43980
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x3d470
jmp 0x43980
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x438c0
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x438c0
jmp 0x43980
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x43980
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x438c0
jmp 0x43980
movq 0x8(%rsp), %rdi
movsd 0x6807d(%rip), %xmm0    # 0xab9e8
callq 0x44660
jmp 0x43980
leaq 0x6909a(%rip), %rdi     # 0xaca13
movb $0x0, %al
callq 0x4c6e0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::IsOne() const
RNBoolean RNAlgebraic::
IsOne(void) const
{
  // Return if algebraic algebraic is constant
  switch(operation) {
  case RN_ZERO_OPERATION:
    return FALSE;

  case RN_POLYNOMIAL_OPERATION:
    return polynomial->IsOne();

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

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

  case RN_MULTIPLY_OPERATION:
  case RN_DIVIDE_OPERATION:
    return (operands[0]->IsOne() && operands[1]->IsOne());

  case RN_POW_OPERATION:
    if (operands[0]->IsOne()) return TRUE;
    if (operands[1]->IsZero()) return TRUE;
    return FALSE;
  }

  // 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 0x43b34
movq 0x10(%rsp), %rax
leaq 0x68f2b(%rip), %rcx     # 0xac8ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, 0x24(%rsp)
jmp 0x43b4a
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x3cfd0
movl %eax, 0x24(%rsp)
jmp 0x43b4a
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x43990
cmpl $0x0, %eax
je 0x43a1c
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x3fa70
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0x7(%rsp)
jne 0x43a57
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x43990
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x6(%rsp)
je 0x43a4f
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x3fa70
cmpl $0x0, %eax
setne %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0x43b4a
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x43990
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x5(%rsp)
je 0x43a9c
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x3fa70
cmpl $0x0, %eax
setne %al
movb %al, 0x5(%rsp)
movb 0x5(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0x43b4a
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x43990
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x4(%rsp)
je 0x43ae1
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x43990
cmpl $0x0, %eax
setne %al
movb %al, 0x4(%rsp)
movb 0x4(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0x43b4a
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x43990
cmpl $0x0, %eax
je 0x43b0d
movl $0x1, 0x24(%rsp)
jmp 0x43b4a
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x3fa70
cmpl $0x0, %eax
je 0x43b2a
movl $0x1, 0x24(%rsp)
jmp 0x43b4a
movl $0x0, 0x24(%rsp)
jmp 0x43b4a
leaq 0x68ed8(%rip), %rdi     # 0xaca13
movb $0x0, %al
callq 0x4c6e0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::IsConstant() const
RNBoolean RNAlgebraic::
IsConstant(void) const
{
  // Return if algebraic algebraic is constant
  switch(operation) {
  case RN_ZERO_OPERATION:
    return TRUE;

  case RN_POLYNOMIAL_OPERATION:
    return polynomial->IsConstant();

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

  case RN_POW_OPERATION:
    if (operands[0]->IsConstant() && operands[1]->IsConstant()) return TRUE;
    if (operands[1]->IsZero()) return TRUE;
    return FALSE;
  }

  // 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 0x43c57
movq 0x10(%rsp), %rax
leaq 0x68d77(%rip), %rcx     # 0xac908
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, 0x24(%rsp)
jmp 0x43c6d
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x3d070
movl %eax, 0x24(%rsp)
jmp 0x43c6d
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x43b60
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x7(%rsp)
je 0x43bf1
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x43b60
cmpl $0x0, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0x43c6d
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x43b60
cmpl $0x0, %eax
je 0x43c30
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x43b60
cmpl $0x0, %eax
je 0x43c30
movl $0x1, 0x24(%rsp)
jmp 0x43c6d
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x3fa70
cmpl $0x0, %eax
je 0x43c4d
movl $0x1, 0x24(%rsp)
jmp 0x43c6d
movl $0x0, 0x24(%rsp)
jmp 0x43c6d
leaq 0x68db5(%rip), %rdi     # 0xaca13
movb $0x0, %al
callq 0x4c6e0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::IsLinear() const
RNBoolean RNAlgebraic::
IsLinear(void) const
{
  // Return if algebraic is linear
  switch(operation) {
  case RN_ZERO_OPERATION:
    return TRUE;

  case RN_POLYNOMIAL_OPERATION:
    return polynomial->IsLinear();

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

  case RN_MULTIPLY_OPERATION:
    if (operands[0]->IsLinear() && operands[1]->IsConstant()) return TRUE;
    if (operands[0]->IsConstant() && operands[1]->IsLinear()) return TRUE;
    return FALSE;

  case RN_DIVIDE_OPERATION:
    return (operands[0]->IsLinear() && operands[1]->IsConstant());

  case RN_POW_OPERATION:
    return (operands[1]->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 0x43de6
movq 0x10(%rsp), %rax
leaq 0x68c73(%rip), %rcx     # 0xac924
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, 0x24(%rsp)
jmp 0x43dfc
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x3d120
movl %eax, 0x24(%rsp)
jmp 0x43dfc
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x43c80
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x7(%rsp)
je 0x43d11
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x43c80
cmpl $0x0, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0x43dfc
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x43c80
cmpl $0x0, %eax
je 0x43d56
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x43b60
cmpl $0x0, %eax
je 0x43d56
movl $0x1, 0x24(%rsp)
jmp 0x43dfc
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x43b60
cmpl $0x0, %eax
je 0x43d86
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x43c80
cmpl $0x0, %eax
je 0x43d86
movl $0x1, 0x24(%rsp)
jmp 0x43dfc
movl $0x0, 0x24(%rsp)
jmp 0x43dfc
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x43c80
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x6(%rsp)
je 0x43dc3
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x43b60
cmpl $0x0, %eax
setne %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0x43dfc
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x3fa70
movl %eax, 0x24(%rsp)
jmp 0x43dfc
leaq 0x68c26(%rip), %rdi     # 0xaca13
movb $0x0, %al
callq 0x4c6e0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::IsQuadratic() const
RNBoolean RNAlgebraic::
IsQuadratic(void) const
{
  // Return if algebraic is quadratic
  switch(operation) {
  case RN_ZERO_OPERATION:
    return TRUE;

  case RN_POLYNOMIAL_OPERATION:
    return polynomial->IsQuadratic();

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

  case RN_MULTIPLY_OPERATION:
    if (operands[0]->IsQuadratic() && operands[1]->IsConstant()) return TRUE;
    if (operands[0]->IsConstant() && operands[1]->IsQuadratic()) return TRUE;
    if (operands[0]->IsLinear() && operands[1]->IsLinear()) return TRUE;
    return FALSE;

  case RN_DIVIDE_OPERATION:
    return (operands[0]->IsQuadratic() && operands[1]->IsConstant());

  case RN_POW_OPERATION:
    return (operands[1]->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 0x43fa9
movq 0x10(%rsp), %rax
leaq 0x68aff(%rip), %rcx     # 0xac940
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, 0x24(%rsp)
jmp 0x43fbf
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x3d220
movl %eax, 0x24(%rsp)
jmp 0x43fbf
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x43e10
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x7(%rsp)
je 0x43ea1
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x43e10
cmpl $0x0, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0x43fbf
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x43e10
cmpl $0x0, %eax
je 0x43ee6
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x43b60
cmpl $0x0, %eax
je 0x43ee6
movl $0x1, 0x24(%rsp)
jmp 0x43fbf
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x43b60
cmpl $0x0, %eax
je 0x43f19
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x43e10
cmpl $0x0, %eax
je 0x43f19
movl $0x1, 0x24(%rsp)
jmp 0x43fbf
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x43c80
cmpl $0x0, %eax
je 0x43f49
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x43c80
cmpl $0x0, %eax
je 0x43f49
movl $0x1, 0x24(%rsp)
jmp 0x43fbf
movl $0x0, 0x24(%rsp)
jmp 0x43fbf
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x43e10
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x6(%rsp)
je 0x43f86
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x43b60
cmpl $0x0, %eax
setne %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0x43fbf
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x3fa70
movl %eax, 0x24(%rsp)
jmp 0x43fbf
leaq 0x68a63(%rip), %rdi     # 0xaca13
movb $0x0, %al
callq 0x4c6e0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::IsPolynomial() const
RNBoolean RNAlgebraic::
IsPolynomial(void) const
{
  // Return if algebraic is polynomial
  switch(operation) {
  case RN_ZERO_OPERATION:
    return TRUE;

  case RN_POLYNOMIAL_OPERATION:
    return TRUE;

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

  case RN_DIVIDE_OPERATION:
    return (operands[0]->IsPolynomial() && operands[1]->IsConstant());

  case RN_POW_OPERATION:
    return (operands[1]->IsConstant());
  }

  // 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 0x440bc
movq 0x10(%rsp), %rax
leaq 0x6895b(%rip), %rcx     # 0xac95c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, 0x24(%rsp)
jmp 0x440d2
movl $0x1, 0x24(%rsp)
jmp 0x440d2
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x43fd0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x7(%rsp)
je 0x44057
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x43fd0
cmpl $0x0, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0x440d2
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x43fd0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x6(%rsp)
je 0x44099
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x43b60
cmpl $0x0, %eax
setne %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0x440d2
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x43b60
movl %eax, 0x24(%rsp)
jmp 0x440d2
leaq 0x68950(%rip), %rdi     # 0xaca13
movb $0x0, %al
callq 0x4c6e0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::HasVariable(int) const
RNBoolean RNAlgebraic::
HasVariable(int variable) const
{
  // Return whether algebraic has a variable
  switch(operation) {
  case RN_ZERO_OPERATION:
    return FALSE;

  case RN_POLYNOMIAL_OPERATION:
    return polynomial->HasVariable(variable);
   
  default:
    if (operands[0]->HasVariable(variable)) return TRUE;
    if (operands[1]->HasVariable(variable)) return TRUE;
    return FALSE;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x10(%rsp)
testl %eax, %eax
je 0x4410f
jmp 0x44104
movl 0x10(%rsp), %eax
subl $0x1, %eax
je 0x44119
jmp 0x44131
movl $0x0, 0x24(%rsp)
jmp 0x4417b
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movl 0x14(%rsp), %esi
callq 0x3d370
movl %eax, 0x24(%rsp)
jmp 0x4417b
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x14(%rsp), %esi
callq 0x440e0
cmpl $0x0, %eax
je 0x44152
movl $0x1, 0x24(%rsp)
jmp 0x4417b
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movl 0x14(%rsp), %esi
callq 0x440e0
cmpl $0x0, %eax
je 0x44173
movl $0x1, 0x24(%rsp)
jmp 0x4417b
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::NVariables() const
int RNAlgebraic::
NVariables(void) const
{
  // Return whether algebraic has a variable
  switch(operation) {
  case RN_ZERO_OPERATION:
    return 0;

  case RN_POLYNOMIAL_OPERATION:
    return polynomial->NVariables();

  default: {
    // Find variable index range
    int min_v = INT_MAX, max_v = -1;
    UpdateVariableRange(min_v, max_v);

    // Check variable index range
    if (max_v < 0) return 0;
    if (min_v == INT_MAX) return 0;
    if (max_v < min_v) return 0;
    if (max_v == min_v) return 1;
    if (max_v == min_v + 1) return 2;
   
    // Allocate index stuff
    int nvariables = 0;
    int *marks = new int [ max_v + 1 ];
    for (int k = 0; k < max_v + 1; k++) marks[k] = 0;
    UpdateVariableIndex(max_v + 1, nvariables, marks, 1);
    delete [] marks;

    // Return count of unique variables
    return nvariables; }
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x28(%rsp)
testl %eax, %eax
je 0x441bb
jmp 0x441b0
movl 0x28(%rsp), %eax
subl $0x1, %eax
je 0x441c8
jmp 0x441df
movl $0x0, 0x54(%rsp)
jmp 0x4433e
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x3ccc0
movl %eax, 0x54(%rsp)
jmp 0x4433e
movq 0x20(%rsp), %rdi
movl $0x7fffffff, 0x44(%rsp) # imm = 0x7FFFFFFF
movl $0xffffffff, 0x40(%rsp) # imm = 0xFFFFFFFF
leaq 0x44(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x44350
cmpl $0x0, 0x40(%rsp)
jge 0x44217
movl $0x0, 0x54(%rsp)
jmp 0x4433e
cmpl $0x7fffffff, 0x44(%rsp) # imm = 0x7FFFFFFF
jne 0x4422e
movl $0x0, 0x54(%rsp)
jmp 0x4433e
movl 0x40(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x44245
movl $0x0, 0x54(%rsp)
jmp 0x4433e
movl 0x40(%rsp), %eax
cmpl 0x44(%rsp), %eax
jne 0x4425c
movl $0x1, 0x54(%rsp)
jmp 0x4433e
movl 0x40(%rsp), %eax
movl 0x44(%rsp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0x44278
movl $0x2, 0x54(%rsp)
jmp 0x4433e
movl $0x0, 0x3c(%rsp)
movl 0x40(%rsp), %eax
addl $0x1, %eax
cltq
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4030
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl 0x40(%rsp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x442e4
movq 0x30(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x442b7
movq 0x20(%rsp), %rdi
movl 0x40(%rsp), %esi
addl $0x1, %esi
movq 0x30(%rsp), %rcx
leaq 0x3c(%rsp), %rdx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x443e0
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x44336
movq 0x18(%rsp), %rdi
callq 0x4360
movl 0x3c(%rsp), %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::UpdateVariableRange(int&, int&) const
void RNAlgebraic::
UpdateVariableRange(int& min_v, int& max_v) const
{
  // Update variable indices
  switch(operation) {
  case RN_ZERO_OPERATION: 
    return;
    
  case RN_POLYNOMIAL_OPERATION: 
    polynomial->UpdateVariableRange(min_v, max_v);
    return;

  default:
    operands[0]->UpdateVariableRange(min_v, max_v);
    operands[1]->UpdateVariableRange(min_v, max_v);
    return;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x8(%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x44384
jmp 0x44379
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x44386
jmp 0x4439f
jmp 0x443cd
movq (%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x3ce60
jmp 0x443cd
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x44350
movq (%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x44350
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::UpdateVariableIndex(int, int&, int*, int, int*, int*, int) const
void RNAlgebraic::
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);

  // Update variable indices
  switch(operation) {
  case RN_ZERO_OPERATION: 
    return;
    
  case RN_POLYNOMIAL_OPERATION: 
    polynomial->UpdateVariableIndex(max_variables, variable_count, 
      variable_marks, current_mark, index_to_variable, variable_to_index, remap_variables);
    return;

  default:
    operands[0]->UpdateVariableIndex(max_variables, variable_count, 
      variable_marks, current_mark, index_to_variable, variable_to_index, remap_variables);
    operands[1]->UpdateVariableIndex(max_variables, variable_count, 
      variable_marks, current_mark, index_to_variable, variable_to_index, remap_variables);
    return;
  }
}

// Assembly:
subq $0x58, %rsp
movl 0x68(%rsp), %eax
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movl %r8d, 0x34(%rsp)
movq %r9, 0x28(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x24(%rsp)
testl %eax, %eax
je 0x4442c
jmp 0x44421
movl 0x24(%rsp), %eax
subl $0x1, %eax
je 0x44431
jmp 0x4446a
jmp 0x444d8
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
movl 0x4c(%rsp), %esi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movl 0x34(%rsp), %r8d
movq 0x28(%rsp), %r9
movq 0x60(%rsp), %r10
movl 0x68(%rsp), %eax
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x3cee0
jmp 0x444d8
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x4c(%rsp), %esi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movl 0x34(%rsp), %r8d
movq 0x28(%rsp), %r9
movq 0x60(%rsp), %r10
movl 0x68(%rsp), %eax
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x443e0
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
movl 0x4c(%rsp), %esi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movl 0x34(%rsp), %r8d
movq 0x28(%rsp), %r9
movq 0x60(%rsp), %r10
movl 0x68(%rsp), %eax
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x443e0
addq $0x58, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::Empty()
void RNAlgebraic::
Empty(void)
{
  // Just checking
  assert(IsValid());

  // Delete everything
  operation = RN_ZERO_OPERATION;
  if (operands[0]) { delete operands[0]; operands[0] = NULL; }
  if (operands[1]) { delete operands[1]; operands[1] = NULL; }
  if (polynomial) { delete polynomial; polynomial = NULL; }

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x8(%rax)
cmpq $0x0, 0x10(%rax)
je 0x4452d
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x44520
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x44565
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x44558
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x445a8
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x4459b
movq (%rsp), %rdi
callq 0x3cac0
movq (%rsp), %rdi
movl $0x10, %esi
callq 0x4290
movq 0x18(%rsp), %rax
movq $0x0, 0x20(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::Reset(int, gaps::RNAlgebraic*, gaps::RNAlgebraic*)
void RNAlgebraic::
Reset(int operation, RNAlgebraic *operand1, RNAlgebraic *operand2)
{
  // Just checking
  assert(IsValid());
  assert((operation != RN_ZERO_OPERATION) && (operation != RN_POLYNOMIAL_OPERATION));
  assert(operand1 && operand2);

  // Reset everything
  Empty();

  // Set operation
  this->operation = operation;
  this->operands[0] = operand1;
  this->operands[1] = operand2;

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x444e0
movq (%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x18(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::Reset(gaps::RNPolynomial*)
void RNAlgebraic::
Reset(RNPolynomial *polynomial)
{
  // NOTE: THIS TAKES OVER MANAGEMENT OF MEMORY FOR POLYNOMIAL
  // SPECIFICALLY, POLYNOMIAL WILL BE DELETED WHEN ALGEBRAIC IS DECONSTRUCTED

  // Empty everything
  Empty();

  // Set polynomial
  if (polynomial) {
    operation = RN_POLYNOMIAL_OPERATION;
    this->polynomial = polynomial;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x444e0
cmpq $0x0, 0x8(%rsp)
je 0x44658
movq (%rsp), %rax
movl $0x1, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x20(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::Multiply(double)
void RNAlgebraic::
Multiply(RNScalar value)
{
  // Just checking
  assert(IsValid());

  // Check value 
  if (value == 0.0) {
    Empty();
  }
  else if (value != 1.0) {
    switch(operation) {
    case RN_ZERO_OPERATION: 
      return;
    
    case RN_POLYNOMIAL_OPERATION:
      polynomial->Multiply(value);
      return;
    
    default: {
      RNAlgebraic *e = new RNAlgebraic(operation, operands[0], operands[1]);
      operation = RN_MULTIPLY_OPERATION;
      operands[0] = new RNAlgebraic(value, 0);
      operands[1] = e;
      return; }
    }
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movsd 0x38(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x44699
jp 0x44699
movq 0x18(%rsp), %rdi
callq 0x444e0
jmp 0x447b5
movsd 0x38(%rsp), %xmm0
movsd 0x66979(%rip), %xmm1    # 0xab020
ucomisd %xmm1, %xmm0
jne 0x446b4
jp 0x446b4
jmp 0x447b3
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x14(%rsp)
testl %eax, %eax
je 0x446d1
jmp 0x446c6
movl 0x14(%rsp), %eax
subl $0x1, %eax
je 0x446d6
jmp 0x446ef
jmp 0x447b5
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
movsd 0x38(%rsp), %xmm0
callq 0x3d4e0
jmp 0x447b5
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq 0x18(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x8(%rsp)
movl 0x8(%rax), %esi
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
callq 0x42ac0
jmp 0x4471b
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x30(%rsp)
movl $0x4, 0x8(%rax)
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movsd 0x38(%rsp), %xmm0
xorl %r8d, %r8d
movl %r8d, %ecx
movl %r8d, %esi
movq %rcx, %rdx
callq 0x3fcb0
jmp 0x4475e
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x447b5
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x447ba
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x447ba
jmp 0x447b5
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x44b0
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::Add(double)
void RNAlgebraic::
Add(RNScalar value)
{
  // Just checking
  assert(IsValid());

  // Check value
  if (value == 0.0) return;

  // Add scalar
  switch(operation) {
  case RN_ZERO_OPERATION: 
    operation = RN_POLYNOMIAL_OPERATION;
    polynomial = new RNPolynomial(value, 0);
    return;

  case RN_POLYNOMIAL_OPERATION:
    polynomial->Add(value);
    return;

  default: {
    RNAlgebraic *e = new RNAlgebraic(operation, operands[0], operands[1]);
    operation = RN_ADD_OPERATION;
    operands[0] = new RNAlgebraic(value, 0);
    operands[1] = e;
    return; }
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movsd %xmm0, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
movsd 0x48(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x447ff
jp 0x447ff
jmp 0x4496e
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x24(%rsp)
testl %eax, %eax
je 0x4481f
jmp 0x44811
movl 0x24(%rsp), %eax
subl $0x1, %eax
je 0x4488e
jmp 0x448a7
movq 0x28(%rsp), %rax
movl $0x1, 0x8(%rax)
movl $0x10, %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 0x3c6e0
jmp 0x44859
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x4496e
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x10, %esi
callq 0x4290
jmp 0x44973
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rdi
movsd 0x48(%rsp), %xmm0
callq 0xb6c0
jmp 0x4496e
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq 0x28(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movl 0x8(%rax), %esi
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
callq 0x42ac0
jmp 0x448d3
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x30(%rsp)
movl $0x2, 0x8(%rax)
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movsd 0x48(%rsp), %xmm0
xorl %r8d, %r8d
movl %r8d, %ecx
movl %r8d, %esi
movq %rcx, %rdx
callq 0x3fcb0
jmp 0x44917
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x4496e
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x44973
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x44973
addq $0x58, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x44b0
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::Subtract(double)
void RNAlgebraic::
Subtract(RNScalar value)
{
  // Just checking
  assert(IsValid());

  // Check value
  if (value == 0.0) return;

  // Subtract scalar
  switch(operation) {
  case RN_ZERO_OPERATION: 
    operation = RN_POLYNOMIAL_OPERATION;
    polynomial = new RNPolynomial(-value, 0);
    return;
    
  case RN_POLYNOMIAL_OPERATION:
    polynomial->Subtract(value);
    return;
    
  default: {
    RNAlgebraic *e = new RNAlgebraic(operation, operands[0], operands[1]);
    operation = RN_SUBTRACT_OPERATION;
    operands[0] = e;
    operands[1] = new RNAlgebraic(value, 0);
    return; }
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movsd %xmm0, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
movsd 0x48(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x449af
jp 0x449af
jmp 0x44b29
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x24(%rsp)
testl %eax, %eax
je 0x449cf
jmp 0x449c1
movl 0x24(%rsp), %eax
subl $0x1, %eax
je 0x44a49
jmp 0x44a62
movq 0x28(%rsp), %rax
movl $0x1, 0x8(%rax)
movl $0x10, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movaps 0x67029(%rip), %xmm1    # 0xaba20
movsd 0x48(%rsp), %xmm0
pxor %xmm1, %xmm0
xorl %r8d, %r8d
movl %r8d, %ecx
movl %r8d, %esi
movq %rcx, %rdx
callq 0x3c6e0
jmp 0x44a14
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x44b29
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x10, %esi
callq 0x4290
jmp 0x44b2e
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rdi
movsd 0x48(%rsp), %xmm0
callq 0xb4a0
jmp 0x44b29
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq 0x28(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movl 0x8(%rax), %esi
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
callq 0x42ac0
jmp 0x44a8e
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x30(%rsp)
movl $0x3, 0x8(%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rax)
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movsd 0x48(%rsp), %xmm0
xorl %r8d, %r8d
movl %r8d, %ecx
movl %r8d, %esi
movq %rcx, %rdx
callq 0x3fcb0
jmp 0x44adb
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x44b29
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x44b2e
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x44b2e
addq $0x58, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x44b0
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::Divide(double)
void RNAlgebraic::
Divide(RNScalar value)
{
  // Just checking
  assert(IsValid());

  // Check value
  if (value == 0.0) {
    if (IsZero()) {
      Empty();
    }
    else {
      Empty();
      operation = RN_POLYNOMIAL_OPERATION;
      polynomial = new RNPolynomial(RN_INFINITY, 0);
    }
  }
  else if (value != 1.0) {
    switch(operation) {
    case RN_ZERO_OPERATION: 
      return;
      
    case RN_POLYNOMIAL_OPERATION:
      polynomial->Divide(value);
      return;
    
    default: {
      RNAlgebraic *e = new RNAlgebraic(operation, operands[0], operands[1]);
      operation = RN_DIVIDE_OPERATION;
      operands[0] = new RNAlgebraic(value, 0);
      operands[1] = e;
      return; }
    }
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movsd %xmm0, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
movsd 0x48(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x44c0d
jp 0x44c0d
movq 0x28(%rsp), %rdi
callq 0x3fa70
cmpl $0x0, %eax
je 0x44b8d
movq 0x28(%rsp), %rdi
callq 0x444e0
jmp 0x44c08
movq 0x28(%rsp), %rdi
callq 0x444e0
movq 0x28(%rsp), %rax
movl $0x1, 0x8(%rax)
movl $0x10, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
leaq 0x85729(%rip), %rax     # 0xca2e8
movsd (%rax), %xmm0
xorl %r8d, %r8d
movl %r8d, %ecx
movl %r8d, %esi
movq %rcx, %rdx
callq 0x3c6e0
jmp 0x44bd6
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x44c08
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x10, %esi
callq 0x4290
jmp 0x44d31
jmp 0x44d2c
movsd 0x48(%rsp), %xmm0
movsd 0x66405(%rip), %xmm1    # 0xab020
ucomisd %xmm1, %xmm0
jne 0x44c28
jp 0x44c28
jmp 0x44d2a
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x1c(%rsp)
testl %eax, %eax
je 0x44c45
jmp 0x44c3a
movl 0x1c(%rsp), %eax
subl $0x1, %eax
je 0x44c4a
jmp 0x44c63
jmp 0x44d2c
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rdi
movsd 0x48(%rsp), %xmm0
callq 0x3d580
jmp 0x44d2c
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq 0x28(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movl 0x8(%rax), %esi
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
callq 0x42ac0
jmp 0x44c8f
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x30(%rsp)
movl $0x5, 0x8(%rax)
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movsd 0x48(%rsp), %xmm0
xorl %r8d, %r8d
movl %r8d, %ecx
movl %r8d, %esi
movq %rcx, %rdx
callq 0x3fcb0
jmp 0x44cd3
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x44d2c
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x44d31
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x44d31
jmp 0x44d2c
addq $0x58, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x44b0
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::Add(gaps::RNPolynomial const&)
void RNAlgebraic::
Add(const RNPolynomial& value)
{
  // Just checking
  assert(IsValid());

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

  // Add scalar
  switch(operation) {
  case RN_ZERO_OPERATION: 
    operation = RN_POLYNOMIAL_OPERATION;
    polynomial = new RNPolynomial(value);
    return;

  case RN_POLYNOMIAL_OPERATION:
    polynomial->Add(value);
    return;

  default: {
    RNAlgebraic *e = new RNAlgebraic(operation, operands[0], operands[1]);
    operation = RN_ADD_OPERATION;
    operands[0] = new RNAlgebraic(value, 0);
    operands[1] = e;
    return; }
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
callq 0x3cf90
cmpl $0x0, %eax
je 0x44d6c
jmp 0x44ebf
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x24(%rsp)
testl %eax, %eax
je 0x44d89
jmp 0x44d7e
movl 0x24(%rsp), %eax
subl $0x1, %eax
je 0x44deb
jmp 0x44e03
movq 0x28(%rsp), %rax
movl $0x1, 0x8(%rax)
movl $0x10, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rsi
callq 0x3c530
jmp 0x44db6
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x44ebf
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x10, %esi
callq 0x4290
jmp 0x44ec4
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x48(%rsp), %rsi
callq 0x3d5e0
jmp 0x44ebf
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq 0x28(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movl 0x8(%rax), %esi
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
callq 0x42ac0
jmp 0x44e2f
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x30(%rsp)
movl $0x2, 0x8(%rax)
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rsi
xorl %edx, %edx
callq 0x3fda0
jmp 0x44e68
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x44ebf
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x44ec4
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x44ec4
addq $0x58, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x44b0
nop
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::Subtract(gaps::RNPolynomial const&)
void RNAlgebraic::
Subtract(const RNPolynomial& value)
{
  // Just checking
  assert(IsValid());

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

  // Subtract scalar
  switch(operation) {
  case RN_ZERO_OPERATION: 
    operation = RN_POLYNOMIAL_OPERATION;
    polynomial = new RNPolynomial(value);
    polynomial->Negate();
    return;
    
  case RN_POLYNOMIAL_OPERATION:
    polynomial->Subtract(value);
    return;
    
  default: {
    RNAlgebraic *e = new RNAlgebraic(operation, operands[0], operands[1]);
    operation = RN_SUBTRACT_OPERATION;
    operands[0] = e;
    operands[1] = new RNAlgebraic(value, 0);
    return; }
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
callq 0x3cf90
cmpl $0x0, %eax
je 0x44efc
jmp 0x4505b
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x24(%rsp)
testl %eax, %eax
je 0x44f1c
jmp 0x44f0e
movl 0x24(%rsp), %eax
subl $0x1, %eax
je 0x44f87
jmp 0x44f9f
movq 0x28(%rsp), %rax
movl $0x1, 0x8(%rax)
movl $0x10, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rsi
callq 0x3c530
jmp 0x44f49
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x20(%rax)
movq 0x20(%rax), %rdi
callq 0x3d470
jmp 0x4505b
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x10, %esi
callq 0x4290
jmp 0x45060
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x48(%rsp), %rsi
callq 0x3d6a0
jmp 0x4505b
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq 0x28(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movl 0x8(%rax), %esi
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
callq 0x42ac0
jmp 0x44fcb
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x30(%rsp)
movl $0x3, 0x8(%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rax)
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rsi
xorl %edx, %edx
callq 0x3fda0
jmp 0x4500d
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x4505b
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x45060
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x45060
addq $0x58, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x44b0
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::Multiply(gaps::RNPolynomial const&)
void RNAlgebraic::
Multiply(const RNPolynomial& value)
{
  // Just checking
  assert(IsValid());

  // Check value 
  if (value.IsZero()) {
    Empty();
  }
  else if (!value.IsOne()) {
    switch(operation) {
    case RN_ZERO_OPERATION: 
      return;
    
    case RN_POLYNOMIAL_OPERATION:
      assert(polynomial);
      if (TRUE || (value.NTerms() == 1) || (polynomial->NTerms() == 1)) {
        polynomial->Multiply(value);
      }
      else {
        operation = RN_MULTIPLY_OPERATION;
        operands[0] = new RNAlgebraic(polynomial);
        operands[1] = new RNAlgebraic(value, 0);
        polynomial = NULL;
      }
      return;
    
    default: {
      RNAlgebraic *e = new RNAlgebraic(operation, operands[0], operands[1]);
      operation = RN_MULTIPLY_OPERATION;
      operands[0] = new RNAlgebraic(value, 0);
      operands[1] = e;
      return; }
    }
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3cf90
cmpl $0x0, %eax
je 0x450a6
movq 0x18(%rsp), %rdi
callq 0x444e0
jmp 0x451ae
movq 0x38(%rsp), %rdi
callq 0x3cfd0
cmpl $0x0, %eax
jne 0x451ac
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x14(%rsp)
testl %eax, %eax
je 0x450d6
jmp 0x450cb
movl 0x14(%rsp), %eax
subl $0x1, %eax
je 0x450db
jmp 0x450f3
jmp 0x451ae
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x38(%rsp), %rsi
callq 0x3d780
jmp 0x451ae
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq 0x18(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x8(%rsp)
movl 0x8(%rax), %esi
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
callq 0x42ac0
jmp 0x4511f
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x30(%rsp)
movl $0x4, 0x8(%rax)
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rsi
xorl %edx, %edx
callq 0x3fda0
jmp 0x45157
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x451ae
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x451b3
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x451b3
jmp 0x451ae
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x44b0
nopl (%rax)