// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/geno/augmentedLagrangian.cpp
// Function: AugmentedLagrangian::solve()
SolverStatus AugmentedLagrangian::solve() 
{  
  static const double gamma = 2;
  //  static const double rhoMin = 1E-6;
  //  static const double rhoMax = 10;
    
  Scalar rho = 0;
//  Vector y = Vector::Zero(_genoNLP.getM());
  _genoNLP.getStartingPointDual(_y.data());
  //  std::cout << "y= " << y.transpose() << std::endl;
  AugmentedNLP augmentedNLP(_genoNLP, rho, _y);
  size_t mEqualities = augmentedNLP.mEqualities();
  size_t mInequalities = augmentedNLP.mInequalities();
  std::vector<int> cType = augmentedNLP.cType();
  

  /*
  _genoNLP.getStartingPoint(_x.data());
  Vector dummyG(_genoNLP.getN());
  _genoNLP.functionValueAndGradient(_x.data(), _f, dummyG.data());
  double dummyF;
  augmentedNLP.functionValueAndGradient(_x.data(), dummyF, dummyG.data());
  Vector constraintError = augmentedNLP.constraintError();

  for (size_t i = 0; i < mInequalities; ++i)
    if (constraintError(mEqualities + i) < 0)
      constraintError(mEqualities + i) = 0;
  std::cout << "constraint Error = " << constraintError.transpose() << std::endl;
  rho = 2 * (std::abs(_f) + 1) / constraintError.squaredNorm();
  if (rho < rhoMin)
    rho = rhoMin;
  if(rho > rhoMax)
    rho = rhoMax;
  */

  Vector constraintError;
  Vector cl = augmentedNLP.cl();
  Vector cu = augmentedNLP.cu();
  Vector dummyG(_genoNLP.getN());
  rho = 1.0;

  LBFGSB solver(augmentedNLP, _correctionPairs, _verbose);
  //NEWTONB solver(augmentedNLP, _correctionPairs);
  if (_tol != -1) solver.setParameter("pgtol", _tol);
  if (_tolFun != -1) solver.setParameter("factr", _tolFun);
  double oldFactor = INF;
  double tau = 0.5;
  double lambdaMin = -1E20;
  double lambdaMax = 1E20;
  double muMax = 1E20;
  double muMin = -1E20;
  SolverStatus status = SOLVED;
  
  for (size_t iter = 0; iter < _maxIter; ++iter) 
  {
    if (_verbose)
      std::cout << "rho = " << rho << std::endl;

    augmentedNLP.setParams(rho, _y);
    solver.restart();
    status = solver.solve();
    if ((status != SOLVED) && (status != SUBOPTIMAL))
      break;
    constraintError = augmentedNLP.constraintError();
    Vector trueConstraintError(constraintError);
    for (size_t i = 0; i < mInequalities; ++i) {
      if (cType[i+mEqualities] == 2)
        if (trueConstraintError(mEqualities + i) > 0)
          trueConstraintError(mEqualities + i) = 0;

      if (cType[i+mEqualities] == 4)
	if (trueConstraintError(mEqualities + i) < 0)
	  trueConstraintError(mEqualities + i) = 0;
    }
    double constraintErrorNorm = 
      trueConstraintError.lpNorm<Eigen::Infinity>();

    _x = Vector::Map(solver.x(), _x.size());

    //    std::cout << "cl " << cl.transpose() << std::endl;
    //    std::cout << "cu " << cu.transpose() << std::endl;
    //    std::cout << "constraint Values " << augmentedNLP.constraintValues().transpose() << std::endl;
    //    std::cout << "y " << y.transpose() << std::endl;
    if (constraintErrorNorm < _constraintsTol)
      break;

    //    y = y + rho * constraintError;

    _y.head(mEqualities) +=  rho * constraintError.head(mEqualities);

    //safeguard Lagrange multiplier for equality constraints
    for (size_t i = 0; i < mEqualities; ++i) {
      if (_y(i) < lambdaMin)
	_y(i) = lambdaMin;
      if (_y(i) > lambdaMax)
	_y(i) = lambdaMax;
    }


    Vector constraintValues = augmentedNLP.constraintValues();

    // compute new Lagrange multiplier and safeguard it
    for (size_t i = 0; i < mInequalities; ++i) {
      if (cType[i+mEqualities] == 2) {
	_y(i+mEqualities) += rho * constraintError(i+mEqualities);
        if (_y(i+mEqualities) > 0)
          _y(i+mEqualities) = 0;
      }

      if (cType[i+mEqualities] == 3) {
	double yLB = std::min(0.0, _y(i+mEqualities));
	double yUB = std::max(0.0, _y(i+mEqualities));
	yLB += rho * (constraintValues(i+mEqualities) - cl(i));
	yUB += rho * (constraintValues(i+mEqualities) - cu(i));
	yLB = std::min(0.0, yLB);
	yUB = std::max(0.0, yUB);

	_y(i+mEqualities) = yLB + yUB;

      }

      if (cType[i+mEqualities] == 4) {
        _y(i+mEqualities) += rho * constraintError(i+mEqualities);
 	if (_y(i+mEqualities) < 0)
	  _y(i+mEqualities) = 0;
      }

      if (_y(i+mEqualities) < muMin)
        _y(i+mEqualities) = muMin;
      if (_y(i+mEqualities) > muMax)
	_y(i+mEqualities) = muMax;
    }
    
    //    double factor = constraintErrorNorm;

    double factor = 0;
    // need to have the if there since if there are no equalities Eigen will make a mistake
    if (mEqualities)  factor = constraintError.head(mEqualities).lpNorm<Eigen::Infinity>();

    //    std::cout << "factor = " << factor << std::endl;
    for (size_t i = 0; i < mInequalities; ++i) {
      factor = std::max(std::abs(std::max(constraintError(mEqualities + i), -_y(mEqualities + i) / rho)), factor);
    }
    if (factor > tau * oldFactor) {
      rho *= gamma;
    }
    oldFactor = factor;
  }
  _genoNLP.functionValueAndGradient(_x.data(), _f, dummyG.data());
  return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x488, %rsp            # imm = 0x488
movq %rdi, %r14
leaq 0x38(%rdi), %r15
movq (%rdi), %rdi
movq 0x38(%r14), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq (%r14), %rsi
leaq 0x188(%rsp), %rbx
xorpd %xmm0, %xmm0
movq %rbx, %rdi
movq %r15, 0x68(%rsp)
movq %r15, %rdx
callq 0xef00
movq 0x20(%rbx), %r13
movq 0x28(%rbx), %r15
leaq 0x200(%rsp), %rsi
leaq 0xb0(%rsp), %rdi
callq 0xf262
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
leaq 0x1e0(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
callq 0x1022e
leaq 0x1f0(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0x1022e
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %rbx
testq %rax, %rax
js 0xed34
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
je 0xe25b
cmpq %rax, %rbx
ja 0xe22d
leaq (,%rbx,8), %rdi
callq 0x9440
cmpq $0x1, %rbx
setne %dl
testb $0xf, %al
setne %cl
testb %cl, %dl
jne 0xed15
movq %rax, 0x50(%rsp)
testq %rax, %rax
jne 0xe264
movl $0x8, %edi
callq 0x9180
movq 0x79d72(%rip), %rcx     # 0x87fb0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x79d7c(%rip), %rsi     # 0x87fc8
movq 0x79d3d(%rip), %rdx     # 0x87f90
movq %rax, %rdi
callq 0x9630
movq $0x0, 0x50(%rsp)
movq 0x18(%r14), %rdx
movzbl 0x60(%r14), %ecx
leaq 0x228(%rsp), %rdi
leaq 0x188(%rsp), %rsi
callq 0x18d64
movsd 0x50(%r14), %xmm0
ucomisd 0x4e110(%rip), %xmm0    # 0x5c3a0
jne 0xe294
jnp 0xe2f4
leaq 0x110(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x4e168(%rip), %rsi     # 0x5c410
leaq 0x4e166(%rip), %rdx     # 0x5c415
leaq 0x100(%rsp), %rdi
callq 0xdb24
movsd 0x50(%r14), %xmm0
leaq 0x228(%rsp), %rdi
leaq 0x100(%rsp), %rsi
callq 0x196f2
movq 0x100(%rsp), %rdi
cmpq %r12, %rdi
je 0xe2f4
movq 0x110(%rsp), %rsi
incq %rsi
callq 0x9340
movsd 0x58(%r14), %xmm0
ucomisd 0x4e09e(%rip), %xmm0    # 0x5c3a0
jne 0xe306
jnp 0xe366
leaq 0xf0(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x4e0fc(%rip), %rsi     # 0x5c416
leaq 0x4e0fa(%rip), %rdx     # 0x5c41b
leaq 0xe0(%rsp), %rdi
callq 0xdb24
movsd 0x58(%r14), %xmm0
leaq 0x228(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x196f2
movq 0xe0(%rsp), %rdi
cmpq %r12, %rdi
je 0xe366
movq 0xf0(%rsp), %rsi
incq %rsi
callq 0x9340
cmpq $0x0, 0x48(%r14)
je 0xeb5b
leaq (,%r13,8), %rax
movq %rax, 0xd0(%rsp)
leaq (,%r13,4), %rax
movq %rax, 0xc8(%rsp)
movsd 0x4e00f(%rip), %xmm0    # 0x5c3a8
movaps %xmm0, 0x20(%rsp)
movsd 0x4e00a(%rip), %xmm0    # 0x5c3b0
movapd %xmm0, 0x80(%rsp)
xorl %ebp, %ebp
cmpb $0x1, 0x60(%r14)
jne 0xe40c
movl $0x6, %edx
movq 0x79bfc(%rip), %rdi     # 0x87fc0
leaq 0x4e051(%rip), %rsi     # 0x5c41c
callq 0x93a0
movq 0x79be9(%rip), %rdi     # 0x87fc0
movapd 0x20(%rsp), %xmm0
callq 0x9560
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x9320
movsbl %al, %esi
movq %r12, %rdi
callq 0x9040
movq %rax, %rdi
callq 0x9220
leaq 0x188(%rsp), %rdi
movapd 0x20(%rsp), %xmm0
movq 0x68(%rsp), %rsi
callq 0xf2e2
leaq 0x228(%rsp), %rdi
callq 0x181bc
leaq 0x228(%rsp), %rdi
callq 0x1865c
cmpl $0x1, %eax
movl %eax, 0x3c(%rsp)
ja 0xeb63
movq 0x218(%rsp), %r12
movq 0x220(%rsp), %rbx
cmpq %rbx, 0x8(%rsp)
je 0xe4c2
testq %rbx, %rbx
js 0xecf6
movq (%rsp), %rdi
callq 0x93c0
testq %rbx, %rbx
je 0xe4b7
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rax, %rbx
ja 0xec8a
leaq (,%rbx,8), %rdi
callq 0x9440
cmpq $0x1, %rbx
setne %cl
testb $0xf, %al
setne %dl
testb %dl, %cl
jne 0xed15
testq %rax, %rax
jne 0xe4b9
jmp 0xec8a
xorl %eax, %eax
movq %rax, (%rsp)
movq %rbx, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq %rbx, %rax
jne 0xec54
movq (%rsp), %rcx
movq %rax, %rdx
shrq $0x3f, %rdx
addq %rax, %rdx
andq $-0x2, %rdx
cmpq $0x2, %rax
jl 0xe4fe
xorl %esi, %esi
movapd (%r12,%rsi,8), %xmm0
movapd %xmm0, (%rcx,%rsi,8)
addq $0x2, %rsi
cmpq %rdx, %rsi
jl 0xe4ea
cmpq %rax, %rdx
jge 0xe516
movsd (%r12,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0xe503
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x1022e
testq %r15, %r15
je 0xe5a7
movq 0xb0(%rsp), %rax
movq 0x40(%rsp), %rcx
movq %r13, %rdx
movq %r15, %rsi
movl (%rax,%rdx,4), %edi
cmpl $0x4, %edi
je 0xe578
cmpl $0x2, %edi
jne 0xe59f
testq %rdx, %rdx
js 0xebf7
cmpq %rdx, 0x48(%rsp)
jle 0xebf7
movsd (%rcx,%rdx,8), %xmm0
ucomisd 0x4de67(%rip), %xmm0    # 0x5c3d0
jbe 0xe573
movq $0x0, (%rcx,%rdx,8)
cmpl $0x4, %edi
jne 0xe59f
testq %rdx, %rdx
js 0xebf7
cmpq %rdx, 0x48(%rsp)
jle 0xebf7
xorpd %xmm0, %xmm0
ucomisd (%rcx,%rdx,8), %xmm0
jbe 0xe59f
movq $0x0, (%rcx,%rdx,8)
incq %rdx
decq %rsi
jne 0xe53b
cmpq $0x0, 0x48(%rsp)
je 0xe5f9
leaq 0x40(%rsp), %rax
movq %rax, 0x120(%rsp)
jle 0xecb8
movq 0x40(%rsp), %rax
movq %rax, 0x150(%rsp)
leaq 0x120(%rsp), %rax
movq %rax, 0x160(%rsp)
leaq 0x148(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x102e6
movsd %xmm0, 0x58(%rsp)
jmp 0xe603
xorpd %xmm0, %xmm0
movsd %xmm0, 0x58(%rsp)
leaq 0x228(%rsp), %rdi
callq 0x196e6
movq 0x30(%r14), %rdx
testq %rdx, %rdx
js 0xec35
movq 0x30(%r14), %rcx
cmpq %rdx, %rcx
jne 0xec6b
movq 0x28(%r14), %rdx
movq %rcx, %rsi
shrq $0x3f, %rsi
addq %rcx, %rsi
andq $-0x2, %rsi
cmpq $0x2, %rcx
jl 0xe657
xorl %edi, %edi
movupd (%rax,%rdi,8), %xmm0
movapd %xmm0, (%rdx,%rdi,8)
addq $0x2, %rdi
cmpq %rsi, %rdi
jl 0xe644
cmpq %rcx, %rsi
jge 0xe66e
movsd (%rax,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0xe65c
movsd 0x8(%r14), %xmm0
ucomisd 0x58(%rsp), %xmm0
movsd %xmm0, 0xd8(%rsp)
ja 0xeb31
testq %r13, %r13
setns %cl
movq (%rsp), %rax
testq %rax, %rax
sete %dl
orb %cl, %dl
je 0xecd7
testq %r13, %r13
js 0xec16
cmpq %r13, 0x8(%rsp)
jl 0xec16
cmpq %r13, 0x40(%r14)
jl 0xec16
movq 0x38(%r14), %rcx
movq %r13, %rdx
testb $0x7, %cl
jne 0xe6da
movl %ecx, %edx
shrl $0x3, %edx
andl $0x1, %edx
cmpq %r13, %rdx
cmovgeq %r13, %rdx
testq %rdx, %rdx
movapd 0x20(%rsp), %xmm1
jle 0xe702
xorl %esi, %esi
movsd (%rax,%rsi,8), %xmm0
mulsd %xmm1, %xmm0
addsd (%rcx,%rsi,8), %xmm0
movsd %xmm0, (%rcx,%rsi,8)
incq %rsi
cmpq %rsi, %rdx
jne 0xe6e7
movq %r13, %rdi
subq %rdx, %rdi
movq %rdi, %rsi
shrq $0x3f, %rsi
addq %rdi, %rsi
andq $-0x2, %rsi
addq %rdx, %rsi
cmpq $0x2, %rdi
jl 0xe745
movapd 0x20(%rsp), %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movupd (%rax,%rdx,8), %xmm1
mulpd %xmm0, %xmm1
addpd (%rcx,%rdx,8), %xmm1
movapd %xmm1, (%rcx,%rdx,8)
addq $0x2, %rdx
cmpq %rsi, %rdx
jl 0xe729
cmpq %r13, %rsi
movapd 0x20(%rsp), %xmm1
jge 0xe76b
movsd (%rax,%rsi,8), %xmm0
mulsd %xmm1, %xmm0
addsd (%rcx,%rsi,8), %xmm0
movsd %xmm0, (%rcx,%rsi,8)
incq %rsi
cmpq %rsi, %r13
jne 0xe750
testq %r13, %r13
je 0xe7c6
movq 0x68(%rsp), %rax
movq (%rax), %rax
xorl %ecx, %ecx
cmpq %rcx, 0x40(%r14)
jle 0xebf7
movsd 0x4dc2c(%rip), %xmm0    # 0x5c3b8
ucomisd (%rax,%rcx,8), %xmm0
jbe 0xe7a1
movabsq $-0x3bea50e2874a73c0, %rdx # imm = 0xC415AF1D78B58C40
movq %rdx, (%rax,%rcx,8)
movsd (%rax,%rcx,8), %xmm0
ucomisd 0x4dc12(%rip), %xmm0    # 0x5c3c0
jbe 0xe7be
movabsq $0x4415af1d78b58c40, %rdx # imm = 0x4415AF1D78B58C40
movq %rdx, (%rax,%rcx,8)
incq %rcx
cmpq %rcx, %r13
jne 0xe77a
leaq 0x70(%rsp), %rdi
leaq 0x1b8(%rsp), %rsi
callq 0x1022e
testq %r15, %r15
je 0xe9eb
movq 0x40(%r14), %rax
movq 0x78(%rsp), %rcx
movq %rcx, 0x60(%rsp)
movq 0x90(%rsp), %rdx
movq 0x98(%rsp), %rsi
movq 0xa0(%rsp), %rdi
movq 0x38(%r14), %r8
movq 0xd0(%rsp), %r11
addq %r11, %r8
movq (%rsp), %r9
addq %r11, %r9
movq 0x70(%rsp), %r10
addq %r11, %r10
movq 0xb0(%rsp), %r11
addq 0xc8(%rsp), %r11
xorl %r12d, %r12d
movq %r15, %rcx
movq %rbp, %r15
leaq (%r12,%r13), %rbp
movl (%r11,%r12,4), %ebx
cmpl $0x4, %ebx
je 0xe943
cmpl $0x3, %ebx
je 0xe8ac
cmpl $0x2, %ebx
jne 0xe98a
testq %r13, %r13
js 0xebf7
cmpq %rbp, 0x8(%rsp)
jle 0xebf7
cmpq %rbp, %rax
jle 0xebf7
movsd (%r9,%r12,8), %xmm0
mulsd 0x20(%rsp), %xmm0
addsd (%r8,%r12,8), %xmm0
xorpd %xmm1, %xmm1
minsd %xmm0, %xmm1
movsd %xmm1, (%r8,%r12,8)
cmpl $0x4, %ebx
je 0xe943
cmpl $0x3, %ebx
jne 0xe98a
testq %r13, %r13
js 0xebf7
cmpq %rbp, 0x40(%r14)
jle 0xebf7
cmpq %rbp, 0x60(%rsp)
jle 0xebf7
testq %r12, %r12
js 0xebf7
cmpq %r12, 0xa8(%rsp)
jle 0xebf7
cmpq %r12, %rsi
jle 0xebf7
movsd (%r8,%r12,8), %xmm0
movapd %xmm0, %xmm1
xorpd %xmm5, %xmm5
minsd %xmm5, %xmm1
movsd (%r10,%r12,8), %xmm2
movapd %xmm2, %xmm3
subsd (%rdi,%r12,8), %xmm3
maxsd %xmm5, %xmm0
movapd 0x20(%rsp), %xmm4
mulsd %xmm4, %xmm3
subsd (%rdx,%r12,8), %xmm2
addsd %xmm1, %xmm3
mulsd %xmm4, %xmm2
addsd %xmm0, %xmm2
minsd %xmm5, %xmm3
maxsd %xmm5, %xmm2
addsd %xmm3, %xmm2
movsd %xmm2, (%r8,%r12,8)
cmpl $0x4, %ebx
jne 0xe98a
testq %r13, %r13
js 0xebf7
cmpq %rbp, 0x8(%rsp)
jle 0xebf7
cmpq %rbp, %rax
jle 0xebf7
movsd (%r9,%r12,8), %xmm0
mulsd 0x20(%rsp), %xmm0
addsd (%r8,%r12,8), %xmm0
movsd %xmm0, (%r8,%r12,8)
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0xe98a
movq $0x0, (%r8,%r12,8)
testq %r13, %r13
js 0xebf7
cmpq %rbp, 0x40(%r14)
jle 0xebf7
movsd 0x4da13(%rip), %xmm0    # 0x5c3b8
ucomisd (%r8,%r12,8), %xmm0
jbe 0xe9bb
movabsq $-0x3bea50e2874a73c0, %rbx # imm = 0xC415AF1D78B58C40
movq %rbx, (%r8,%r12,8)
movsd (%r8,%r12,8), %xmm0
ucomisd 0x4d9f7(%rip), %xmm0    # 0x5c3c0
movq %r15, %rbp
jbe 0xe9dc
movabsq $0x4415af1d78b58c40, %rbx # imm = 0x4415AF1D78B58C40
movq %rbx, (%r8,%r12,8)
incq %r12
movq %rcx, %r15
cmpq %r12, %rcx
jne 0xe838
testq %r13, %r13
je 0xea65
movq 0x8(%rsp), %rax
cmpq %r13, %rax
jl 0xec16
movq (%rsp), %rcx
movq %rcx, 0x148(%rsp)
movq %r13, 0x150(%rsp)
movq %rsp, %rdx
movq %rdx, 0x160(%rsp)
movq $0x0, 0x168(%rsp)
movq %rax, 0x178(%rsp)
movq %rcx, 0x128(%rsp)
movq %rax, 0x138(%rsp)
leaq 0x148(%rsp), %rax
movq %rax, 0x140(%rsp)
leaq 0x120(%rsp), %rdi
leaq 0x1f(%rsp), %rsi
callq 0x10406
jmp 0xea69
xorpd %xmm0, %xmm0
testq %r15, %r15
je 0xeacc
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x38(%r14), %rdx
movq 0x40(%r14), %rsi
movq %r13, %rdi
movq %r15, %r8
testq %r13, %r13
js 0xebf7
cmpq %rdi, %rcx
jle 0xebf7
cmpq %rdi, %rsi
jle 0xebf7
movsd (%rdx,%rdi,8), %xmm1
xorpd 0x4d933(%rip), %xmm1    # 0x5c3e0
divsd 0x20(%rsp), %xmm1
maxsd (%rax,%rdi,8), %xmm1
andpd 0x4d930(%rip), %xmm1    # 0x5c3f0
maxsd %xmm1, %xmm0
incq %rdi
decq %r8
jne 0xea85
movsd %xmm0, 0x60(%rsp)
movapd 0x80(%rsp), %xmm3
mulsd 0x4d8e5(%rip), %xmm3    # 0x5c3c8
movapd 0x20(%rsp), %xmm1
movapd %xmm1, %xmm2
addsd %xmm1, %xmm2
cmpltsd %xmm0, %xmm3
andpd %xmm3, %xmm2
andnpd %xmm1, %xmm3
orpd %xmm2, %xmm3
movapd %xmm3, 0x80(%rsp)
movq 0x70(%rsp), %rdi
callq 0x93c0
movaps 0x80(%rsp), %xmm0
movaps %xmm0, 0x20(%rsp)
movsd 0x60(%rsp), %xmm0
movapd %xmm0, 0x80(%rsp)
movq 0x40(%rsp), %rdi
callq 0x93c0
movsd 0xd8(%rsp), %xmm0
ucomisd 0x58(%rsp), %xmm0
ja 0xeb63
incq %rbp
cmpq 0x48(%r14), %rbp
jb 0xe3b1
jmp 0xeb63
movl $0x0, 0x3c(%rsp)
movq (%r14), %rdi
movq 0x28(%r14), %rsi
addq $0x20, %r14
movq (%rdi), %rax
movq %r14, %rdx
movq 0x50(%rsp), %rbx
movq %rbx, %rcx
callq *0x48(%rax)
leaq 0x228(%rsp), %rdi
callq 0xf3b6
movq %rbx, %rdi
callq 0x93c0
movq 0x90(%rsp), %rdi
callq 0x93c0
movq 0xa0(%rsp), %rdi
callq 0x93c0
movq (%rsp), %rdi
callq 0x93c0
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0xebd4
movq 0xc0(%rsp), %rsi
subq %rdi, %rsi
callq 0x9340
leaq 0x188(%rsp), %rdi
callq 0xf4e8
movl 0x3c(%rsp), %eax
addq $0x488, %rsp            # imm = 0x488
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4e627(%rip), %rdi     # 0x5d225
leaq 0x4e63d(%rip), %rsi     # 0x5d242
leaq 0x4e659(%rip), %rcx     # 0x5d265
movl $0x1a9, %edx            # imm = 0x1A9
callq 0x9200
leaq 0x4dbae(%rip), %rdi     # 0x5c7cb
leaq 0x4dad2(%rip), %rsi     # 0x5c6f6
leaq 0x4dae4(%rip), %rcx     # 0x5c70f
movl $0x93, %edx
callq 0x9200
leaq 0x4df4b(%rip), %rdi     # 0x5cb87
leaq 0x4dcc1(%rip), %rsi     # 0x5c904
leaq 0x4eaf4(%rip), %rcx     # 0x5d73e
movl $0xa3, %edx
callq 0x9200
leaq 0x4e405(%rip), %rdi     # 0x5d060
leaq 0x4d8b7(%rip), %rsi     # 0x5c519
leaq 0x4e683(%rip), %rcx     # 0x5d2ec
jmp 0xec80
leaq 0x4e3ee(%rip), %rdi     # 0x5d060
leaq 0x4d8a0(%rip), %rsi     # 0x5c519
leaq 0x4eb60(%rip), %rcx     # 0x5d7e0
movl $0x2d1, %edx            # imm = 0x2D1
callq 0x9200
movl $0x8, %edi
callq 0x9180
movq 0x79315(%rip), %rcx     # 0x87fb0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x7931f(%rip), %rsi     # 0x87fc8
movq 0x792e0(%rip), %rdx     # 0x87f90
movq %rax, %rdi
callq 0x9630
leaq 0x4dd12(%rip), %rdi     # 0x5c9d1
leaq 0x4dd4f(%rip), %rsi     # 0x5ca15
leaq 0x4e91a(%rip), %rcx     # 0x5d5e7
movl $0x19d, %edx            # imm = 0x19D
callq 0x9200
leaq 0x4db7c(%rip), %rdi     # 0x5c85a
leaq 0x4dc1f(%rip), %rsi     # 0x5c904
leaq 0x4dc33(%rip), %rcx     # 0x5c91f
movl $0xaf, %edx
callq 0x9200
leaq 0x4e15b(%rip), %rdi     # 0x5ce58
leaq 0x4dfb3(%rip), %rsi     # 0x5ccb7
leaq 0x4e2dc(%rip), %rcx     # 0x5cfe7
movl $0x11d, %edx            # imm = 0x11D
callq 0x9200
leaq 0x4e030(%rip), %rdi     # 0x5cd4c
leaq 0x4e0e3(%rip), %rsi     # 0x5ce06
leaq 0x4e0fb(%rip), %rcx     # 0x5ce25
movl $0xa1, %edx
callq 0x9200
leaq 0x4def2(%rip), %rdi     # 0x5cc2d
leaq 0x4df75(%rip), %rsi     # 0x5ccb7
leaq 0x4df91(%rip), %rcx     # 0x5ccda
movl $0x138, %edx            # imm = 0x138
callq 0x9200
movq %rax, %rbx
movq 0xe0(%rsp), %rdi
cmpq %r12, %rdi
je 0xeddc
movq 0xf0(%rsp), %rsi
jmp 0xed87
jmp 0xedd9
movq %rax, %rbx
movq 0x100(%rsp), %rdi
cmpq %r12, %rdi
je 0xeddc
movq 0x110(%rsp), %rsi
incq %rsi
callq 0x9340
jmp 0xeddc
jmp 0xedd9
jmp 0xedd9
movq %rax, %rbx
jmp 0xede9
jmp 0xedae
movq %rax, %rbx
jmp 0xee00
movq %rax, %rbx
jmp 0xee0d
movq %rax, %rbx
jmp 0xee33
movq %rax, %rbx
jmp 0xedf3
movq %rax, %rbx
movq 0x70(%rsp), %rdi
callq 0x93c0
jmp 0xedcb
jmp 0xedc8
jmp 0xedc8
jmp 0xedd9
movq %rax, %rbx
movq 0x40(%rsp), %rdi
callq 0x93c0
jmp 0xeddc
jmp 0xedd9
movq %rax, %rbx
leaq 0x228(%rsp), %rdi
callq 0xf3b6
movq 0x50(%rsp), %rdi
callq 0x93c0
movq 0x90(%rsp), %rdi
callq 0x93c0
movq 0xa0(%rsp), %rdi
callq 0x93c0
movq (%rsp), %rdi
callq 0x93c0
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0xee33
movq 0xc0(%rsp), %rsi
subq %rdi, %rsi
callq 0x9340
leaq 0x188(%rsp), %rdi
callq 0xf4e8
movq %rbx, %rdi
callq 0x9670