LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x211b4
testl %eax, %eax
je 0x24e68
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x246a8
movq %r14, %rdi
callq 0x211be
testl %eax, %eax
je 0x24e7d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rbx), %ebp
testl %ebp, %ebp
je 0x24e74
cmpl $0x1, %ebp
jne 0x24e9d
movq 0x20(%rbx), %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21560
movl $0x28, %edi
callq 0x4280
movq %rax, %r15
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0x56947(%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 0x23c2c
movl $0x4, 0x8(%rbx)
movl $0x28, %edi
callq 0x4280
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x22864
movq %r12, 0x10(%rbx)
movq %r15, 0x18(%rbx)
jmp 0x24e74
movq %rax, %rbx
movq %r12, %r15
jmp 0x24f18
movq %rax, %rbx
movl $0x28, %esi
movq %r15, %rdi
callq 0x4290
movq %rbx, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x211b4
testl %eax, %eax
je 0x24f94
movq %rbx, %rdi
callq 0x22676
movl %eax, %ebp
movq %rbx, %rdi
callq 0x246a8
testl %ebp, %ebp
jne 0x24fa0
movl $0x1, 0x8(%rbx)
movl $0x10, %edi
callq 0x4280
movq %rax, %r14
leaq 0x57437(%rip), %rax     # 0x7c3b0
movsd (%rax), %xmm0
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x20ce4
movq %r14, 0x20(%rbx)
jmp 0x24fa0
movq %r14, %rdi
callq 0x211be
testl %eax, %eax
je 0x24fa9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rbx), %ebp
testl %ebp, %ebp
je 0x24fa0
cmpl $0x1, %ebp
jne 0x24fff
movl $0x5, 0x8(%rbx)
movl $0x28, %edi
callq 0x4280
movq %rax, %r15
movq 0x20(%rbx), %rsi
movq %rax, %rdi
callq 0x22582
movq %r15, 0x10(%rbx)
movl $0x28, %edi
callq 0x4280
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x22864
movq %r15, 0x18(%rbx)
movq $0x0, 0x20(%rbx)
jmp 0x24fa0
movl $0x28, %edi
callq 0x4280
movq %rax, %r15
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0x567e5(%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 0x23c2c
movl $0x5, 0x8(%rbx)
movl $0x28, %edi
callq 0x4280
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x22864
movq %r12, 0x10(%rbx)
movq %r15, 0x18(%rbx)
jmp 0x24fa0
movq %rax, %rbx
movl $0x28, %esi
movq %r12, %rdi
jmp 0x25098
jmp 0x25080
jmp 0x25080
movq %rax, %rbx
movl $0x28, %esi
movq %r15, %rdi
jmp 0x25098
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x4290
movq %rbx, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x22676
testl %eax, %eax
je 0x250c9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rbx), %ebp
cmpl $0x1, %ebp
je 0x250e8
testl %ebp, %ebp
jne 0x25108
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x251ea
cmpl $0x1, 0x8(%r15)
jne 0x25178
movq 0x20(%rbx), %rdi
movq 0x20(%r15), %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x214b6
movl $0x28, %edi
callq 0x4280
movq %rax, %r14
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0x566dc(%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 0x23c2c
movl $0x28, %edi
callq 0x4280
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x228dc
movq %r12, 0x10(%rbx)
movq %r14, 0x18(%rbx)
movl $0x2, 0x8(%rbx)
jmp 0x250c0
movl $0x28, %edi
callq 0x4280
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x228dc
movq %r14, 0x10(%rbx)
movl $0x28, %edi
callq 0x4280
movq %rax, %r14
movq 0x20(%rbx), %rsi
movq %rax, %rdi
callq 0x22582
movq %r14, 0x18(%rbx)
movl $0x2, 0x8(%rbx)
movq $0x0, 0x20(%rbx)
jmp 0x250c0
jmp 0x251d1
jmp 0x251d1
movq %rax, %rbx
movq %r12, %r14
jmp 0x251d4
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0x4290
movq %rbx, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x246a8
movl 0x8(%r15), %eax
movl %eax, 0x8(%rbx)
testl %eax, %eax
je 0x2526b
cmpl $0x1, %eax
jne 0x2522b
movl $0x10, %edi
callq 0x4280
movq %rax, %r14
movq 0x20(%r15), %rsi
movl $0x20, %r15d
movq %rax, %rdi
callq 0x20bde
jmp 0x25267
movl $0x28, %edi
callq 0x4280
movq %rax, %r14
movq 0x10(%r15), %rsi
movq %rax, %rdi
callq 0x228dc
movq %r14, 0x10(%rbx)
movl $0x28, %edi
callq 0x4280
movq %rax, %r14
movq 0x18(%r15), %rsi
movl $0x18, %r15d
movq %rax, %rdi
callq 0x228dc
movq %r14, (%rbx,%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x25276
movq %rax, %rbx
movl $0x28, %esi
jmp 0x25288
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x4290
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x22676
testl %eax, %eax
je 0x252bb
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rbx), %ebp
cmpl $0x1, %ebp
je 0x252e2
testl %ebp, %ebp
jne 0x25302
movq %rbx, %rdi
movq %r15, %rsi
callq 0x251ea
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2402e
cmpl $0x1, 0x8(%r15)
jne 0x25372
movq 0x20(%rbx), %rdi
movq 0x20(%r15), %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21508
movl $0x28, %edi
callq 0x4280
movq %rax, %r14
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0x564e2(%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 0x23c2c
movl $0x28, %edi
callq 0x4280
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x228dc
movq %r12, 0x18(%rbx)
movq %r14, 0x10(%rbx)
movl $0x3, 0x8(%rbx)
jmp 0x252b2
movl $0x28, %edi
callq 0x4280
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x228dc
movq %r14, 0x18(%rbx)
movl $0x28, %edi
callq 0x4280
movq %rax, %r14
movq 0x20(%rbx), %rsi
movq %rax, %rdi
callq 0x22582
movq %r14, 0x10(%rbx)
movl $0x3, 0x8(%rbx)
movq $0x0, 0x20(%rbx)
jmp 0x252b2
jmp 0x253cb
jmp 0x253cb
movq %rax, %rbx
movq %r12, %r14
jmp 0x253ce
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0x4290
movq %rbx, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x22676
testl %eax, %eax
je 0x2540e
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x246a8
movq %r15, %rdi
callq 0x240ba
testl %eax, %eax
je 0x25423
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rbx), %ebp
testl %ebp, %ebp
je 0x2541a
cmpl $0x1, %ebp
jne 0x2544f
cmpl $0x1, 0x8(%r15)
jne 0x254bf
movq 0x20(%rbx), %rdi
movq 0x20(%r15), %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21560
movl $0x28, %edi
callq 0x4280
movq %rax, %r14
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0x56395(%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 0x23c2c
movl $0x28, %edi
callq 0x4280
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x228dc
movq %r12, 0x10(%rbx)
movq %r14, 0x18(%rbx)
movl $0x4, 0x8(%rbx)
jmp 0x2541a
movl $0x28, %edi
callq 0x4280
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x228dc
movq %r14, 0x18(%rbx)
movl $0x28, %edi
callq 0x4280
movq %rax, %r14
movq 0x20(%rbx), %rsi
movq %rax, %rdi
callq 0x22582
movq %r14, 0x10(%rbx)
movl $0x4, 0x8(%rbx)
movq $0x0, 0x20(%rbx)
jmp 0x2541a
jmp 0x25518
jmp 0x25518
movq %rax, %rbx
movq %r12, %r14
jmp 0x2551b
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0x4290
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x22676
testl %eax, %eax
je 0x25596
movq %rbx, %rdi
callq 0x22676
movl %eax, %ebp
movq %rbx, %rdi
callq 0x246a8
testl %ebp, %ebp
jne 0x255a2
movl $0x1, 0x8(%rbx)
movl $0x10, %edi
callq 0x4280
movq %rax, %r14
leaq 0x56e35(%rip), %rax     # 0x7c3b0
movsd (%rax), %xmm0
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x20ce4
movq %r14, 0x20(%rbx)
jmp 0x255a2
movq %r14, %rdi
callq 0x240ba
testl %eax, %eax
je 0x255ab
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rbx), %ebp
testl %ebp, %ebp
je 0x255a2
movl $0x28, %edi
cmpl $0x1, %ebp
jne 0x25601
callq 0x4280
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x228dc
movq %r15, 0x18(%rbx)
movl $0x28, %edi
callq 0x4280
movq %rax, %r14
movq 0x20(%rbx), %rsi
movq %rax, %rdi
callq 0x22582
movq %r14, 0x10(%rbx)
movl $0x5, 0x8(%rbx)
movq $0x0, 0x20(%rbx)
jmp 0x255a2
callq 0x4280
movq %rax, %r15
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0x561e8(%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 0x23c2c
movl $0x28, %edi
callq 0x4280
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x228dc
movq %r12, 0x10(%rbx)
movq %r15, 0x18(%rbx)
movl $0x5, 0x8(%rbx)
jmp 0x255a2
movq %rax, %rbx
movl $0x28, %esi
movq %r12, %rdi
jmp 0x2569d
movq %rax, %rbx
movl $0x28, %esi
jmp 0x2569a
jmp 0x25685
movq %rax, %rbx
movl $0x28, %esi
movq %r15, %rdi
jmp 0x2569d
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x4290
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x246a8
movl $0x1, 0x8(%rbx)
movl $0x10, %edi
callq 0x4280
movq %rax, %r14
movq %rax, %rdi
movsd (%rsp), %xmm0
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x20ce4
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 0x4290
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x246a8
movl $0x1, 0x8(%rbx)
movl $0x10, %edi
callq 0x4280
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x20bde
movq %r14, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x4290
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2581b
movq %rdi, %r14
leaq 0x350aa(%rip), %rax     # 0x5a82c
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 0x218c6
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x25760
movsd %xmm0, (%rsp)
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x25760
mulsd (%rsp), %xmm0
jmp 0x258cb
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x25760
movsd %xmm0, (%rsp)
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x25760
addsd (%rsp), %xmm0
jmp 0x258cb
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x25760
movsd %xmm0, (%rsp)
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x25760
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x258cb
leaq 0x350cc(%rip), %rdi     # 0x5a8ee
xorl %eax, %eax
callq 0x29356
xorpd %xmm0, %xmm0
jmp 0x258cb
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x25760
leaq 0x56b53(%rip), %rax     # 0x7c398
movsd (%rax), %xmm2
movapd 0x3380f(%rip), %xmm1    # 0x59060
xorpd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jb 0x258b5
ucomisd %xmm0, %xmm2
jb 0x258b5
leaq 0x56b48(%rip), %rax     # 0x7c3b0
movsd (%rax), %xmm0
jmp 0x258cb
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x25760
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x2588a
jnp 0x258cb
movsd %xmm1, (%rsp)
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x25760
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x258d3
jp 0x258d3
movsd 0x3375d(%rip), %xmm0    # 0x59010
jmp 0x258cb
movq 0x10(%r14), %rdi
movq %rbx, %rsi
movsd %xmm0, (%rsp)
callq 0x25760
divsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x44b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2599f
movq %rdi, %r14
leaq 0x34f42(%rip), %rax     # 0x5a848
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 0x21a20
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x258e4
movsd %xmm0, (%rsp)
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x258e4
mulsd (%rsp), %xmm0
jmp 0x25a4f
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x258e4
movsd %xmm0, (%rsp)
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x258e4
addsd (%rsp), %xmm0
jmp 0x25a4f
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x258e4
movsd %xmm0, (%rsp)
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x258e4
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x25a4f
leaq 0x34f48(%rip), %rdi     # 0x5a8ee
xorl %eax, %eax
callq 0x29356
xorpd %xmm0, %xmm0
jmp 0x25a4f
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x258e4
leaq 0x569cf(%rip), %rax     # 0x7c398
movsd (%rax), %xmm2
movapd 0x3368b(%rip), %xmm1    # 0x59060
xorpd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jb 0x25a39
ucomisd %xmm0, %xmm2
jb 0x25a39
leaq 0x569c4(%rip), %rax     # 0x7c3b0
movsd (%rax), %xmm0
jmp 0x25a4f
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x258e4
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x25a0e
jnp 0x25a4f
movsd %xmm1, (%rsp)
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x258e4
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x25a57
jp 0x25a57
movsd 0x335d9(%rip), %xmm0    # 0x59010
jmp 0x25a4f
movq 0x10(%r14), %rdi
movq %rbx, %rsi
movsd %xmm0, (%rsp)
callq 0x258e4
divsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x44b0
// File: /workspace/github_cpp_makefile_star2_O3/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), %edx
testl %edx, %edx
je 0x260c1
movq %rdi, %r15
cmpl $0x1, %edx
jne 0x260e4
testl %r14d, %r14d
jle 0x260ab
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4350
decl %r14d
jne 0x26099
movq 0x20(%r15), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21fe6
testl %r14d, %r14d
jle 0x260d8
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4350
decl %r14d
jne 0x260c6
leaq 0x33b8c(%rip), %rdi     # 0x59c6b
jmp 0x26185
testl %r14d, %r14d
jle 0x2614b
movl %r14d, %ebp
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4350
decl %ebp
jne 0x260ec
movl 0x8(%r15), %edx
leaq 0x34806(%rip), %rsi     # 0x5a90e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x43e0
movq 0x10(%r15), %rdi
leal 0x2(%r14), %ebp
movq %rbx, %rsi
movl %ebp, %edx
callq 0x26078
movq 0x18(%r15), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x26078
testl %r14d, %r14d
jle 0x2617e
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4350
decl %r14d
jne 0x26137
jmp 0x2617e
leaq 0x347bc(%rip), %rsi     # 0x5a90e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x43e0
movq 0x10(%r15), %rdi
addl $0x2, %r14d
movq %rbx, %rsi
movl %r14d, %edx
callq 0x26078
movq 0x18(%r15), %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x26078
leaq 0x3478f(%rip), %rdi     # 0x5a914
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2625f
movq 0x20(%rdi), %rax
cmpl $0x1, %ecx
je 0x261ce
testl %ecx, %ecx
jne 0x261e3
testq %rax, %rax
je 0x261f1
leaq 0x3475d(%rip), %rdi     # 0x5a926
jmp 0x26253
testq %rax, %rax
je 0x26201
cmpq $0x0, 0x10(%rdi)
je 0x26226
leaq 0x3473c(%rip), %rdi     # 0x5a91d
jmp 0x26253
testq %rax, %rax
je 0x2620a
leaq 0x34740(%rip), %rdi     # 0x5a92f
jmp 0x26253
cmpq $0x0, 0x10(%rdi)
je 0x26236
leaq 0x34724(%rip), %rdi     # 0x5a923
jmp 0x26253
leaq 0x3470f(%rip), %rdi     # 0x5a917
jmp 0x26253
cmpq $0x0, 0x10(%rdi)
je 0x2624c
movl $0x1, %eax
cmpq $0x0, 0x18(%rdi)
jne 0x2625f
leaq 0x34708(%rip), %rdi     # 0x5a92c
jmp 0x26253
cmpq $0x0, 0x18(%rdi)
je 0x26246
leaq 0x346e6(%rip), %rdi     # 0x5a91a
jmp 0x26253
cmpq $0x0, 0x18(%rdi)
je 0x26246
leaq 0x346dc(%rip), %rdi     # 0x5a920
jmp 0x26253
movl $0x1, %eax
retq
leaq 0x346d6(%rip), %rdi     # 0x5a929
pushq %rax
callq 0x4430
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movl %esi, 0x30(%rdi)
leaq 0x38(%rdi), %r15
movq %r15, %rdi
callq 0x27330
movl %ebp, %r14d
shlq $0x2, %r14
testl %ebp, %ebp
movq $-0x1, %r12
cmovnsq %r14, %r12
movq %r12, %rdi
callq 0x4030
movq %rax, (%rbx)
movq %r12, %rdi
callq 0x4030
movq %rax, 0x8(%rbx)
movq %r12, %rdi
callq 0x4030
movq %rax, 0x10(%rbx)
testl %ebp, %ebp
jle 0x262cb
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x4160
movl $0x1, 0x18(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x2739a
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x27330
movslq 0x30(%r15), %rbp
leaq (,%rbp,4), %r12
testq %rbp, %rbp
movq $-0x1, %r13
cmovnsq %r12, %r13
movq %r13, %rdi
callq 0x4030
movq %rax, (%r15)
movq %r13, %rdi
callq 0x4030
movq %rax, 0x8(%r15)
movq %r13, %rdi
callq 0x4030
movq %rax, 0x10(%r15)
testl %ebp, %ebp
jle 0x26366
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x4160
movl $0x1, 0x18(%r15)
movl 0x44(%r14), %esi
movq %rbx, %rdi
callq 0x2742a
cmpl $0x0, 0x44(%r14)
jle 0x263ba
xorl %ebp, %ebp
movq 0x38(%r14), %rax
movq (%rax,%rbp,8), %r13
movl $0x40, %edi
callq 0x4280
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
callq 0x27006
movq %r15, %rdi
movq %r12, %rsi
callq 0x26482
incq %rbp
movslq 0x44(%r14), %rax
cmpq %rax, %rbp
jl 0x26383
cmpq $0x0, 0x20(%r14)
je 0x26404
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 0x26404
movq 0x20(%r14), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x263f2
cmpq $0x0, 0x28(%r14)
je 0x2644b
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 0x2644b
movq 0x28(%r14), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x26439
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2646e
movq %rax, %r14
movl $0x40, %esi
movq %r12, %rdi
callq 0x4290
jmp 0x26471
movq %rax, %r14
movq %rbx, %rdi
callq 0x2739a
movq %r14, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2418e
testl %eax, %eax
je 0x264a8
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 0x273c6
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x264df
callq 0x4360
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x264ed
callq 0x4360
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x264fb
callq 0x4360
movl 0x44(%rbx), %esi
testl %esi, %esi
jle 0x26542
leaq 0x38(%rbx), %r14
movq (%r14), %rax
movl %esi, %ecx
movq -0x8(%rax,%rcx,8), %r15
movslq 0x30(%r15), %rcx
movq %r15, (%rax,%rcx,8)
decl %esi
movq %r14, %rdi
callq 0x27550
movl $0xffffffff, 0x30(%r15) # imm = 0xFFFFFFFF
movq $0x0, 0x28(%r15)
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movl 0x44(%rbx), %esi
testl %esi, %esi
jg 0x26506
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x26550
callq 0x4360
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x2655e
callq 0x4360
addq $0x38, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2739a
movq %rax, %rdi
callq 0x22553
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x26619
movq %rdi, %rbx
movl 0x18(%rdi), %r8d
xorl %r15d, %r15d
leaq 0xc(%rsp), %r14
movq 0x38(%rbx), %rax
movq (%rax,%r15,8), %rdi
movl 0x30(%rbx), %esi
movq 0x10(%rbx), %rcx
movq %r14, %rdx
xorl %r9d, %r9d
pushq $0x0
pushq $0x0
callq 0x2460c
addq $0x10, %rsp
movl 0x18(%rbx), %r8d
incl %r8d
movl %r8d, 0x18(%rbx)
incq %r15
movslq 0x44(%rbx), %rax
cmpq %rax, %r15
jl 0x265da
movl 0xc(%rsp), %eax
jmp 0x2661b
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpl $0x0, 0x44(%rdi)
jle 0x26663
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x24228
testl %eax, %eax
je 0x26653
incq %r14
movslq 0x44(%rbx), %rcx
cmpq %rcx, %r14
jl 0x26636
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x26668
movl $0x1, %ecx
movl %ecx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpl $0x0, 0x44(%rdi)
jle 0x266a9
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x242fa
testl %eax, %eax
je 0x26699
incq %r14
movslq 0x44(%rbx), %rcx
cmpq %rcx, %r14
jl 0x2667c
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x266ae
movl $0x1, %ecx
movl %ecx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpl $0x0, 0x44(%rdi)
jle 0x266ef
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x243ea
testl %eax, %eax
je 0x266df
incq %r14
movslq 0x44(%rbx), %rcx
cmpq %rcx, %r14
jl 0x266c2
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x266f4
movl $0x1, %ecx
movl %ecx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNMath/RNSystemOfEquations.cpp
// Function: gaps::RNSystemOfEquations::HasVariable(int) const
RNBoolean RNSystemOfEquations::
HasVariable(int v) const
{
  // Check whether any equation has variable v
  for (int i = 0; i < NEquations(); i++) {
    RNEquation *equation = Equation(i);
    if (equation->HasVariable(v)) return TRUE;
  }

  // No equation has variable v
  return FALSE;
}

// Assembly:
cmpl $0x0, 0x44(%rdi)
jle 0x2673e
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x38(%r14), %rax
movq (%rax,%r15,8), %rdi
movl %ebx, %esi
callq 0x24468
testl %eax, %eax
jne 0x26730
incq %r15
movslq 0x44(%r14), %rcx
cmpq %rcx, %r15
jl 0x26711
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
popq %rbx
popq %r14
popq %r15
jmp 0x26740
xorl %ecx, %ecx
movl %ecx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNMath/RNSystemOfEquations.cpp
// Function: gaps::RNSystemOfEquations::InsertEquation(gaps::RNPolynomial*)
void RNSystemOfEquations::
InsertEquation(RNPolynomial *polynomial)
{
  // Check polynomial
  if (polynomial->IsConstant()) { delete polynomial; return; }

  // Insert equation
  RNEquation *equation = new RNEquation(polynomial);
  InsertEquation(equation);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x21210
testl %eax, %eax
je 0x26775
movq %rbx, %rdi
callq 0x20f24
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4290
movl $0x40, %edi
callq 0x4280
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x26f22
movq %r14, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x26482
movq %rax, %rbx
movl $0x40, %esi
movq %r15, %rdi
callq 0x4290
movq %rbx, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNMath/RNSystemOfEquations.cpp
// Function: gaps::RNSystemOfEquations::InsertEquation(gaps::RNAlgebraic*)
void RNSystemOfEquations::
InsertEquation(RNAlgebraic *algebraic)
{
  // Check algebraic
  if (algebraic->IsConstant()) { delete algebraic; return; }

  // Insert equation
  RNEquation *equation = new RNEquation(algebraic);
  InsertEquation(equation);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2418e
testl %eax, %eax
je 0x267db
movq (%r14), %rax
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x8(%rax)
movl $0x40, %edi
callq 0x4280
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x26f48
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x26482
movq %rax, %rbx
movl $0x40, %esi
movq %r15, %rdi
callq 0x4290
movq %rbx, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNMath/RNSystemOfEquations.cpp
// Function: gaps::RNSystemOfEquations::InsertEquation(gaps::RNPolynomial*, double)
void RNSystemOfEquations::
InsertEquation(RNPolynomial *polynomial, RNScalar residual_threshold)
{
  // Check polynomial
  if (polynomial->IsConstant()) { delete polynomial; return; }

  // Insert equation
  RNEquation *equation = new RNEquation(polynomial);
  equation->SetResidualThreshold(residual_threshold);
  InsertEquation(equation);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x21210
testl %eax, %eax
je 0x2685b
movq %rbx, %rdi
callq 0x20f24
movl $0x10, %esi
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x4290
movl $0x40, %edi
callq 0x4280
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x26f22
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x38(%r15)
movq %r14, %rdi
movq %r15, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x26482
movq %rax, %rbx
movl $0x40, %esi
movq %r15, %rdi
callq 0x4290
movq %rbx, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNMath/RNSystemOfEquations.cpp
// Function: gaps::RNSystemOfEquations::InsertEquation(gaps::RNAlgebraic*, double)
void RNSystemOfEquations::
InsertEquation(RNAlgebraic *algebraic, RNScalar residual_threshold)
{
  // Check algebraic
  if (algebraic->IsConstant()) { delete algebraic; return; }

  // Insert equation
  RNEquation *equation = new RNEquation(algebraic);
  equation->SetResidualThreshold(residual_threshold);
  InsertEquation(equation);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2418e
testl %eax, %eax
je 0x268df
movq (%r14), %rax
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmpq *0x8(%rax)
movl $0x40, %edi
callq 0x4280
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x26f48
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x38(%r15)
movq %rbx, %rdi
movq %r15, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x26482
movq %rax, %rbx
movl $0x40, %esi
movq %r15, %rdi
callq 0x4290
movq %rbx, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNMath/RNSystemOfEquations.cpp
// Function: gaps::RNSystemOfEquations::SetLowerBound(int, double)
void RNSystemOfEquations::
SetLowerBound(int variable, RNScalar bound)
{
  // Just checking
  assert((variable >= 0) && (variable < nvariables));
  
  // Allocate lower bounds
  if (!lower_bounds) {
    lower_bounds = new RNScalar [ nvariables ];
    for (int i = 0; i < nvariables; i++) {
      lower_bounds[i] = -FLT_MAX;
    }
  }

  // Set lower bound
  lower_bounds[variable] = bound;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq 0x20(%rdi), %rax
testq %rax, %rax
jne 0x26a1d
movq %rdi, %r14
movq %xmm0, 0x8(%rsp)
movslq 0x30(%rdi), %r15
leaq (,%r15,8), %rax
testq %r15, %r15
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x4030
movq %rax, 0x20(%r14)
testq %r15, %r15
jle 0x26a17
leal 0x1(%r15), %ecx
decq %r15
movq %r15, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shrl %ecx
shlq $0x4, %rcx
movdqa 0x32f24(%rip), %xmm1    # 0x598c0
xorl %edx, %edx
movdqa 0x32f2a(%rip), %xmm2    # 0x598d0
pxor %xmm2, %xmm0
movabsq $-0x3810000020000000, %rsi # imm = 0xC7EFFFFFE0000000
pcmpeqd %xmm3, %xmm3
movdqa 0x32f20(%rip), %xmm4    # 0x598e0
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %edi
notl %edi
testb $0x1, %dil
je 0x269f6
movq %rsi, (%rax,%rdx)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %edi
testb $0x1, %dil
je 0x26a0a
movq %rsi, 0x8(%rax,%rdx)
paddq %xmm4, %xmm1
addq $0x10, %rdx
cmpq %rdx, %rcx
jne 0x269c0
movsd 0x8(%rsp), %xmm0
movslq %ebx, %rcx
movsd %xmm0, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNMath/RNSystemOfEquations.cpp
// Function: gaps::RNSystemOfEquations::SetUpperBound(int, double)
void RNSystemOfEquations::
SetUpperBound(int variable, RNScalar bound)
{
  // Just checking
  assert((variable >= 0) && (variable < nvariables));
  
  // Allocate upper bounds
  if (!upper_bounds) {
    upper_bounds = new RNScalar [ nvariables ];
    for (int i = 0; i < nvariables; i++) {
      upper_bounds[i] = -FLT_MAX;
    }
  }

  // Set upper bound
  upper_bounds[variable] = bound;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq 0x28(%rdi), %rax
testq %rax, %rax
jne 0x26b1d
movq %rdi, %r14
movq %xmm0, 0x8(%rsp)
movslq 0x30(%rdi), %r15
leaq (,%r15,8), %rax
testq %r15, %r15
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x4030
movq %rax, 0x28(%r14)
testq %r15, %r15
jle 0x26b17
leal 0x1(%r15), %ecx
decq %r15
movq %r15, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shrl %ecx
shlq $0x4, %rcx
movdqa 0x32e24(%rip), %xmm1    # 0x598c0
xorl %edx, %edx
movdqa 0x32e2a(%rip), %xmm2    # 0x598d0
pxor %xmm2, %xmm0
movabsq $-0x3810000020000000, %rsi # imm = 0xC7EFFFFFE0000000
pcmpeqd %xmm3, %xmm3
movdqa 0x32e20(%rip), %xmm4    # 0x598e0
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %edi
notl %edi
testb $0x1, %dil
je 0x26af6
movq %rsi, (%rax,%rdx)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %edi
testb $0x1, %dil
je 0x26b0a
movq %rsi, 0x8(%rax,%rdx)
paddq %xmm4, %xmm1
addq $0x10, %rdx
cmpq %rdx, %rcx
jne 0x26ac0
movsd 0x8(%rsp), %xmm0
movslq %ebx, %rcx
movsd %xmm0, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNMath/RNSystemOfEquations.cpp
// Function: gaps::RNSystemOfEquations::EvaluateResiduals(double const*, double*) const
void RNSystemOfEquations::
EvaluateResiduals(const RNScalar *x, RNScalar *y) const
{
  // Evaluate equations
  for (int i = 0; i < NEquations(); i++) {
    RNEquation *equation = Equation(i);
    y[i] = equation->Evaluate(x);
  }
}

// Assembly:
cmpl $0x0, 0x44(%rdi)
jle 0x26b77
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movq 0x38(%r15), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
callq 0x25760
movsd %xmm0, (%rbx,%r12,8)
incq %r12
movslq 0x44(%r15), %rax
cmpq %rax, %r12
jl 0x26b4a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq