LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
callq 0x3fa70
cmpl $0x0, %eax
je 0x4547c
jmp 0x45645
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x24(%rsp)
testl %eax, %eax
je 0x4549c
jmp 0x4548e
movl 0x24(%rsp), %eax
subl $0x1, %eax
je 0x454b0
jmp 0x45593
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x45660
jmp 0x45645
movq 0x48(%rsp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x454d7
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x48(%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x3d5e0
jmp 0x4558e
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rsi
callq 0x3fe60
jmp 0x454f8
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq 0x28(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movq 0x20(%rax), %rsi
callq 0x3f8b0
jmp 0x4552b
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rax)
movl $0x2, 0x8(%rax)
movq $0x0, 0x20(%rax)
jmp 0x4558e
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x4564a
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x4564a
jmp 0x45645
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq 0x28(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x8(%rsp)
movl 0x8(%rax), %esi
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
callq 0x42ac0
jmp 0x455bf
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rsi
callq 0x3fe60
jmp 0x455e9
movq 0x28(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x18(%rax)
movl $0x2, 0x8(%rax)
jmp 0x45645
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x4564a
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x4564a
addq $0x58, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x44b0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x444e0
movq 0x20(%rsp), %rax
movq 0x38(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movl 0x8(%rax), %eax
movl %eax, 0x28(%rsp)
testl %eax, %eax
je 0x456a5
jmp 0x4569a
movl 0x28(%rsp), %eax
subl $0x1, %eax
je 0x456aa
jmp 0x45704
jmp 0x457aa
movl $0x10, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x3c530
jmp 0x456cf
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x457aa
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl $0x10, %esi
callq 0x4290
jmp 0x457b4
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x3fe60
jmp 0x45729
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x3fe60
jmp 0x4575c
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x457aa
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x457b4
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x457b4
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x44b0
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
callq 0x3fa70
cmpl $0x0, %eax
je 0x457ec
jmp 0x459bf
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x24(%rsp)
testl %eax, %eax
je 0x4580c
jmp 0x457fe
movl 0x24(%rsp), %eax
subl $0x1, %eax
je 0x4582a
jmp 0x4590d
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x45660
movq 0x28(%rsp), %rdi
callq 0x438c0
jmp 0x459bf
movq 0x48(%rsp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x45851
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x48(%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x3d6a0
jmp 0x45908
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rsi
callq 0x3fe60
jmp 0x45872
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x18(%rax)
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq 0x28(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movq 0x20(%rax), %rsi
callq 0x3f8b0
jmp 0x458a5
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movl $0x3, 0x8(%rax)
movq $0x0, 0x20(%rax)
jmp 0x45908
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x459c4
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x459c4
jmp 0x459bf
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq 0x28(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x8(%rsp)
movl 0x8(%rax), %esi
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
callq 0x42ac0
jmp 0x45939
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x28, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rsi
callq 0x3fe60
jmp 0x45963
movq 0x28(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rax)
movl $0x3, 0x8(%rax)
jmp 0x459bf
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x459c4
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x28, %esi
callq 0x4290
jmp 0x459c4
addq $0x58, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x44b0
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x444e0
movq 0x8(%rsp), %rax
movl $0x1, 0x8(%rax)
movl $0x10, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movsd 0x28(%rsp), %xmm0
xorl %r8d, %r8d
movl %r8d, %ecx
movl %r8d, %esi
movq %rcx, %rdx
callq 0x3c6e0
jmp 0x45ec8
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x20(%rax)
addq $0x38, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x10, %esi
callq 0x4290
movq 0x20(%rsp), %rdi
callq 0x44b0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x444e0
movq 0x8(%rsp), %rax
movl $0x1, 0x8(%rax)
movl $0x10, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rsi
callq 0x3c530
jmp 0x45f5a
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x20(%rax)
addq $0x38, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x10, %esi
callq 0x4290
movq 0x20(%rsp), %rdi
callq 0x44b0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x10(%rsp)
testl %eax, %eax
je 0x46f57
jmp 0x46f49
movl 0x10(%rsp), %eax
subl $0x1, %eax
je 0x46fa1
jmp 0x46feb
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x46f89
movq 0x28(%rsp), %rdi
leaq 0x65b63(%rip), %rsi     # 0xacad8
movb $0x0, %al
callq 0x43e0
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x46f5f
movq 0x28(%rsp), %rdi
leaq 0x64e8d(%rip), %rsi     # 0xabe22
movb $0x0, %al
callq 0x43e0
jmp 0x470b1
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x46fd3
movq 0x28(%rsp), %rdi
leaq 0x65b19(%rip), %rsi     # 0xacad8
movb $0x0, %al
callq 0x43e0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x46fa9
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x3ea20
jmp 0x470b1
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x4701d
movq 0x28(%rsp), %rdi
leaq 0x65acf(%rip), %rsi     # 0xacad8
movb $0x0, %al
callq 0x43e0
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x46ff3
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rdi
movl 0x8(%rax), %edx
leaq 0x65a29(%rip), %rsi     # 0xaca5a
movb $0x0, %al
callq 0x43e0
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edx
addl $0x2, %edx
callq 0x46f20
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edx
addl $0x2, %edx
callq 0x46f20
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x4709e
movq 0x28(%rsp), %rdi
leaq 0x65a4e(%rip), %rsi     # 0xacad8
movb $0x0, %al
callq 0x43e0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x47074
movq 0x28(%rsp), %rdi
leaq 0x64398(%rip), %rsi     # 0xab442
movb $0x0, %al
callq 0x43e0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x8(%rax)
jl 0x470e4
movq 0x10(%rsp), %rax
cmpl $0x7, 0x8(%rax)
jl 0x470f1
movl $0x0, 0x24(%rsp)
jmp 0x47275
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x47111
jmp 0x47103
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x4718b
jmp 0x471ff
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x47138
leaq 0x6593c(%rip), %rdi     # 0xaca60
movb $0x0, %al
callq 0x4050
movl $0x0, 0x24(%rsp)
jmp 0x47275
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4715f
leaq 0x65919(%rip), %rdi     # 0xaca64
movb $0x0, %al
callq 0x4050
movl $0x0, 0x24(%rsp)
jmp 0x47275
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x47186
leaq 0x658f6(%rip), %rdi     # 0xaca68
movb $0x0, %al
callq 0x4050
movl $0x0, 0x24(%rsp)
jmp 0x47275
jmp 0x4726d
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x471b2
leaq 0x658ce(%rip), %rdi     # 0xaca6c
movb $0x0, %al
callq 0x4050
movl $0x0, 0x24(%rsp)
jmp 0x47275
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x471d9
leaq 0x658ab(%rip), %rdi     # 0xaca70
movb $0x0, %al
callq 0x4050
movl $0x0, 0x24(%rsp)
jmp 0x47275
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x471fd
leaq 0x65888(%rip), %rdi     # 0xaca74
movb $0x0, %al
callq 0x4050
movl $0x0, 0x24(%rsp)
jmp 0x47275
jmp 0x4726d
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x47223
leaq 0x65866(%rip), %rdi     # 0xaca78
movb $0x0, %al
callq 0x4050
movl $0x0, 0x24(%rsp)
jmp 0x47275
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x47247
leaq 0x65846(%rip), %rdi     # 0xaca7c
movb $0x0, %al
callq 0x4050
movl $0x0, 0x24(%rsp)
jmp 0x47275
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x4726b
leaq 0x65826(%rip), %rdi     # 0xaca80
movb $0x0, %al
callq 0x4050
movl $0x0, 0x24(%rsp)
jmp 0x47275
jmp 0x4726d
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq $0x0, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
movl 0x3c(%rsp), %eax
movl %eax, 0x30(%rdi)
addq $0x38, %rdi
movq %rdi, 0x18(%rsp)
callq 0x48860
movslq 0x3c(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x4030
movq %rax, 0x20(%rsp)
jmp 0x472e3
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movslq 0x3c(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x4030
movq %rax, 0x8(%rsp)
jmp 0x47317
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movslq 0x3c(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x4030
movq %rax, (%rsp)
jmp 0x4734b
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0x473a6
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x28(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x47360
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x48870
jmp 0x473b7
movq 0x10(%rsp), %rax
movl $0x1, 0x18(%rax)
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x44b0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x43b60
cmpl $0x0, %eax
je 0x477a4
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x477a2
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x477d8
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rdi, 0x28(%rax)
addq $0x38, %rdi
callq 0xb730
movq 0x10(%rsp), %rdi
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x30(%rax)
addq $0x38, %rdi
movq 0x18(%rsp), %rsi
callq 0x488f0
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, (%rax)
je 0x47818
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, %rax
je 0x47816
movq 0x38(%rsp), %rdi
callq 0x4360
jmp 0x47818
movq 0x40(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x47844
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, %rax
je 0x47842
movq 0x30(%rsp), %rdi
callq 0x4360
jmp 0x47844
movq 0x40(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x47870
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x4786e
movq 0x28(%rsp), %rdi
callq 0x4360
jmp 0x47870
jmp 0x47872
movq 0x40(%rsp), %rdi
callq 0xb4e0
movl %eax, 0x24(%rsp)
jmp 0x47882
movl 0x24(%rsp), %eax
cmpl $0x0, %eax
jle 0x478d8
movq 0x40(%rsp), %rdi
addq $0x38, %rdi
callq 0x488b0
movq %rax, 0x18(%rsp)
jmp 0x478a0
movq 0x40(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rsi
callq 0x47950
jmp 0x478bb
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x478d6
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x47872
movq 0x40(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x47904
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x47902
movq 0x8(%rsp), %rdi
callq 0x4360
jmp 0x47904
movq 0x40(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x4792e
movq 0x40(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x4792c
movq (%rsp), %rdi
callq 0x4360
jmp 0x4792e
movq 0x40(%rsp), %rdi
addq $0x38, %rdi
callq 0x48870
addq $0x58, %rsp
retq
movq %rax, %rdi
callq 0x3f630
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x38, %rdi
movq 0x28(%rsp), %rax
movl 0x30(%rax), %esi
callq 0x48920
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x38, %rdi
callq 0x488b0
movq 0x10(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movl 0x30(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x30(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x38, %rdi
movq 0x20(%rsp), %rsi
callq 0x48940
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq %rcx, (%rax)
addq $0x38, %rdi
callq 0x1fc10
movq 0x28(%rsp), %rax
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
movq 0x28(%rsp), %rax
movq $0x0, 0x28(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movq 0x18(%rsp), %rdi
movl 0x28(%rsp), %eax
movl %eax, 0x14(%rsp)
callq 0xb4e0
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0x47aa9
movq 0x18(%rsp), %rdi
movl 0x28(%rsp), %esi
callq 0x48880
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl 0x30(%rax), %esi
movq 0x10(%rax), %rcx
movl 0x18(%rax), %r8d
leaq 0x2c(%rsp), %rdx
xorl %eax, %eax
movl %eax, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x443e0
movq 0x18(%rsp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x47a23
movl 0x2c(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0xb4e0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x47b32
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x48880
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x43c80
cmpl $0x0, %eax
jne 0x47b23
movl $0x0, 0x34(%rsp)
jmp 0x47b3a
jmp 0x47b25
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x47adb
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0xb4e0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x47bc2
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x48880
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x43e10
cmpl $0x0, %eax
jne 0x47bb3
movl $0x0, 0x34(%rsp)
jmp 0x47bca
jmp 0x47bb5
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x47b6b
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0xb4e0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x47c52
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x48880
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x43fd0
cmpl $0x0, %eax
jne 0x47c43
movl $0x0, 0x34(%rsp)
jmp 0x47c5a
jmp 0x47c45
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x47bfb
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNSystemOfEquations.cpp
// Function: gaps::RNSystemOfEquations::IsAlgebraic() const
RNBoolean RNSystemOfEquations::
IsAlgebraic(void) const
{
  // Check whether all equations are algebraic
  for (int i = 0; i < NEquations(); i++) {
    RNEquation *equation = Equation(i);
    if (!equation->IsAlgebraic()) return FALSE;
  }

  // Passed all tests
  return TRUE;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0xb4e0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x47ce2
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x48880
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x488c0
cmpl $0x0, %eax
jne 0x47cd3
movl $0x0, 0x34(%rsp)
jmp 0x47cea
jmp 0x47cd5
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x47c8b
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x20(%rsp)
movq 0x10(%rsp), %rdi
movl 0x20(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0xb4e0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x47d7a
movq 0x10(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x48880
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x440e0
cmpl $0x0, %eax
je 0x47d6b
movl $0x1, 0x34(%rsp)
jmp 0x47d82
jmp 0x47d6d
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x47d1f
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3d070
cmpl $0x0, %eax
je 0x47de2
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x47de0
movq 0x10(%rsp), %rdi
callq 0x3cac0
movq 0x10(%rsp), %rdi
movl $0x10, %esi
callq 0x4290
jmp 0x47e1c
movl $0x40, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rsi
callq 0x489d0
jmp 0x47e03
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rsi
callq 0x47760
addq $0x48, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x40, %esi
callq 0x4290
movq 0x28(%rsp), %rdi
callq 0x44b0
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x43b60
cmpl $0x0, %eax
je 0x47e94
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x47e92
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x47ece
movl $0x40, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rsi
callq 0x48a20
jmp 0x47eb5
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rsi
callq 0x47760
addq $0x48, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x40, %esi
callq 0x4290
movq 0x28(%rsp), %rdi
callq 0x44b0
nopw (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3d070
cmpl $0x0, %eax
je 0x47f58
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x47f56
movq 0x8(%rsp), %rdi
callq 0x3cac0
movq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x4290
jmp 0x47fa0
movl $0x40, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rsi
callq 0x489d0
jmp 0x47f78
movq (%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movsd 0x30(%rsp), %xmm0
callq 0x488d0
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x47760
addq $0x48, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x40, %esi
callq 0x4290
movq 0x20(%rsp), %rdi
callq 0x44b0
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x43b60
cmpl $0x0, %eax
je 0x4801a
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x48018
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x48062
movl $0x40, %edi
callq 0x4280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rsi
callq 0x48a20
jmp 0x4803a
movq (%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movsd 0x30(%rsp), %xmm0
callq 0x488d0
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x47760
addq $0x48, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x40, %esi
callq 0x4290
movq 0x20(%rsp), %rdi
callq 0x44b0
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x20(%rax)
jne 0x48125
movq (%rsp), %rax
movslq 0x30(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x30(%rcx), %eax
jge 0x48123
movq (%rsp), %rax
movq 0x20(%rax), %rax
movslq 0xc(%rsp), %rcx
movsd 0x638a7(%rip), %xmm0    # 0xab9b8
movsd %xmm0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x480ef
jmp 0x48125
movq (%rsp), %rax
movsd 0x10(%rsp), %xmm0
movq 0x20(%rax), %rax
movslq 0x1c(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x28(%rax)
jne 0x481e5
movq (%rsp), %rax
movslq 0x30(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x30(%rcx), %eax
jge 0x481e3
movq (%rsp), %rax
movq 0x28(%rax), %rax
movslq 0xc(%rsp), %rcx
movsd 0x637e7(%rip), %xmm0    # 0xab9b8
movsd %xmm0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x481af
jmp 0x481e5
movq (%rsp), %rax
movsd 0x10(%rsp), %xmm0
movq 0x28(%rax), %rax
movslq 0x1c(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0xb4e0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x4828f
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x48880
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x45fa0
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x48235
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNSystemOfEquations.cpp
// Function: gaps::RNSystemOfEquations::SumOfSquaredResiduals(double const*) const
RNScalar RNSystemOfEquations::
SumOfSquaredResiduals(const RNScalar *x) const
{
  // Check stuff
  if (NVariables() == 0) return 0.0;
  if (NEquations() == 0) return 0.0;
  
  // Allocate residuals
  RNScalar *y = new RNScalar [ NEquations() ];
  
  // Compute residuals
  EvaluateResiduals(x, y);

  // Sum squared residuals
  RNScalar sum = 0;
  for (int i = 0; i < NEquations(); i++) {
    sum += y[i] * y[i];
  }

  // Free residuals
  delete [] y;

  // Return sum of squared residuals
  return sum;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x48950
cmpl $0x0, %eax
jne 0x482d0
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x483c3
movq 0x10(%rsp), %rdi
callq 0xb4e0
cmpl $0x0, %eax
jne 0x482ed
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x483c3
movq 0x10(%rsp), %rdi
callq 0xb4e0
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4030
movq 0x10(%rsp), %rdi
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x48210
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0xb4e0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x4839f
movq 0x28(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x28(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd 0x20(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x48344
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x483b7
movq (%rsp), %rdi
callq 0x4360
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
addq $0x48, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNSystemOfEquations.cpp
// Function: gaps::RNSystemOfEquations::PrintEquations(_IO_FILE*) const
void RNSystemOfEquations::
PrintEquations(FILE *fp) const
{
  // Check file
  if (!fp) fp = stdout;
  
  // Print equation
  fprintf(fp, "fp, %d %d %d\n", NEquations(), NVariables(), NPartialDerivatives());
  for (int i = 0; i < NEquations(); i++) {
    RNEquation *equation = Equation(i);
    equation->Print(fp);
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x483ff
movq 0x81bb9(%rip), %rax     # 0xc9fb0
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xb4e0
movq 0x20(%rsp), %rdi
movl %eax, 0x18(%rsp)
callq 0x48950
movq 0x20(%rsp), %rdi
movl %eax, 0x1c(%rsp)
callq 0x47a00
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %edx
movl 0x1c(%rsp), %ecx
movl %eax, %r8d
leaq 0x6463e(%rip), %rsi     # 0xaca84
movb $0x0, %al
callq 0x43e0
movl $0x0, 0x34(%rsp)
movq 0x20(%rsp), %rdi
movl 0x34(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0xb4e0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x484a2
movq 0x20(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x48880
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
xorl %edx, %edx
callq 0x46f20
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x48455
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNSystemOfEquations.cpp
// Function: gaps::RNSystemOfEquations::PrintValues(double const*, _IO_FILE*) const
void RNSystemOfEquations::
PrintValues(const RNScalar *x, FILE *fp) const
{
  // Check file
  if (!fp) fp = stdout;
  
  // Print values
  fprintf(fp, "Values: %d\n", NVariables());
  for (int i = 0; i < NVariables(); i++) {
    fprintf(fp, "  %12d %12.6f ", i, x[i]);
    if ((i > 0) && ((i % 6) == 0)) fprintf(fp, "\n");
  }
  fprintf(fp, "\n");
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x484e4
movq 0x81ad4(%rip), %rax     # 0xc9fb0
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x48950
movq 0x8(%rsp), %rdi
movl %eax, %edx
leaq 0x6458c(%rip), %rsi     # 0xaca92
movb $0x0, %al
callq 0x43e0
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x48950
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x48591
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %edx
movq 0x28(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x6454e(%rip), %rsi     # 0xaca9e
movb $0x1, %al
callq 0x43e0
cmpl $0x0, 0x1c(%rsp)
jle 0x48582
movl 0x1c(%rsp), %eax
movl $0x6, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x48582
movq 0x20(%rsp), %rdi
leaq 0x666f7(%rip), %rsi     # 0xaec72
movb $0x0, %al
callq 0x43e0
jmp 0x48584
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x48515
movq 0x20(%rsp), %rdi
leaq 0x666d5(%rip), %rsi     # 0xaec72
movb $0x0, %al
callq 0x43e0
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNSystemOfEquations.cpp
// Function: gaps::RNSystemOfEquations::PrintResiduals(double const*, _IO_FILE*) const
void RNSystemOfEquations::
PrintResiduals(const RNScalar *x, FILE *fp) const
{
  // Check file
  if (!fp) fp = stdout;
  
  // Print residuals
  double sum = 0;
  double *y = new double [ NEquations() ];
  EvaluateResiduals(x, y);
  fprintf(fp, "Residuals: %d\n", NEquations());
  for (int i = 0; i < NEquations(); i++) {
    fprintf(fp, "  %12d %12.6f\n", i, y[i]);
    sum += y[i]*y[i];
  }
  fprintf(fp, "%g\n", sum);
  delete [] y;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x485e4
movq 0x819d4(%rip), %rax     # 0xc9fb0
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x20(%rsp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
callq 0xb4e0
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4030
movq 0x20(%rsp), %rdi
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x48210
movq 0x20(%rsp), %rdi
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0xb4e0
movq 0x18(%rsp), %rdi
movl %eax, %edx
leaq 0x64458(%rip), %rsi     # 0xacaad
movb $0x0, %al
callq 0x43e0
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
callq 0xb4e0
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0x486e8
movq 0x40(%rsp), %rdi
movl 0x2c(%rsp), %edx
movq 0x30(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x6441d(%rip), %rsi     # 0xacabc
movb $0x1, %al
callq 0x43e0
movq 0x30(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x30(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd 0x38(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x48664
movq 0x40(%rsp), %rdi
movsd 0x38(%rsp), %xmm0
leaq 0x63151(%rip), %rsi     # 0xab84b
movb $0x1, %al
callq 0x43e0
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x4871b
movq 0x8(%rsp), %rdi
callq 0x4360
addq $0x58, %rsp
retq
// File: tomfunkhouser[P]gaps/pkgs/RNMath/RNSystemOfEquations.cpp
// Function: gaps::RNSystemOfEquations::PrintPartialDerivatives(double const*, _IO_FILE*) const
void RNSystemOfEquations::
PrintPartialDerivatives(const RNScalar *x, FILE *fp) const
{
  // Check file
  if (!fp) fp = stdout;
  
  // Print partial derivatives
  for (int j = 0; j < NEquations(); j++) {
    RNEquation *equation = Equation(j);
    for (int i = 0; i < NVariables(); i++) 
      fprintf(fp, "(%d %d : %g)  ", j, i, equation->PartialDerivative(x, i));
    fprintf(fp, "\n");
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x48754
movq 0x81864(%rip), %rax     # 0xc9fb0
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, 0x1c(%rsp)
callq 0xb4e0
movl %eax, %ecx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jge 0x4882b
movq 0x20(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x48880
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x18(%rsp)
callq 0x48950
movl %eax, %ecx
movl 0x18(%rsp), %eax
cmpl %ecx, %eax
jge 0x48808
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rdi
movq 0x48(%rsp), %rsi
movl 0x2c(%rsp), %edx
callq 0x46480
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %edx
movl 0x14(%rsp), %ecx
leaq 0x642d7(%rip), %rsi     # 0xacacb
movb $0x1, %al
callq 0x43e0
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x48797
movq 0x40(%rsp), %rdi
leaq 0x6645e(%rip), %rsi     # 0xaec72
movb $0x0, %al
callq 0x43e0
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x4875c
addq $0x58, %rsp
retq
// File: coolsuperman[P]ShareCataLogServer/upload.cc
// Function: main
int main(){
  Upload  UPLOAD;
  std::string rsp_body;
  if(UPLOAD.InitUpload()==false) 
    return 0;
  std::cerr << "child init success\n";
  if(UPLOAD.ProcessUpload()==false)
    rsp_body="<html><body><h1>FAILED!</h1></body></html><br/>";
  else 
    rsp_body="<html><body><h1>SUCCESS!</h1></body></html><br/>";
  std::cout<<rsp_body;
  fflush(stdout);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x98(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x37e0
leaq -0xb8(%rbp), %rdi
callq 0x22f0
movq -0xd8(%rbp), %rdi
callq 0x3840
movb %al, -0xc9(%rbp)
jmp 0x2c25
movb -0xc9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2c7a
movl $0x0, -0x4(%rbp)
movl $0x1, -0xc8(%rbp)
jmp 0x2d18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x2458
leaq -0x98(%rbp), %rdi
callq 0x4190
jmp 0x2d3c
movq 0x836f(%rip), %rdi      # 0xaff0
leaq 0x44a0(%rip), %rsi      # 0x7128
callq 0x2220
jmp 0x2c8f
leaq -0x98(%rbp), %rdi
callq 0x3cf0
movb %al, -0xd9(%rbp)
jmp 0x2ca3
movb -0xd9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2cca
leaq 0x4482(%rip), %rsi      # 0x713c
leaq -0xb8(%rbp), %rdi
callq 0x22d0
jmp 0x2cc8
jmp 0x2ce1
leaq 0x449b(%rip), %rsi      # 0x716c
leaq -0xb8(%rbp), %rdi
callq 0x22d0
jmp 0x2cdf
jmp 0x2ce1
movq 0x82e0(%rip), %rdi      # 0xafc8
leaq -0xb8(%rbp), %rsi
callq 0x21f0
jmp 0x2cf6
movq 0x82a3(%rip), %rax      # 0xafa0
movq (%rax), %rdi
callq 0x2270
jmp 0x2d07
movl $0x0, -0x4(%rbp)
movl $0x1, -0xc8(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x2458
leaq -0x98(%rbp), %rdi
callq 0x4190
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
movq -0xc0(%rbp), %rdi
callq 0x23c0
nopl (%rax,%rax)