// File: canzarlab[P]Trajan/geno/lineSearch.cpp
// Function: dcsrch(double&, double&, double&, double, double, double, double, double, TaskType&, TMPContainer&)
void dcsrch(double & f,
            double & g,
            double & stp,
            double const ftol,
            double const gtol,
            double const xtol,
            double const stpmin,
            double const stpmax,
            TaskType & task, TMPContainer& TCON) {
  double const zero = 0.0,
               p5   = 0.5,
               p66  = 0.66,
               xtrapl = 1.1,
               xtrapu = 4.0;
  //static bool brackt;
  //static int stage;
  //static double finit, fx, fy, ginit,gtest, gx, gy,
  //              stx,sty,stmin,stmax,width,width1;
  double ftest,fm,fxm,fym, gm,gxm,gym;

      if (task == TaskType::START) {

//       Check the input arguments for errors.

         if (stp < stpmin) {
          task = TaskType::ERROR;
          std::cerr << "ERROR: STP < STPMIN" << std::endl;
         }
         if (stp > stpmax) {
          //task = TaskType::ERROR;
          stp = stpmax;
          std::cerr << "ERROR: STP > STPMAX" << std::endl;
         } 
         if (g >= zero) {
          task = TaskType::ERROR;
          std::cerr << "ERROR: INITIAL G >= ZERO" << std::endl;
         }
         if (ftol < zero) {
          task = TaskType::ERROR;
          std::cerr << "ERROR: FTOL < ZERO" << std::endl;
         }
         if (gtol < zero) {
          task = TaskType::ERROR;
          std::cerr << "ERROR: GTOL < ZERO" << std::endl;
         }
         if (xtol < zero) {
          task = TaskType::ERROR;
          std::cerr << "ERROR: XTOL < ZERO" << std::endl;
         }
         if (stpmin < zero) {
          task = TaskType::ERROR;
          std::cerr << "ERROR: STPMIN < ZERO" << std::endl;
         }
         if (stpmax < stpmin) {
          task = TaskType::ERROR;
          std::cerr << "ERROR: STPMAX < STPMIN" << std::endl;
         }

//        Exit if there are errors on input.

         if (task == TaskType::ERROR)
          return;

//        Initialize local variables.

         TCON.brackt = false;
         TCON.stage = 1;
         TCON.finit = f;
         TCON.ginit = g;
         TCON.gtest = ftol*TCON.fy;
         TCON.width = stpmax - stpmin;
         TCON.width1 = TCON.width/p5;

//        The variables stx, fx, gx contain the values of the step, 
//        function, and derivative at the best step. 
//        The variables sty, fy, gy contain the value of the step, 
//        function, and derivative at sty.
//        The variables stp, f, g contain the values of the step, 
//        function, and derivative at stp.

         TCON.stx = zero;
         TCON.fx = TCON.finit;
         TCON.gx = TCON.ginit;
         TCON.sty = zero;
         TCON.fy = TCON.finit;
         TCON.gy = TCON.ginit;
         TCON.stmin = zero;
         TCON.stmax = stp + xtrapu*stp;
         task = TaskType::FG;

         return;

      }

//     If psi(stp) <= 0 and f'(stp) >= 0 for some step, then the
//     algorithm enters the second stage.

      ftest = TCON.finit + stp*TCON.gtest;
      if (TCON.stage == 1 && f <= ftest && g >= zero) 
        TCON.stage = 2;

//     Test for warnings.

      if (TCON.brackt && (stp <= TCON.stmin || stp >= TCON.stmax)) {
        task = TaskType::WARNING;
//        std::cerr << "ROUNDING ERRORS PREVENT PROGRESS\n";
      }
      if (TCON.brackt && TCON.stmax - TCON.stmin <= xtol*TCON.stmax) {
        task = TaskType::WARNING;
//        std::cerr << "XTOL TEST SATISFIED\n";
      }
      if (stp == stpmax && f <= ftest && g <= TCON.gtest) {
        task = TaskType::WARNING;
//        std::cerr << "STP = STPMAX\n";
      }
      if (stp == stpmin && (f > ftest || g >= TCON.gtest)) {
        task = TaskType::WARNING;
//        std::cerr << "STP = STPMIN\n";
      }
//     Test for convergence.

/*
      printf("f = %15.15g \n", f);
      printf("ftest = %15.15g\n", ftest);
      std::cout << "f " << f << std::endl;
      std::cout << "ftest " << ftest << std::endl;
      std::cout << "fabs(g) " << std::fabs(g) << std::endl;
      std::cout << "gtol*ginit " << gtol * (-ginit) << std::endl;
*/
//      if (f <= ftest && std::fabs(g) <= gtol * (-TCON.ginit))
      double eps = 1E-6;
      if (f <= ftest + eps*(std::fabs(ftest) + 1) && std::fabs(g) <= gtol * (-TCON.ginit)) 
        task = TaskType::CONVERGENCE;

//     Test for termination.

      if (task == TaskType::WARNING || task == TaskType::CONVERGENCE)
        return;

//     A modified function is used to predict the step during the
//     first TCON.stage if a lower function value has been obtained but 
//     the decrease is not sufficient.

      if (TCON.stage == 1 && f <= TCON.fx && f > ftest) {
//        Define the modified function and derivative values.
         fm = f - stp*TCON.gtest;
         fxm = TCON.fx - TCON.stx*TCON.gtest;
         fym = TCON.fy - TCON.sty*TCON.gtest;
         gm = g - TCON.gtest;
         gxm = TCON.gx - TCON.gtest;
         gym = TCON.gy - TCON.gtest;
//        Call dcstep to update stx, sty, and to compute the new step.
//	 std::cout << "called dcstep 1" << std::endl;
         dcstep(TCON.stx,fxm,gxm,TCON.sty,fym,gym,stp,fm,gm,TCON.brackt,TCON.stmin,TCON.stmax);
//        Reset the function and derivative values for f.
         TCON.fx = fxm + TCON.stx*TCON.gtest;
         TCON.fy = fym + TCON.sty*TCON.gtest;
         TCON.gx = gxm + TCON.gtest;
         TCON.gy = gym + TCON.gtest;
      } else {

//       Call dcstep to update stx, sty, and to compute the new step.
//	std::cout << "called dcstep 2" << std::endl;
        dcstep(TCON.stx,TCON.fx,TCON.gx,TCON.sty,TCON.fy,TCON.gy,stp,f,g,TCON.brackt,TCON.stmin,TCON.stmax);
	//	std::cout << "stx = " << stx << std::endl;
	//	std::cout << "fx  = " << fx << std::endl;
	//	std::cout << "gx  = " << gx << std::endl;
	//	std::cout << "sty = " << sty << std::endl;
	//	std::cout << "fy  = " << fy << std::endl;
	//	std::cout << "gy  = " << gy << std::endl;
	//	std::cout << "stp = " << stp << std::endl;
	//	std::cout << "f   = " << f << std::endl;
	//	std::cout << "g   = " << g << std::endl;
	//	std::cout << "stmin = " << stmin << std::endl;
	//	std::cout << "stmax = " << stmax << std::endl;
      }
//     Decide if a bisection step is needed.

      if (TCON.brackt) {
	//	std::cout << "brackt true" << std::endl;
         if (std::fabs(TCON.sty-TCON.stx) >= p66*TCON.width1) stp = TCON.stx + p5*(TCON.sty - TCON.stx);
         TCON.width1 = TCON.width;
         TCON.width = std::fabs(TCON.sty-TCON.stx);
      }

//     Set the minimum and maximum steps allowed for stp.

      if (TCON.brackt) {
         TCON.stmin = std::min(TCON.stx,TCON.sty);
         TCON.stmax = std::max(TCON.stx,TCON.sty);
      } else {
         TCON.stmin = stp + xtrapl*(stp - TCON.stx);
         TCON.stmax = stp + xtrapu*(stp - TCON.stx);
      }
// 
//     Force the step to be within the bounds stpmax and stpmin.
// 
      stp = std::max(stp,stpmin);
      stp = std::min(stp,stpmax);

//     If further progress is not possible, let stp be the best
//     point obtained during the search.

      if ((TCON.brackt && (stp <= TCON.stmin || stp >= TCON.stmax))
          || (TCON.brackt && TCON.stmax-TCON.stmin <= xtol*TCON.stmax)) {
	//	std::cout << "no further progress" << std::endl;
	stp = TCON.stx;
      }

//     Obtain another function and derivative.

      task = TaskType::FG;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd %xmm3, -0x38(%rbp)
movsd %xmm4, -0x40(%rbp)
movq %rcx, -0x48(%rbp)
movq %r8, -0x50(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd 0x755d0(%rip), %xmm0    # 0x10b398
movsd %xmm0, -0x60(%rbp)
movsd 0x94243(%rip), %xmm0    # 0x12a018
movsd %xmm0, -0x68(%rbp)
movsd 0x94246(%rip), %xmm0    # 0x12a028
movsd %xmm0, -0x70(%rbp)
movsd 0x94231(%rip), %xmm0    # 0x12a020
movsd %xmm0, -0x78(%rbp)
movq -0x48(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x960fd
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
movsd -0x38(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x95e40
movq -0x48(%rbp), %rax
movl $0x1, (%rax)
movq 0x10b1cb(%rip), %rdi    # 0x1a0ff0
leaq 0x9420c(%rip), %rsi     # 0x12a038
callq 0xa440
movq %rax, %rdi
movq 0x10b125(%rip), %rsi    # 0x1a0f60
callq 0xa4a0
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
ucomisd -0x40(%rbp), %xmm0
jbe 0x95e7e
movsd -0x40(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq 0x10b18d(%rip), %rdi    # 0x1a0ff0
leaq 0x941e2(%rip), %rsi     # 0x12a04c
callq 0xa440
movq %rax, %rdi
movq 0x10b0e7(%rip), %rsi    # 0x1a0f60
callq 0xa4a0
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x95ebb
movq -0x48(%rbp), %rax
movl $0x1, (%rax)
movq 0x10b150(%rip), %rdi    # 0x1a0ff0
leaq 0x941b9(%rip), %rsi     # 0x12a060
callq 0xa440
movq %rax, %rdi
movq 0x10b0aa(%rip), %rsi    # 0x1a0f60
callq 0xa4a0
xorps %xmm0, %xmm0
ucomisd -0x20(%rbp), %xmm0
jbe 0x95ef1
movq -0x48(%rbp), %rax
movl $0x1, (%rax)
movq 0x10b11a(%rip), %rdi    # 0x1a0ff0
leaq 0x9419c(%rip), %rsi     # 0x12a079
callq 0xa440
movq %rax, %rdi
movq 0x10b074(%rip), %rsi    # 0x1a0f60
callq 0xa4a0
xorps %xmm0, %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x95f27
movq -0x48(%rbp), %rax
movl $0x1, (%rax)
movq 0x10b0e4(%rip), %rdi    # 0x1a0ff0
leaq 0x94179(%rip), %rsi     # 0x12a08c
callq 0xa440
movq %rax, %rdi
movq 0x10b03e(%rip), %rsi    # 0x1a0f60
callq 0xa4a0
xorps %xmm0, %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0x95f5d
movq -0x48(%rbp), %rax
movl $0x1, (%rax)
movq 0x10b0ae(%rip), %rdi    # 0x1a0ff0
leaq 0x94156(%rip), %rsi     # 0x12a09f
callq 0xa440
movq %rax, %rdi
movq 0x10b008(%rip), %rsi    # 0x1a0f60
callq 0xa4a0
xorps %xmm0, %xmm0
ucomisd -0x38(%rbp), %xmm0
jbe 0x95f93
movq -0x48(%rbp), %rax
movl $0x1, (%rax)
movq 0x10b078(%rip), %rdi    # 0x1a0ff0
leaq 0x94133(%rip), %rsi     # 0x12a0b2
callq 0xa440
movq %rax, %rdi
movq 0x10afd2(%rip), %rsi    # 0x1a0f60
callq 0xa4a0
movsd -0x40(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x95fcf
movq -0x48(%rbp), %rax
movl $0x1, (%rax)
movq 0x10b03c(%rip), %rdi    # 0x1a0ff0
leaq 0x9410c(%rip), %rsi     # 0x12a0c7
callq 0xa440
movq %rax, %rdi
movq 0x10af96(%rip), %rsi    # 0x1a0f60
callq 0xa4a0
movq -0x48(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x95fdd
jmp 0x967bc
movq -0x50(%rbp), %rax
movb $0x0, (%rax)
movq -0x50(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movsd -0x20(%rbp), %xmm0
movq -0x50(%rbp), %rax
mulsd 0x18(%rax), %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, 0x28(%rax)
movsd -0x40(%rbp), %xmm0
subsd -0x38(%rbp), %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, 0x60(%rax)
movq -0x50(%rbp), %rax
movsd 0x60(%rax), %xmm0
movsd 0x7534c(%rip), %xmm1    # 0x10b398
divsd %xmm1, %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, 0x68(%rax)
movq -0x50(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rax)
movq -0x50(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x50(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, 0x30(%rax)
movq -0x50(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x48(%rax)
movq -0x50(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x50(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, 0x38(%rax)
movq -0x50(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x50(%rax)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd 0x93f43(%rip), %xmm2    # 0x12a020
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, 0x58(%rax)
movq -0x48(%rbp), %rax
movl $0x2, (%rax)
jmp 0x967bc
movq -0x50(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x50(%rbp), %rax
movsd 0x28(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x80(%rbp)
movq -0x50(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0x9615d
movq -0x8(%rbp), %rax
movsd (%rax), %xmm1
movsd -0x80(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x9615d
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x9615d
movq -0x50(%rbp), %rax
movl $0x2, 0x4(%rax)
movq -0x50(%rbp), %rax
testb $0x1, (%rax)
je 0x9619a
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
movq -0x50(%rbp), %rax
movsd 0x50(%rax), %xmm0
ucomisd %xmm1, %xmm0
jae 0x96190
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x50(%rbp), %rax
ucomisd 0x58(%rax), %xmm0
jb 0x9619a
movq -0x48(%rbp), %rax
movl $0x3, (%rax)
movq -0x50(%rbp), %rax
testb $0x1, (%rax)
je 0x961d3
movq -0x50(%rbp), %rax
movsd 0x58(%rax), %xmm1
movq -0x50(%rbp), %rax
subsd 0x50(%rax), %xmm1
movsd -0x30(%rbp), %xmm0
movq -0x50(%rbp), %rax
mulsd 0x58(%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0x961d3
movq -0x48(%rbp), %rax
movl $0x3, (%rax)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
ucomisd -0x40(%rbp), %xmm0
jne 0x96218
jp 0x96218
movq -0x8(%rbp), %rax
movsd (%rax), %xmm1
movsd -0x80(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x96218
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movq -0x50(%rbp), %rax
movsd 0x28(%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0x96218
movq -0x48(%rbp), %rax
movl $0x3, (%rax)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
ucomisd -0x38(%rbp), %xmm0
jne 0x96255
jp 0x96255
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
ucomisd -0x80(%rbp), %xmm0
ja 0x9624b
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x50(%rbp), %rax
ucomisd 0x28(%rax), %xmm0
jb 0x96255
movq -0x48(%rbp), %rax
movl $0x3, (%rax)
movsd 0x93dd3(%rip), %xmm0    # 0x12a030
movsd %xmm0, -0xb8(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm1
movsd -0x80(%rbp), %xmm2
movsd -0xb8(%rbp), %xmm0
movsd -0x80(%rbp), %xmm3
movaps 0x7514a(%rip), %xmm4    # 0x10b3d0
pand %xmm4, %xmm3
movsd 0x779d6(%rip), %xmm4    # 0x10dc68
addsd %xmm4, %xmm3
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x962f0
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movaps 0x7511d(%rip), %xmm0    # 0x10b3d0
pand %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
movq -0x50(%rbp), %rax
movsd 0x20(%rax), %xmm2
movq %xmm2, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm2
mulsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x962f0
movq -0x48(%rbp), %rax
movl $0x4, (%rax)
movq -0x48(%rbp), %rax
cmpl $0x3, (%rax)
je 0x96302
movq -0x48(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x96307
jmp 0x967bc
movq -0x50(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0x96544
movq -0x8(%rbp), %rax
movsd (%rax), %xmm1
movq -0x50(%rbp), %rax
movsd 0x10(%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0x96544
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
ucomisd -0x80(%rbp), %xmm0
jbe 0x96544
movq -0x8(%rbp), %rax
movsd (%rax), %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x50(%rbp), %rax
movsd 0x28(%rax), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x88(%rbp)
movq -0x50(%rbp), %rax
movsd 0x10(%rax), %xmm1
movq -0x50(%rbp), %rax
movsd 0x40(%rax), %xmm0
movq -0x50(%rbp), %rax
movsd 0x28(%rax), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x90(%rbp)
movq -0x50(%rbp), %rax
movsd 0x18(%rax), %xmm1
movq -0x50(%rbp), %rax
movsd 0x48(%rax), %xmm0
movq -0x50(%rbp), %rax
movsd 0x28(%rax), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x98(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x50(%rbp), %rax
subsd 0x28(%rax), %xmm0
movsd %xmm0, -0xa0(%rbp)
movq -0x50(%rbp), %rax
movsd 0x30(%rax), %xmm0
movq -0x50(%rbp), %rax
subsd 0x28(%rax), %xmm0
movsd %xmm0, -0xa8(%rbp)
movq -0x50(%rbp), %rax
movsd 0x38(%rax), %xmm0
movq -0x50(%rbp), %rax
subsd 0x28(%rax), %xmm0
movsd %xmm0, -0xb0(%rbp)
movq -0x50(%rbp), %rdi
addq $0x40, %rdi
movq -0x50(%rbp), %rcx
addq $0x48, %rcx
movq -0x18(%rbp), %r10
movsd -0x88(%rbp), %xmm0
movsd -0xa0(%rbp), %xmm1
movq -0x50(%rbp), %rax
movq -0x50(%rbp), %rdx
movsd 0x50(%rdx), %xmm2
movq -0x50(%rbp), %rdx
movsd 0x58(%rdx), %xmm3
leaq -0x90(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
leaq -0x98(%rbp), %r8
leaq -0xb0(%rbp), %r9
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x94fb0
movsd -0x90(%rbp), %xmm1
movq -0x50(%rbp), %rax
movsd 0x40(%rax), %xmm0
movq -0x50(%rbp), %rax
movsd 0x28(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x98(%rbp), %xmm1
movq -0x50(%rbp), %rax
movsd 0x48(%rax), %xmm0
movq -0x50(%rbp), %rax
movsd 0x28(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movsd -0xa8(%rbp), %xmm0
movq -0x50(%rbp), %rax
addsd 0x28(%rax), %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, 0x30(%rax)
movsd -0xb0(%rbp), %xmm0
movq -0x50(%rbp), %rax
addsd 0x28(%rax), %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, 0x38(%rax)
jmp 0x965ae
movq -0x50(%rbp), %rdi
addq $0x40, %rdi
movq -0x50(%rbp), %rsi
addq $0x10, %rsi
movq -0x50(%rbp), %rdx
addq $0x30, %rdx
movq -0x50(%rbp), %rcx
addq $0x48, %rcx
movq -0x50(%rbp), %r8
addq $0x18, %r8
movq -0x50(%rbp), %r9
addq $0x38, %r9
movq -0x18(%rbp), %r10
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movq -0x50(%rbp), %rax
movq -0x50(%rbp), %r11
movsd 0x50(%r11), %xmm2
movq -0x50(%rbp), %r11
movsd 0x58(%r11), %xmm3
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x94fb0
movq -0x50(%rbp), %rax
testb $0x1, (%rax)
je 0x9665a
movq -0x50(%rbp), %rax
movsd 0x48(%rax), %xmm0
movq -0x50(%rbp), %rax
subsd 0x40(%rax), %xmm0
movaps 0x74dfc(%rip), %xmm1    # 0x10b3d0
pand %xmm1, %xmm0
movq -0x50(%rbp), %rax
movsd 0x93a34(%rip), %xmm1    # 0x12a018
mulsd 0x68(%rax), %xmm1
ucomisd %xmm1, %xmm0
jb 0x96622
movq -0x50(%rbp), %rax
movsd 0x40(%rax), %xmm1
movq -0x50(%rbp), %rax
movsd 0x48(%rax), %xmm0
movq -0x50(%rbp), %rax
subsd 0x40(%rax), %xmm0
movsd 0x74d86(%rip), %xmm2    # 0x10b398
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x50(%rbp), %rax
movsd 0x60(%rax), %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, 0x68(%rax)
movq -0x50(%rbp), %rax
movsd 0x48(%rax), %xmm0
movq -0x50(%rbp), %rax
subsd 0x40(%rax), %xmm0
movaps 0x74d83(%rip), %xmm1    # 0x10b3d0
pand %xmm1, %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, 0x60(%rax)
movq -0x50(%rbp), %rax
testb $0x1, (%rax)
je 0x966a9
movq -0x50(%rbp), %rdi
addq $0x40, %rdi
movq -0x50(%rbp), %rsi
addq $0x48, %rsi
callq 0x148e0
movsd (%rax), %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, 0x50(%rax)
movq -0x50(%rbp), %rdi
addq $0x40, %rdi
movq -0x50(%rbp), %rsi
addq $0x48, %rsi
callq 0x14920
movsd (%rax), %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, 0x58(%rax)
jmp 0x9670d
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x50(%rbp), %rax
subsd 0x40(%rax), %xmm0
movsd 0x9395e(%rip), %xmm2    # 0x12a028
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, 0x50(%rax)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x50(%rbp), %rax
subsd 0x40(%rax), %xmm0
movsd 0x93924(%rip), %xmm2    # 0x12a020
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, 0x58(%rax)
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x14920
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x148e0
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x50(%rbp), %rax
testb $0x1, (%rax)
je 0x96772
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
movq -0x50(%rbp), %rax
movsd 0x50(%rax), %xmm0
ucomisd %xmm1, %xmm0
jae 0x967a1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x50(%rbp), %rax
ucomisd 0x58(%rax), %xmm0
jae 0x967a1
movq -0x50(%rbp), %rax
testb $0x1, (%rax)
je 0x967b2
movq -0x50(%rbp), %rax
movsd 0x58(%rax), %xmm1
movq -0x50(%rbp), %rax
subsd 0x50(%rax), %xmm1
movsd -0x30(%rbp), %xmm0
movq -0x50(%rbp), %rax
mulsd 0x58(%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0x967b2
movq -0x50(%rbp), %rax
movsd 0x40(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x48(%rbp), %rax
movl $0x2, (%rax)
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop