LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x24b81
jp 0x24b81
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
cmpl $0x1, %ebp
je 0x24bcd
movapd %xmm0, (%rsp)
testl %ebp, %ebp
jne 0x24bf5
movl $0x1, 0x8(%rbx)
movl $0x10, %edi
callq 0x4270
movq %rax, %r14
movapd (%rsp), %xmm0
xorpd 0x344aa(%rip), %xmm0    # 0x59060
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x20dd4
movq %r14, 0x20(%rbx)
jmp 0x24b78
xorpd 0x3448b(%rip), %xmm0    # 0x59060
movq 0x20(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x20e38
movl $0x28, %edi
callq 0x4270
movq %rax, %r14
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0x56bef(%rip), %rax     # 0x7b800
movq %rax, (%r14)
movl $0x0, 0x8(%r14)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x10(%r14)
movq $0x0, 0x20(%r14)
movq %r14, %rdi
movl %ebp, %esi
xorl %r8d, %r8d
callq 0x23dbe
movl $0x3, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movl $0x28, %edi
callq 0x4270
movq %rax, %r14
movq %rax, %rdi
movapd (%rsp), %xmm0
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2290a
movq %r14, 0x18(%rbx)
jmp 0x24b78
jmp 0x24c74
movq %rax, %rbx
movl $0x28, %esi
jmp 0x24c86
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x4280
movq %rbx, %rdi
callq 0x44b0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x24cff
jp 0x24cff
movq %rbx, %rdi
callq 0x227c2
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2486c
testl %ebp, %ebp
jne 0x24daf
movl $0x1, 0x8(%rbx)
movl $0x10, %edi
callq 0x4270
movq %rax, %r14
leaq 0x576c7(%rip), %rax     # 0x7c3a8
movsd (%rax), %xmm0
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x20dd4
movq %r14, 0x20(%rbx)
jmp 0x24daf
ucomisd 0x34309(%rip), %xmm0    # 0x59010
jne 0x24d0f
jnp 0x24daf
movl 0x8(%rbx), %ebp
testl %ebp, %ebp
je 0x24daf
cmpl $0x1, %ebp
jne 0x24d32
movq 0x20(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21582
movsd %xmm0, (%rsp)
movl $0x28, %edi
callq 0x4270
movq %rax, %r14
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0x56aad(%rip), %rax     # 0x7b800
movq %rax, (%r14)
movl $0x0, 0x8(%r14)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x10(%r14)
movq $0x0, 0x20(%r14)
movq %r14, %rdi
movl %ebp, %esi
xorl %r8d, %r8d
callq 0x23dbe
movl $0x5, 0x8(%rbx)
movl $0x28, %edi
callq 0x4270
movq %rax, %r15
movq %rax, %rdi
movsd (%rsp), %xmm0
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2290a
movq %r15, 0x10(%rbx)
movq %r14, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x28, %esi
movq %r15, %rdi
jmp 0x24ddc
movq %rax, %rbx
movl $0x28, %esi
jmp 0x24dd9
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x4280
movq %rbx, %rdi
callq 0x44b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2129e
testl %eax, %eax
je 0x24e0d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rbx), %ebp
cmpl $0x1, %ebp
je 0x24e3e
testl %ebp, %ebp
jne 0x24e52
movl $0x1, 0x8(%rbx)
movl $0x10, %edi
callq 0x4270
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x20cce
movq %r15, 0x20(%rbx)
jmp 0x24e04
movq 0x20(%rbx), %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x215bc
movl $0x28, %edi
callq 0x4270
movq %rax, %r15
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0x56992(%rip), %rax     # 0x7b800
movq %rax, (%r15)
movl $0x0, 0x8(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq $0x0, 0x20(%r15)
movq %r15, %rdi
movl %ebp, %esi
xorl %r8d, %r8d
callq 0x23dbe
movl $0x2, 0x8(%rbx)
movl $0x28, %edi
callq 0x4270
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x229b0
movq %r12, 0x10(%rbx)
movq %r15, 0x18(%rbx)
jmp 0x24e04
movq %rax, %rbx
movl $0x28, %esi
movq %r12, %rdi
jmp 0x24ee4
movq %rax, %rbx
movl $0x28, %esi
jmp 0x24ee1
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
callq 0x4280
movq %rbx, %rdi
callq 0x44b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2129e
testl %eax, %eax
je 0x24f16
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rbx), %ebp
cmpl $0x1, %ebp
je 0x24f57
testl %ebp, %ebp
jne 0x24f6d
movl $0x1, 0x8(%rbx)
movl $0x10, %edi
callq 0x4270
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x20cce
movq %r15, 0x20(%rbx)
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2151a
movq 0x20(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2160e
movl $0x28, %edi
callq 0x4270
movq %rax, %r15
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0x56877(%rip), %rax     # 0x7b800
movq %rax, (%r15)
movl $0x0, 0x8(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq $0x0, 0x20(%r15)
movq %r15, %rdi
movl %ebp, %esi
xorl %r8d, %r8d
callq 0x23dbe
movl $0x3, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movl $0x28, %edi
callq 0x4270
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x229b0
movq %r15, 0x18(%rbx)
jmp 0x24f0b
jmp 0x24fdf
movq %rax, %rbx
movl $0x28, %esi
jmp 0x24ff1
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
callq 0x4280
movq %rbx, %rdi
callq 0x44b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2129e
testl %eax, %eax
je 0x2502c
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2486c
movq %r14, %rdi
callq 0x212a8
testl %eax, %eax
je 0x25041
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rbx), %ebp
testl %ebp, %ebp
je 0x25038
cmpl $0x1, %ebp
jne 0x25061
movq 0x20(%rbx), %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21666
movl $0x28, %edi
callq 0x4270
movq %rax, %r15
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0x56783(%rip), %rax     # 0x7b800
movq %rax, (%r15)
movl $0x0, 0x8(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq $0x0, 0x20(%r15)
movq %r15, %rdi
movl %ebp, %esi
xorl %r8d, %r8d
callq 0x23dbe
movl $0x4, 0x8(%rbx)
movl $0x28, %edi
callq 0x4270
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x229b0
movq %r12, 0x10(%rbx)
movq %r15, 0x18(%rbx)
jmp 0x25038
movq %rax, %rbx
movq %r12, %r15
jmp 0x250dc
movq %rax, %rbx
movl $0x28, %esi
movq %r15, %rdi
callq 0x4280
movq %rbx, %rdi
callq 0x44b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::Divide(gaps::RNPolynomial const&)
void RNAlgebraic::
Divide(const RNPolynomial& value)
{
  // Just checking
  assert(IsValid());

  // Check value
  if (value.IsZero()) {
    if (IsZero()) {
      Empty();
    }
    else {
      Empty();
      operation = RN_POLYNOMIAL_OPERATION;
      polynomial = new RNPolynomial(RN_INFINITY, 0);
    }
  }
  else if (!value.IsOne()){
    switch(operation) {
    case RN_ZERO_OPERATION: 
      return;
      
    case RN_POLYNOMIAL_OPERATION:
      operation = RN_DIVIDE_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_DIVIDE_OPERATION;
      operands[0] = new RNAlgebraic(value, 0);
      operands[1] = e;
      return; }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2129e
testl %eax, %eax
je 0x25158
movq %rbx, %rdi
callq 0x227c2
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2486c
testl %ebp, %ebp
jne 0x25164
movl $0x1, 0x8(%rbx)
movl $0x10, %edi
callq 0x4270
movq %rax, %r14
leaq 0x5726b(%rip), %rax     # 0x7c3a8
movsd (%rax), %xmm0
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x20dd4
movq %r14, 0x20(%rbx)
jmp 0x25164
movq %r14, %rdi
callq 0x212a8
testl %eax, %eax
je 0x2516d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rbx), %ebp
testl %ebp, %ebp
je 0x25164
cmpl $0x1, %ebp
jne 0x251c3
movl $0x5, 0x8(%rbx)
movl $0x28, %edi
callq 0x4270
movq %rax, %r15
movq 0x20(%rbx), %rsi
movq %rax, %rdi
callq 0x226ce
movq %r15, 0x10(%rbx)
movl $0x28, %edi
callq 0x4270
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x229b0
movq %r15, 0x18(%rbx)
movq $0x0, 0x20(%rbx)
jmp 0x25164
movl $0x28, %edi
callq 0x4270
movq %rax, %r15
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0x56621(%rip), %rax     # 0x7b800
movq %rax, (%r15)
movl $0x0, 0x8(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq $0x0, 0x20(%r15)
movq %r15, %rdi
movl %ebp, %esi
xorl %r8d, %r8d
callq 0x23dbe
movl $0x5, 0x8(%rbx)
movl $0x28, %edi
callq 0x4270
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x229b0
movq %r12, 0x10(%rbx)
movq %r15, 0x18(%rbx)
jmp 0x25164
movq %rax, %rbx
movl $0x28, %esi
movq %r12, %rdi
jmp 0x2525c
jmp 0x25244
jmp 0x25244
movq %rax, %rbx
movl $0x28, %esi
movq %r15, %rdi
jmp 0x2525c
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x4280
movq %rbx, %rdi
callq 0x44b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::Add(gaps::RNAlgebraic const&)
void RNAlgebraic::
Add(const RNAlgebraic& value)
{
  // Just checking
  assert(IsValid());
  assert(value.IsValid());

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

  // Add value
  switch(operation) {
  case RN_ZERO_OPERATION: 
    *this = value;
    return;

  case RN_POLYNOMIAL_OPERATION:
    if (value.operation == RN_POLYNOMIAL_OPERATION) {
      polynomial->Add(*(value.polynomial));
    }
    else {
      operands[0] = new RNAlgebraic(value);
      operands[1] = new RNAlgebraic(polynomial);
      operation = RN_ADD_OPERATION;
      polynomial = NULL;
    }
    return;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x227c2
testl %eax, %eax
je 0x2528d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rbx), %ebp
cmpl $0x1, %ebp
je 0x252ac
testl %ebp, %ebp
jne 0x252cc
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x253ae
cmpl $0x1, 0x8(%r15)
jne 0x2533c
movq 0x20(%rbx), %rdi
movq 0x20(%r15), %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x215bc
movl $0x28, %edi
callq 0x4270
movq %rax, %r14
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0x56518(%rip), %rax     # 0x7b800
movq %rax, (%r14)
movl $0x0, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq $0x0, 0x20(%r14)
movq %r14, %rdi
movl %ebp, %esi
xorl %r8d, %r8d
callq 0x23dbe
movl $0x28, %edi
callq 0x4270
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x22a28
movq %r12, 0x10(%rbx)
movq %r14, 0x18(%rbx)
movl $0x2, 0x8(%rbx)
jmp 0x25284
movl $0x28, %edi
callq 0x4270
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x22a28
movq %r14, 0x10(%rbx)
movl $0x28, %edi
callq 0x4270
movq %rax, %r14
movq 0x20(%rbx), %rsi
movq %rax, %rdi
callq 0x226ce
movq %r14, 0x18(%rbx)
movl $0x2, 0x8(%rbx)
movq $0x0, 0x20(%rbx)
jmp 0x25284
jmp 0x25395
jmp 0x25395
movq %rax, %rbx
movq %r12, %r14
jmp 0x25398
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0x4280
movq %rbx, %rdi
callq 0x44b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::operator=(gaps::RNAlgebraic const&)
RNAlgebraic& RNAlgebraic::
operator=(const RNAlgebraic& value)
{
  // Just checking
  assert(value.IsValid());

  // Empty this value
  Empty();

  // Copy operation
  this->operation = value.operation;

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

  case RN_POLYNOMIAL_OPERATION:
    polynomial = new RNPolynomial(*(value.polynomial));
    break;

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

  // Return this
  return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0x2486c
movl 0x8(%r15), %eax
movl %eax, 0x8(%rbx)
testl %eax, %eax
je 0x2542f
cmpl $0x1, %eax
jne 0x253ef
movl $0x10, %edi
callq 0x4270
movq %rax, %r14
movq 0x20(%r15), %rsi
movl $0x20, %r15d
movq %rax, %rdi
callq 0x20cce
jmp 0x2542b
movl $0x28, %edi
callq 0x4270
movq %rax, %r14
movq 0x10(%r15), %rsi
movq %rax, %rdi
callq 0x22a28
movq %r14, 0x10(%rbx)
movl $0x28, %edi
callq 0x4270
movq %rax, %r14
movq 0x18(%r15), %rsi
movl $0x18, %r15d
movq %rax, %rdi
callq 0x22a28
movq %r14, (%rbx,%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2543a
movq %rax, %rbx
movl $0x28, %esi
jmp 0x2544c
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x4280
movq %rbx, %rdi
callq 0x44b0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::Subtract(gaps::RNAlgebraic const&)
void RNAlgebraic::
Subtract(const RNAlgebraic& value)
{
  // Just checking
  assert(IsValid());
  assert(value.IsValid());

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

  // Subtract value
  switch(operation) {
  case RN_ZERO_OPERATION: 
    *this = value;
    Negate();
    return;

  case RN_POLYNOMIAL_OPERATION:
    if (value.operation == RN_POLYNOMIAL_OPERATION) {
      polynomial->Subtract(*(value.polynomial));
    }
    else {
      operands[1] = new RNAlgebraic(value);
      operands[0] = new RNAlgebraic(polynomial);
      operation = RN_SUBTRACT_OPERATION;
      polynomial = NULL;
    }
    return;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x227c2
testl %eax, %eax
je 0x2547f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rbx), %ebp
cmpl $0x1, %ebp
je 0x254a6
testl %ebp, %ebp
jne 0x254c6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x253ae
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x241f6
cmpl $0x1, 0x8(%r15)
jne 0x25536
movq 0x20(%rbx), %rdi
movq 0x20(%r15), %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2160e
movl $0x28, %edi
callq 0x4270
movq %rax, %r14
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0x5631e(%rip), %rax     # 0x7b800
movq %rax, (%r14)
movl $0x0, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq $0x0, 0x20(%r14)
movq %r14, %rdi
movl %ebp, %esi
xorl %r8d, %r8d
callq 0x23dbe
movl $0x28, %edi
callq 0x4270
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x22a28
movq %r12, 0x18(%rbx)
movq %r14, 0x10(%rbx)
movl $0x3, 0x8(%rbx)
jmp 0x25476
movl $0x28, %edi
callq 0x4270
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x22a28
movq %r14, 0x18(%rbx)
movl $0x28, %edi
callq 0x4270
movq %rax, %r14
movq 0x20(%rbx), %rsi
movq %rax, %rdi
callq 0x226ce
movq %r14, 0x10(%rbx)
movl $0x3, 0x8(%rbx)
movq $0x0, 0x20(%rbx)
jmp 0x25476
jmp 0x2558f
jmp 0x2558f
movq %rax, %rbx
movq %r12, %r14
jmp 0x25592
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0x4280
movq %rbx, %rdi
callq 0x44b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::Multiply(gaps::RNAlgebraic const&)
void RNAlgebraic::
Multiply(const RNAlgebraic& value)
{
  // Just checking
  assert(IsValid());
  assert(value.IsValid());

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x227c2
testl %eax, %eax
je 0x255d2
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2486c
movq %r15, %rdi
callq 0x2427e
testl %eax, %eax
je 0x255e7
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rbx), %ebp
testl %ebp, %ebp
je 0x255de
cmpl $0x1, %ebp
jne 0x25613
cmpl $0x1, 0x8(%r15)
jne 0x25683
movq 0x20(%rbx), %rdi
movq 0x20(%r15), %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21666
movl $0x28, %edi
callq 0x4270
movq %rax, %r14
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0x561d1(%rip), %rax     # 0x7b800
movq %rax, (%r14)
movl $0x0, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq $0x0, 0x20(%r14)
movq %r14, %rdi
movl %ebp, %esi
xorl %r8d, %r8d
callq 0x23dbe
movl $0x28, %edi
callq 0x4270
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x22a28
movq %r12, 0x10(%rbx)
movq %r14, 0x18(%rbx)
movl $0x4, 0x8(%rbx)
jmp 0x255de
movl $0x28, %edi
callq 0x4270
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x22a28
movq %r14, 0x18(%rbx)
movl $0x28, %edi
callq 0x4270
movq %rax, %r14
movq 0x20(%rbx), %rsi
movq %rax, %rdi
callq 0x226ce
movq %r14, 0x10(%rbx)
movl $0x4, 0x8(%rbx)
movq $0x0, 0x20(%rbx)
jmp 0x255de
jmp 0x256dc
jmp 0x256dc
movq %rax, %rbx
movq %r12, %r14
jmp 0x256df
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0x4280
movq %rbx, %rdi
callq 0x44b0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::Divide(gaps::RNAlgebraic const&)
void RNAlgebraic::
Divide(const RNAlgebraic& value)
{
  // Just checking
  assert(IsValid());
  assert(value.IsValid());

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x227c2
testl %eax, %eax
je 0x2575a
movq %rbx, %rdi
callq 0x227c2
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2486c
testl %ebp, %ebp
jne 0x25766
movl $0x1, 0x8(%rbx)
movl $0x10, %edi
callq 0x4270
movq %rax, %r14
leaq 0x56c69(%rip), %rax     # 0x7c3a8
movsd (%rax), %xmm0
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x20dd4
movq %r14, 0x20(%rbx)
jmp 0x25766
movq %r14, %rdi
callq 0x2427e
testl %eax, %eax
je 0x2576f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rbx), %ebp
testl %ebp, %ebp
je 0x25766
movl $0x28, %edi
cmpl $0x1, %ebp
jne 0x257c5
callq 0x4270
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x22a28
movq %r15, 0x18(%rbx)
movl $0x28, %edi
callq 0x4270
movq %rax, %r14
movq 0x20(%rbx), %rsi
movq %rax, %rdi
callq 0x226ce
movq %r14, 0x10(%rbx)
movl $0x5, 0x8(%rbx)
movq $0x0, 0x20(%rbx)
jmp 0x25766
callq 0x4270
movq %rax, %r15
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0x56024(%rip), %rax     # 0x7b800
movq %rax, (%r15)
movl $0x0, 0x8(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq $0x0, 0x20(%r15)
movq %r15, %rdi
movl %ebp, %esi
xorl %r8d, %r8d
callq 0x23dbe
movl $0x28, %edi
callq 0x4270
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x22a28
movq %r12, 0x10(%rbx)
movq %r15, 0x18(%rbx)
movl $0x5, 0x8(%rbx)
jmp 0x25766
movq %rax, %rbx
movl $0x28, %esi
movq %r12, %rdi
jmp 0x25861
movq %rax, %rbx
movl $0x28, %esi
jmp 0x2585e
jmp 0x25849
movq %rax, %rbx
movl $0x28, %esi
movq %r15, %rdi
jmp 0x25861
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x4280
movq %rbx, %rdi
callq 0x44b0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::operator=(double)
RNAlgebraic& RNAlgebraic::
operator=(RNScalar value)
{
  // Empty this algebraic
  Empty();

  // Assign constant
  operation = RN_POLYNOMIAL_OPERATION;
  polynomial = new RNPolynomial(value, 0);

  // Return this
  return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rdi, %rbx
callq 0x2486c
movl $0x1, 0x8(%rbx)
movl $0x10, %edi
callq 0x4270
movq %rax, %r14
movq %rax, %rdi
movsd (%rsp), %xmm0
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x20dd4
movq %r14, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x4280
movq %rbx, %rdi
callq 0x44b0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::operator=(gaps::RNPolynomial const&)
RNAlgebraic& RNAlgebraic::
operator=(const RNPolynomial& value)
{
  // Empty this algebraic
  Empty();

  // Assign polynomial
  operation = RN_POLYNOMIAL_OPERATION;
  polynomial = new RNPolynomial(value);

  // Return this
  return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0x2486c
movl $0x1, 0x8(%rbx)
movl $0x10, %edi
callq 0x4270
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x20cce
movq %r14, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x4280
movq %rbx, %rdi
callq 0x44b0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::Evaluate(double const*) const
RNScalar RNAlgebraic::
Evaluate(const RNScalar *x) const
{
  // Return value of algebraic
  switch(operation) {
  case RN_ZERO_OPERATION:
    return 0;
  
  case RN_POLYNOMIAL_OPERATION: 
    return polynomial->Evaluate(x);

  case RN_ADD_OPERATION: 
    return operands[0]->Evaluate(x) + operands[1]->Evaluate(x);
  
  case RN_SUBTRACT_OPERATION: 
    return operands[0]->Evaluate(x) - operands[1]->Evaluate(x);
  
  case RN_MULTIPLY_OPERATION: 
    return operands[0]->Evaluate(x) * operands[1]->Evaluate(x);

  case RN_DIVIDE_OPERATION: {
    RNScalar v1 = operands[1]->Evaluate(x);
    if (RNIsZero(v1, RN_SMALL_EPSILON)) return RN_INFINITY;
    RNScalar v0 = operands[0]->Evaluate(x);
    return v0 / v1; }
  
  case RN_POW_OPERATION: {
    RNScalar v0 = operands[0]->Evaluate(x);
    if (v0 == 0) return 0;
    RNScalar v1 = operands[1]->Evaluate(x);
    if (v1 == 0) return 1;
    return pow(v0, v1); }
  }

  // Should never get here
  RNAbort("Invalid algebraic operation: %d", operation);
  return 0.0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x8(%rdi), %esi
xorpd %xmm0, %xmm0
cmpq $0x6, %rsi
ja 0x259df
movq %rdi, %r14
leaq 0x34ed6(%rip), %rax     # 0x5a81c
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x20(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x219d8
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x25924
movsd %xmm0, (%rsp)
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x25924
mulsd (%rsp), %xmm0
jmp 0x25a8f
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x25924
movsd %xmm0, (%rsp)
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x25924
addsd (%rsp), %xmm0
jmp 0x25a8f
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x25924
movsd %xmm0, (%rsp)
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x25924
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x25a8f
leaq 0x34ef8(%rip), %rdi     # 0x5a8de
xorl %eax, %eax
callq 0x297ae
xorpd %xmm0, %xmm0
jmp 0x25a8f
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x25924
leaq 0x56987(%rip), %rax     # 0x7c390
movsd (%rax), %xmm2
movapd 0x3364b(%rip), %xmm1    # 0x59060
xorpd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jb 0x25a79
ucomisd %xmm0, %xmm2
jb 0x25a79
leaq 0x5697c(%rip), %rax     # 0x7c3a8
movsd (%rax), %xmm0
jmp 0x25a8f
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x25924
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x25a4e
jnp 0x25a8f
movsd %xmm1, (%rsp)
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x25924
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x25a97
jp 0x25a97
movsd 0x33599(%rip), %xmm0    # 0x59010
jmp 0x25a8f
movq 0x10(%r14), %rdi
movq %rbx, %rsi
movsd %xmm0, (%rsp)
callq 0x25924
divsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x44a0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::Evaluate(double const* const*) const
RNScalar RNAlgebraic::
Evaluate(double const* const* x) const
{
  // Return value of algebraic
  switch(operation) {
  case RN_ZERO_OPERATION: 
    return 0;
  
  case RN_POLYNOMIAL_OPERATION: 
    return polynomial->Evaluate(x);

  case RN_ADD_OPERATION: 
    return operands[0]->Evaluate(x) + operands[1]->Evaluate(x);
  
  case RN_SUBTRACT_OPERATION: 
    return operands[0]->Evaluate(x) - operands[1]->Evaluate(x);
  
  case RN_MULTIPLY_OPERATION: 
    return operands[0]->Evaluate(x) * operands[1]->Evaluate(x);

  case RN_DIVIDE_OPERATION: {
    RNScalar v1 = operands[1]->Evaluate(x);
    if (RNIsZero(v1, RN_SMALL_EPSILON)) return RN_INFINITY;
    RNScalar v0 = operands[0]->Evaluate(x);
    return v0 / v1; }
  
  case RN_POW_OPERATION: {
    RNScalar v0 = operands[0]->Evaluate(x);
    if (v0 == 0) return 0;
    RNScalar v1 = operands[1]->Evaluate(x);
    if (v1 == 0) return 1;
    return pow(v0, v1); }
  }

  // Should never get here
  RNAbort("Invalid algebraic operation: %d", operation);
  return 0.0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x8(%rdi), %esi
xorpd %xmm0, %xmm0
cmpq $0x6, %rsi
ja 0x25b63
movq %rdi, %r14
leaq 0x34d6e(%rip), %rax     # 0x5a838
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x20(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21b32
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x25aa8
movsd %xmm0, (%rsp)
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x25aa8
mulsd (%rsp), %xmm0
jmp 0x25c13
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x25aa8
movsd %xmm0, (%rsp)
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x25aa8
addsd (%rsp), %xmm0
jmp 0x25c13
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x25aa8
movsd %xmm0, (%rsp)
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x25aa8
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x25c13
leaq 0x34d74(%rip), %rdi     # 0x5a8de
xorl %eax, %eax
callq 0x297ae
xorpd %xmm0, %xmm0
jmp 0x25c13
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x25aa8
leaq 0x56803(%rip), %rax     # 0x7c390
movsd (%rax), %xmm2
movapd 0x334c7(%rip), %xmm1    # 0x59060
xorpd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jb 0x25bfd
ucomisd %xmm0, %xmm2
jb 0x25bfd
leaq 0x567f8(%rip), %rax     # 0x7c3a8
movsd (%rax), %xmm0
jmp 0x25c13
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x25aa8
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x25bd2
jnp 0x25c13
movsd %xmm1, (%rsp)
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x25aa8
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x25c1b
jp 0x25c1b
movsd 0x33415(%rip), %xmm0    # 0x59010
jmp 0x25c13
movq 0x10(%r14), %rdi
movq %rbx, %rsi
movsd %xmm0, (%rsp)
callq 0x25aa8
divsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x44a0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::Print(_IO_FILE*, int) const
void RNAlgebraic::
Print(FILE *fp, int indent) const
{
  // Print algebraic
  switch(operation) {
  case RN_ZERO_OPERATION:
    for (int i = 0; i < indent; i++) fprintf(fp, " ");
    fprintf(fp, "0\n");
    return;
    
  case RN_POLYNOMIAL_OPERATION: 
    for (int i = 0; i < indent; i++) fprintf(fp, " ");
    polynomial->Print(fp);
    return;

  default:
    for (int i = 0; i < indent; i++) fprintf(fp, " ");
    fprintf(fp, "[ %d\n", operation);
    operands[0]->Print(fp, indent+2);
    operands[1]->Print(fp, indent+2);
    for (int i = 0; i < indent; i++) fprintf(fp, " ");
    fprintf(fp, "]\n");
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0x26285
movq %rdi, %r15
cmpl $0x1, %eax
jne 0x262a5
testl %r14d, %r14d
jle 0x2626f
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4340
decl %r14d
jne 0x2625d
movq 0x20(%r15), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22132
testl %r14d, %r14d
jle 0x2629c
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4340
decl %r14d
jne 0x2628a
leaq 0x339c8(%rip), %rdi     # 0x59c6b
jmp 0x26311
testl %r14d, %r14d
jle 0x262be
movl %r14d, %ebp
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4340
decl %ebp
jne 0x262ad
movl 0x8(%r15), %edx
leaq 0x34635(%rip), %rsi     # 0x5a8fe
movq %rbx, %rdi
xorl %eax, %eax
callq 0x43d0
movq 0x10(%r15), %rdi
leal 0x2(%r14), %ebp
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2623c
movq 0x18(%r15), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2623c
testl %r14d, %r14d
jle 0x2630a
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4340
decl %r14d
jne 0x262f8
leaq 0x345f3(%rip), %rdi     # 0x5a904
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/RNMath/RNAlgebraic.cpp
// Function: gaps::RNAlgebraic::IsValid() const
RNBoolean RNAlgebraic::
IsValid(void) const
{
  // Check operation
  if ((operation < 0) || (operation >= RN_NUM_ALGEBRAIC_OPERATIONS)) return FALSE; 

  // Check invariants
  switch(operation) {
  case RN_ZERO_OPERATION: 
    if (polynomial) { printf("E1\n"); return FALSE; }
    if (operands[0]) { printf("E2\n"); return FALSE; }
    if (operands[1]) { printf("E3\n"); return FALSE; }
    break;
    
  case RN_POLYNOMIAL_OPERATION: 
    if (!polynomial) { printf("E4\n"); return FALSE; }
    if (operands[0]) { printf("E5\n"); return FALSE; }
    if (operands[1]) { printf("E6\n"); return FALSE; }
    break;

  default:
    if (polynomial) { printf("E7\n"); return FALSE; }
    if (!operands[0]) { printf("E8\n"); return FALSE; }
    if (!operands[1]) { printf("E9\n"); return FALSE; }
    break;
  }

  // Passed all tests
  return TRUE;
}

// Assembly:
movl 0x8(%rdi), %ecx
xorl %eax, %eax
cmpl $0x6, %ecx
ja 0x263eb
movq 0x20(%rdi), %rax
cmpl $0x1, %ecx
je 0x2635a
testl %ecx, %ecx
jne 0x2636f
testq %rax, %rax
je 0x2637d
leaq 0x345c1(%rip), %rdi     # 0x5a916
jmp 0x263df
testq %rax, %rax
je 0x2638d
cmpq $0x0, 0x10(%rdi)
je 0x263b2
leaq 0x345a0(%rip), %rdi     # 0x5a90d
jmp 0x263df
testq %rax, %rax
je 0x26396
leaq 0x345a4(%rip), %rdi     # 0x5a91f
jmp 0x263df
cmpq $0x0, 0x10(%rdi)
je 0x263c2
leaq 0x34588(%rip), %rdi     # 0x5a913
jmp 0x263df
leaq 0x34573(%rip), %rdi     # 0x5a907
jmp 0x263df
cmpq $0x0, 0x10(%rdi)
je 0x263d8
movl $0x1, %eax
cmpq $0x0, 0x18(%rdi)
jne 0x263eb
leaq 0x3456c(%rip), %rdi     # 0x5a91c
jmp 0x263df
cmpq $0x0, 0x18(%rdi)
je 0x263d2
leaq 0x3454a(%rip), %rdi     # 0x5a90a
jmp 0x263df
cmpq $0x0, 0x18(%rdi)
je 0x263d2
leaq 0x34540(%rip), %rdi     # 0x5a910
jmp 0x263df
movl $0x1, %eax
retq
leaq 0x3453a(%rip), %rdi     # 0x5a919
pushq %rax
callq 0x4420
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/RNMath/RNSystemOfEquations.cpp
// Function: gaps::RNSystemOfEquations::RNSystemOfEquations(int)
RNSystemOfEquations::
RNSystemOfEquations(int nvariables)
  : lower_bounds(NULL),
    upper_bounds(NULL),
    nvariables(nvariables),
    equations()
{
  // Allocate memory for variable counting
  index_to_variable = new int [ nvariables ];
  variable_to_index = new int [ nvariables ];
  variable_marks = new int [ nvariables ];
  for (int i = 0; i < nvariables; i++) variable_marks[i] = 0;
  current_mark = 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movl %esi, 0x30(%rdi)
leaq 0x38(%rdi), %r14
movq %r14, %rdi
callq 0x2751c
movslq %ebp, %rax
leaq (,%rax,4), %rcx
testl %eax, %eax
movq $-0x1, %r15
cmovnsq %rcx, %r15
movq %r15, %rdi
callq 0x4030
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x4030
movq %rax, 0x8(%rbx)
movq %r15, %rdi
callq 0x4030
movq %rax, 0x10(%rbx)
testl %ebp, %ebp
jle 0x2645d
movl %ebp, %edx
shlq $0x2, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x4160
movl $0x1, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x27586
movq %rbx, %rdi
callq 0x44b0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/RNMath/RNSystemOfEquations.cpp
// Function: gaps::RNSystemOfEquations::RNSystemOfEquations(gaps::RNSystemOfEquations const&)
RNSystemOfEquations::
RNSystemOfEquations(const RNSystemOfEquations& system)
  : lower_bounds(NULL),
    upper_bounds(NULL),
    nvariables(system.nvariables),
    equations()
{
  // Allocate memory for variable counting
  index_to_variable = new int [ nvariables ];
  variable_to_index = new int [ nvariables ];
  variable_marks = new int [ nvariables ];
  for (int i = 0; i < nvariables; i++) variable_marks[i] = 0;
  current_mark = 1;

  // Copy equations
  equations.Resize(system.NEquations());
  for (int i = 0; i < system.NEquations(); i++) {
    RNEquation *equation = system.Equation(i);
    InsertEquation(new RNEquation(*equation));
  }

  // Copy lower bounds
  if (system.lower_bounds) {
    lower_bounds = new RNScalar [ nvariables ];
    for (int i = 0; i < nvariables; i++) {
      lower_bounds[i] = system.lower_bounds[i];
    }
  }
  
  // Copy upper bounds
  if (system.upper_bounds) {
    upper_bounds = new RNScalar [ nvariables ];
    for (int i = 0; i < nvariables; i++) {
      upper_bounds[i] = system.upper_bounds[i];
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movl 0x30(%rsi), %eax
movl %eax, 0x30(%rdi)
leaq 0x38(%rdi), %rbx
movq %rbx, %rdi
callq 0x2751c
movslq 0x30(%r15), %rax
leaq (,%rax,4), %rcx
testq %rax, %rax
movq $-0x1, %r12
cmovnsq %rcx, %r12
movq %r12, %rdi
callq 0x4030
movq %rax, (%r15)
movq %r12, %rdi
callq 0x4030
movq %rax, 0x8(%r15)
movq %r12, %rdi
callq 0x4030
movq %rax, 0x10(%r15)
movslq 0x30(%r15), %rdx
testq %rdx, %rdx
jle 0x26500
shlq $0x2, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x4160
movl $0x1, 0x18(%r15)
movl 0x44(%r14), %esi
movq %rbx, %rdi
callq 0x27610
cmpl $0x0, 0x44(%r14)
jle 0x26554
xorl %ebp, %ebp
movq 0x38(%r14), %rax
movq (%rax,%rbp,8), %r13
movl $0x40, %edi
callq 0x4270
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
callq 0x271f2
movq %r15, %rdi
movq %r12, %rsi
callq 0x2661c
incq %rbp
movslq 0x44(%r14), %rax
cmpq %rax, %rbp
jl 0x2651d
cmpq $0x0, 0x20(%r14)
je 0x2659e
movslq 0x30(%r15), %r12
leaq (,%r12,8), %rax
testq %r12, %r12
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x4030
leaq 0x20(%r15), %rcx
movq %rax, (%rcx)
testl %r12d, %r12d
jle 0x2659e
movq 0x20(%r14), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x2658c
cmpq $0x0, 0x28(%r14)
je 0x265e5
movslq 0x30(%r15), %r12
leaq (,%r12,8), %rax
testq %r12, %r12
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x4030
movq %rax, 0x28(%r15)
testl %r12d, %r12d
jle 0x265e5
movq 0x28(%r14), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x265d3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26608
movq %rax, %r14
movl $0x40, %esi
movq %r12, %rdi
callq 0x4280
jmp 0x2660b
movq %rax, %r14
movq %rbx, %rdi
callq 0x27586
movq %r14, %rdi
callq 0x44b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/RNMath/RNSystemOfEquations.cpp
// Function: gaps::RNSystemOfEquations::InsertEquation(gaps::RNEquation*)
void RNSystemOfEquations::
InsertEquation(RNEquation *equation)
{
  // Check equation
  if (equation->IsConstant()) { delete equation; return; }

  // Just checking
  assert(!equation->system);
  assert(equation->system_index == -1);
  // assert(!equations.FindEntry(equation));

  // Insert equation
  equation->system = this;
  equation->system_index = equations.NEntries();
  equations.Insert(equation);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x24352
testl %eax, %eax
je 0x26642
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x8(%rax)
movq %r14, 0x28(%rbx)
movl 0x44(%r14), %edx
addq $0x38, %r14
movl %edx, 0x30(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x275b2
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/RNMath/RNSystemOfEquations.cpp
// Function: gaps::RNSystemOfEquations::~RNSystemOfEquations()
RNSystemOfEquations::
~RNSystemOfEquations(void)
{
  // Delete memory for variable counting
  if (index_to_variable) delete [] index_to_variable;
  if (variable_to_index) delete [] variable_to_index;
  if (variable_marks) delete [] variable_marks;

  // Delete all equations
  while (NEquations() > 0) {
    RNEquation *equation = equations.Tail();
    RemoveEquation(equation);
    delete equation;
  }

  // Delete all bounds
  if (lower_bounds) delete [] lower_bounds;
  if (upper_bounds) delete [] upper_bounds;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x26679
callq 0x4350
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x26687
callq 0x4350
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x26695
callq 0x4350
movl 0x44(%rbx), %esi
testl %esi, %esi
jle 0x266ee
leaq 0x38(%rbx), %r14
movslq 0x44(%rbx), %rax
movq 0x38(%rbx), %rcx
movq -0x8(%rcx,%rax,8), %r15
movslq 0x30(%r15), %rax
movl %esi, %edx
movq -0x8(%rcx,%rdx,8), %rdx
movl %eax, 0x30(%rdx)
movq %rdx, (%rcx,%rax,8)
decl %esi
movq %r14, %rdi
callq 0x27726
movl $0xffffffff, 0x30(%r15) # imm = 0xFFFFFFFF
movq $0x0, 0x28(%r15)
testq %r15, %r15
je 0x266e7
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movl 0x44(%rbx), %esi
testl %esi, %esi
jg 0x266a0
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x266fc
callq 0x4350
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x2670a
callq 0x4350
addq $0x38, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x27586
movq %rax, %rdi
callq 0x226a1
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/RNMath/RNSystemOfEquations.cpp
// Function: gaps::RNSystemOfEquations::RemoveEquation(gaps::RNEquation*)
void RNSystemOfEquations::
RemoveEquation(RNEquation *equation)
{
  // Just checking
  assert(equation->system == this);
  assert(equation->system_index >= 0);
  // assert(equations.FindEntry(equation));

  // Remove equation
  RNArrayEntry *entry = equations.KthEntry(equation->system_index);
  assert(entry && (equations.EntryContents(entry) == equation));
  RNEquation *tail = equations.Tail();
  tail->system_index = equation->system_index;
  equations.EntryContents(entry) = tail;
  equations.RemoveTail();
  equation->system_index = -1;
  equation->system = NULL;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
leaq 0x38(%rdi), %rax
movslq 0x30(%rsi), %rcx
movq 0x38(%rdi), %rdx
movslq 0x44(%rdi), %rsi
movq -0x8(%rdx,%rsi,8), %rdi
movl %ecx, 0x30(%rdi)
movq %rdi, (%rdx,%rcx,8)
decl %esi
movq %rax, %rdi
callq 0x27726
movl $0xffffffff, 0x30(%rbx) # imm = 0xFFFFFFFF
movq $0x0, 0x28(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/RNMath/RNSystemOfEquations.cpp
// Function: gaps::RNSystemOfEquations::NPartialDerivatives() const
int RNSystemOfEquations::
NPartialDerivatives(void) const
{
  // Return number of partial derivatives
  int count = 0;
  for (int i = 0; i < NEquations(); i++) {
    RNEquation *equation = Equation(i);
    equation->UpdateVariableIndex(nvariables, count, variable_marks, current_mark);
    ((RNSystemOfEquations *) this)->current_mark++;
  }
  return count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0x0, 0xc(%rsp)
cmpl $0x0, 0x44(%rdi)
jle 0x267b7
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0xc(%rsp), %r14
movq 0x38(%rbx), %rax
movq (%rax,%r15,8), %rdi
movl 0x30(%rbx), %esi
movq 0x10(%rbx), %rcx
movl 0x18(%rbx), %r8d
movq %r14, %rdx
xorl %r9d, %r9d
pushq $0x0
pushq $0x0
callq 0x247d0
addq $0x10, %rsp
incl 0x18(%rbx)
incq %r15
movslq 0x44(%rbx), %rax
cmpq %rax, %r15
jl 0x26782
movl 0xc(%rsp), %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/RNMath/RNSystemOfEquations.cpp
// Function: gaps::RNSystemOfEquations::IsLinear() const
RNBoolean RNSystemOfEquations::
IsLinear(void) const
{
  // Check whether all equations are linear
  for (int i = 0; i < NEquations(); i++) {
    RNEquation *equation = Equation(i);
    if (!equation->IsLinear()) return FALSE;
  }

  // Passed all tests
  return TRUE;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x0, 0x44(%rdi)
setle %bpl
jle 0x2680e
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq (%rax), %rdi
callq 0x243ec
testl %eax, %eax
je 0x2680e
movl $0x1, %r14d
movslq 0x44(%rbx), %rax
cmpq %rax, %r14
setge %bpl
jge 0x2680e
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x243ec
incq %r14
testl %eax, %eax
jne 0x267ed
movzbl %bpl, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/RNMath/RNSystemOfEquations.cpp
// Function: gaps::RNSystemOfEquations::IsQuadratic() const
RNBoolean RNSystemOfEquations::
IsQuadratic(void) const
{
  // Check whether all equations are quadratic
  for (int i = 0; i < NEquations(); i++) {
    RNEquation *equation = Equation(i);
    if (!equation->IsQuadratic()) return FALSE;
  }

  // Passed all tests
  return TRUE;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x0, 0x44(%rdi)
setle %bpl
jle 0x26860
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq (%rax), %rdi
callq 0x244be
testl %eax, %eax
je 0x26860
movl $0x1, %r14d
movslq 0x44(%rbx), %rax
cmpq %rax, %r14
setge %bpl
jge 0x26860
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x244be
incq %r14
testl %eax, %eax
jne 0x2683f
movzbl %bpl, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/RNMath/RNSystemOfEquations.cpp
// Function: gaps::RNSystemOfEquations::IsPolynomial() const
RNBoolean RNSystemOfEquations::
IsPolynomial(void) const
{
  // Check whether all equations are polynomial
  for (int i = 0; i < NEquations(); i++) {
    RNEquation *equation = Equation(i);
    if (!equation->IsPolynomial()) return FALSE;
  }

  // Passed all tests
  return TRUE;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x0, 0x44(%rdi)
setle %bpl
jle 0x268b2
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq (%rax), %rdi
callq 0x245ae
testl %eax, %eax
je 0x268b2
movl $0x1, %r14d
movslq 0x44(%rbx), %rax
cmpq %rax, %r14
setge %bpl
jge 0x268b2
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x245ae
incq %r14
testl %eax, %eax
jne 0x26891
movzbl %bpl, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop