// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: background_w_fld
int background_w_fld(
                     struct background * pba,
                     double a,
                     double * w_fld,
                     double * dw_over_da_fld,
                     double * integral_fld
                     ) {


  double Omega_ede = 0.;
  double dOmega_ede_over_da = 0.;
  double d2Omega_ede_over_da2 = 0.;
  double a_eq, Omega_r, Omega_m;
  double w,w_f,w_i,dw,intw;
  double powac,powa;
  /** - first, define the function w(a) */
  switch (pba->fluid_equation_of_state) {
  case CLP:
    *w_fld = pba->w0_fld + pba->wa_fld * (1. - a);
    break;
  case EDE:
    if (pba->ede_parametrization == pheno_axion || pba->ede_parametrization == pheno_ADE){
      // w_ede(a) defined from a mash-up of 1811.04083 and 1905.12618
      w_f = pba->w_fld_f; //e.o.s. once the field starts oscillating
      w_i = pba->w_fld_i; //e.o.s. once the field starts oscillating
      // *w_fld = (1+w_f)/(1+pow(pba->a_c/a,3*(1+w_f)/pba->nu_fld))-1;
      *w_fld = (w_f-w_i)/(1+pow(pba->a_c/a,3*(w_f-w_i)/pba->nu_fld))+w_i;
    }
    else if(pba->ede_parametrization == EDE_is_DR){
      *w_fld = 1./3;
    }
    else {
      // Omega_ede(a) taken from eq. (10) in 1706.00730
      Omega_ede = (pba->Omega0_fld - pba->Omega_EDE*(1.-pow(a,-3.*pba->w0_fld)))
        /(pba->Omega0_fld+(1.-pba->Omega0_fld)*pow(a,3.*pba->w0_fld))
        + pba->Omega_EDE*(1.-pow(a,-3.*pba->w0_fld));

      // d Omega_ede / d a taken analytically from the above
      dOmega_ede_over_da = - pba->Omega_EDE* 3.*pba->w0_fld*pow(a,-3.*pba->w0_fld-1.)/(pba->Omega0_fld+(1.-pba->Omega0_fld)*pow(a,3.*pba->w0_fld))
        - (pba->Omega0_fld - pba->Omega_EDE*(1.-pow(a,-3.*pba->w0_fld)))*(1.-pba->Omega0_fld)*3.*pba->w0_fld*pow(a,3.*pba->w0_fld-1.)/pow(pba->Omega0_fld+(1.-pba->Omega0_fld)*pow(a,3.*pba->w0_fld),2)
        + pba->Omega_EDE*3.*pba->w0_fld*pow(a,-3.*pba->w0_fld-1.);

      // find a_equality (needed because EDE tracks first radiation, then matter)
      Omega_r = pba->Omega0_g * (1. + 3.046 * 7./8.*pow(4./11.,4./3.)); // assumes LambdaCDM + eventually massive neutrinos so light that they are relativistic at equality; needs to be generalised later on.
      Omega_m = pba->Omega0_b;
      if (pba->has_cdm == _TRUE_) Omega_m += pba->Omega0_cdm;
      if (pba->has_idm == _TRUE_) Omega_m += pba->Omega0_idm;
      if (pba->has_dcdm == _TRUE_)
        class_stop(pba->error_message,"Early Dark Energy not compatible with decaying Dark Matter because we omitted to code the calculation of a_eq in that case, but it would not be difficult to add it if necessary, should be a matter of 5 minutes");
      a_eq = Omega_r/Omega_m; // assumes a flat universe with a=1 today

      // w_ede(a) taken from eq. (11) in 1706.00730
      *w_fld = - dOmega_ede_over_da*a/Omega_ede/3./(1.-Omega_ede)+a_eq/3./(a+a_eq);
    }
    break;
  }


  /** - then, give the corresponding analytic derivative dw/da (used
      by perturbation equations; we could compute it numerically,
      but with a loss of precision; as long as there is a simple
      analytic expression of the derivative of the previous
      function, let's use it! */
  switch (pba->fluid_equation_of_state) {
  case CLP:
    *dw_over_da_fld = - pba->wa_fld;
    break;
  case EDE:
  if (pba->ede_parametrization == pheno_axion || pba->ede_parametrization == pheno_ADE){
      *dw_over_da_fld =    (3*pba->a_c*pow(pba->a_c/a,-1+3*(1+w_f)/pba->nu_fld)*(1+w_f)*(w_f-w_i))
      /(a*a*pba->nu_fld*pow(1 + (pba->a_c/a,3*(1+w_f)/pba->nu_fld),2));

    }
    else if(pba->ede_parametrization == EDE_is_DR){
      *dw_over_da_fld = 0;
    }
    else {
      d2Omega_ede_over_da2 = 0.;
      *dw_over_da_fld = - d2Omega_ede_over_da2*a/3./(1.-Omega_ede)/Omega_ede
        - dOmega_ede_over_da/3./(1.-Omega_ede)/Omega_ede
        + dOmega_ede_over_da*dOmega_ede_over_da*a/3./(1.-Omega_ede)/(1.-Omega_ede)/Omega_ede
        + a_eq/3./(a+a_eq)/(a+a_eq);
    }
    break;
  }

  /** - finally, give the analytic solution of the following integral:
        \f$ \int_{a}^{a0} da 3(1+w_{fld})/a \f$. This is used in only
        one place, in the initial conditions for the background, and
        with a=a_ini. If your w(a) does not lead to a simple analytic
        solution of this integral, no worry: instead of writing
        something here, the best would then be to leave it equal to
        zero, and then in background_initial_conditions() you should
        implement a numerical calculation of this integral only for
        a=a_ini, using for instance Romberg integration. It should be
        fast, simple, and accurate enough. */

  switch (pba->fluid_equation_of_state) {
  case CLP:
    *integral_fld = 3.*((1.+pba->w0_fld+pba->wa_fld)*log(1./a) + pba->wa_fld*(a-1.));
    break;
  case EDE:
  if (pba->ede_parametrization == pheno_axion || pba->ede_parametrization == pheno_ADE){
    powac=pow(pba->a_c,3*(1+w_f)/pba->nu_fld);
    powa=pow(a,3*(1+w_f));
      *integral_fld = //-3*(1+w)*log(a/pba->a_today) - pba->nu_fld*log(1+ pow(pba->a_c[n]/a,3*(1+w)/pba->nu_fld));
        // 3*(w_f-w_i)*( log(1/a)
        // + pba->nu_fld/3/(w_f-w_i)*log( (1 + pow((pba->a_c),3*(w_f-w_i)/pba->nu_fld) ) / (1 + pow((pba->a_c/a),3*(w_f-w_i)/pba->nu_fld) ) ) )+3*a*(1+w_i);
        -3*(1 + w_i)*log(a) + pba->nu_fld*(w_f-w_i)*(log(1+1/powac)-log(1/powac*(powa+powac)))/(1+w_f);

      // *integral_fld = //-3*(1+w)*log(a/pba->a_today) - pba->nu_fld*log(1+ pow(pba->a_c[n]/a,3*(1+w)/pba->nu_fld));
      //   3*(1+w)*( log(1/a)
      //   + pba->nu_fld/3/(1+w)*log( (1 + pow((pba->a_c),3*(1+w)/pba->nu_fld) ) / (1 + pow((pba->a_c/a),3*(1+w)/pba->nu_fld) ) ) );
    }
    else if(pba->ede_parametrization == EDE_is_DR){
      *integral_fld = -4*log(a);
    }
    else{
      class_stop(pba->error_message,"EDE implementation not finished: to finish it, read the comments in background.c just before this line\n");
    }
    break;
  }

  /** note: of course you can generalise these formulas to anything,
      defining new parameters pba->w..._fld. Just remember that so
      far, HyRec explicitely assumes that w(a)= w0 + wa (1-a/a0); but
      Recfast does not assume anything */

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10e0, %rsp           # imm = 0x10E0
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movapd %xmm0, %xmm6
movq %rdi, %rbx
movl 0x40(%rdi), %eax
cmpl $0x1, %eax
movsd %xmm0, (%rsp)
je 0x607a1
testl %eax, %eax
jne 0x6082d
movsd 0x90ad6(%rip), %xmm2    # 0xf1260
subsd %xmm6, %xmm2
mulsd 0x50(%rbx), %xmm2
addsd 0x48(%rbx), %xmm2
xorpd %xmm5, %xmm5
jmp 0x60821
movl 0x44(%rbx), %eax
xorpd %xmm5, %xmm5
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0x6090d
movsd 0xa0(%rbx), %xmm0
movsd 0xa8(%rbx), %xmm1
movsd %xmm1, 0x40(%rsp)
movsd %xmm0, 0x10(%rsp)
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
movapd %xmm2, 0x30(%rsp)
movsd 0x1c8(%rbx), %xmm0
divsd %xmm6, %xmm0
movsd 0x91e8e(%rip), %xmm1    # 0xf2680
mulsd %xmm2, %xmm1
divsd 0x60(%rbx), %xmm1
callq 0x8620
movapd 0x30(%rsp), %xmm2
xorpd %xmm5, %xmm5
movsd (%rsp), %xmm6
addsd 0x90a49(%rip), %xmm0    # 0xf1260
divsd %xmm0, %xmm2
addsd 0x40(%rsp), %xmm2
xorpd %xmm7, %xmm7
movsd %xmm2, (%r12)
jmp 0x60835
xorpd %xmm5, %xmm5
xorpd %xmm7, %xmm7
movl 0x40(%rbx), %eax
cmpl $0x1, %eax
je 0x60857
testl %eax, %eax
jne 0x609bd
movsd 0x50(%rbx), %xmm2
xorpd 0x909de(%rip), %xmm2    # 0xf1230
jmp 0x609b8
movl 0x44(%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0x60923
movsd 0x1c8(%rbx), %xmm0
movsd 0x91e0a(%rip), %xmm1    # 0xf2680
movapd %xmm0, %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, 0x28(%rsp)
divsd %xmm6, %xmm0
movsd 0x10(%rsp), %xmm2
addsd 0x909ca(%rip), %xmm2    # 0xf1260
movsd %xmm2, 0x8(%rsp)
mulsd %xmm2, %xmm1
movsd %xmm1, 0x30(%rsp)
divsd 0x60(%rbx), %xmm1
addsd 0x90f35(%rip), %xmm1    # 0xf17e8
callq 0x8620
movsd (%rsp), %xmm6
mulsd 0x28(%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm2
subsd 0x40(%rsp), %xmm2
mulsd %xmm0, %xmm2
movapd %xmm6, %xmm0
mulsd %xmm6, %xmm0
movsd 0x60(%rbx), %xmm1
mulsd %xmm1, %xmm0
movsd 0x30(%rsp), %xmm3
divsd %xmm1, %xmm3
addsd 0x90964(%rip), %xmm3    # 0xf1260
mulsd %xmm3, %xmm3
mulsd %xmm0, %xmm3
divsd %xmm3, %xmm2
jmp 0x609b8
cmpl $0x3, %eax
jne 0x60b5d
movsd 0x93b1a(%rip), %xmm2    # 0xf4438
jmp 0x6079c
xorpd %xmm2, %xmm2
cmpl $0x3, %eax
je 0x609b8
movsd 0x93bc0(%rip), %xmm1    # 0xf44f8
mulsd %xmm6, %xmm1
movsd 0x9091c(%rip), %xmm2    # 0xf1260
subsd %xmm7, %xmm2
movsd 0x91d30(%rip), %xmm3    # 0xf2680
movapd %xmm5, %xmm4
divsd %xmm3, %xmm4
divsd %xmm2, %xmm4
divsd %xmm7, %xmm4
mulsd %xmm5, %xmm5
mulsd %xmm6, %xmm5
divsd %xmm3, %xmm5
unpcklpd %xmm5, %xmm1            # xmm1 = xmm1[0],xmm5[0]
movapd 0x91df8(%rip), %xmm5    # 0xf2770
unpcklpd %xmm2, %xmm5            # xmm5 = xmm5[0],xmm2[0]
divpd %xmm5, %xmm1
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
divpd %xmm2, %xmm1
unpcklpd %xmm7, %xmm7            # xmm7 = xmm7[0,0]
divpd %xmm7, %xmm1
movapd %xmm1, %xmm2
subsd %xmm4, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
movapd %xmm0, %xmm2
divsd %xmm3, %xmm2
addsd %xmm6, %xmm0
divsd %xmm0, %xmm2
divsd %xmm0, %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, (%r15)
movl 0x40(%rbx), %eax
xorl %ebp, %ebp
cmpl $0x1, %eax
je 0x60a1d
testl %eax, %eax
jne 0x60b4b
movsd 0x90889(%rip), %xmm0    # 0xf1260
movsd 0x48(%rbx), %xmm1
addsd %xmm0, %xmm1
addsd 0x50(%rbx), %xmm1
movsd %xmm1, 0x10(%rsp)
divsd %xmm6, %xmm0
callq 0x82c0
movsd (%rsp), %xmm1
addsd 0x90de7(%rip), %xmm1    # 0xf17e8
mulsd 0x50(%rbx), %xmm1
mulsd 0x10(%rsp), %xmm0
addsd %xmm1, %xmm0
mulsd 0x91c68(%rip), %xmm0    # 0xf2680
jmp 0x60b46
movl 0x44(%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0x60b2b
movsd 0x1c8(%rbx), %xmm0
movsd 0x10(%rsp), %xmm1
addsd 0x9081e(%rip), %xmm1    # 0xf1260
movsd %xmm1, 0x28(%rsp)
movsd 0x91c30(%rip), %xmm2    # 0xf2680
mulsd %xmm1, %xmm2
movsd %xmm2, 0x8(%rsp)
movapd %xmm2, %xmm1
divsd 0x60(%rbx), %xmm1
callq 0x8620
movsd %xmm0, 0x30(%rsp)
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x8620
movsd %xmm0, 0x60(%rsp)
movsd 0x40(%rsp), %xmm0
addsd 0x907ce(%rip), %xmm0    # 0xf1260
mulsd 0x939d6(%rip), %xmm0    # 0xf4470
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0x82c0
movsd 0x10(%rsp), %xmm1
subsd 0x40(%rsp), %xmm1
mulsd 0x60(%rbx), %xmm1
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, (%rsp)
movsd 0x90792(%rip), %xmm0    # 0xf1260
movapd %xmm0, %xmm1
divsd 0x30(%rsp), %xmm1
movsd %xmm1, 0x58(%rsp)
addsd %xmm1, %xmm0
callq 0x82c0
movsd %xmm0, 0x40(%rsp)
movsd 0x60(%rsp), %xmm0
addsd 0x30(%rsp), %xmm0
mulsd 0x58(%rsp), %xmm0
callq 0x82c0
movsd 0x40(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x10(%rsp), %xmm1
divsd 0x28(%rsp), %xmm1
movsd (%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
jmp 0x60b46
cmpl $0x3, %eax
jne 0x60de6
movsd (%rsp), %xmm0
callq 0x82c0
mulsd 0x93912(%rip), %xmm0    # 0xf4458
movsd %xmm0, (%r14)
movl %ebp, %eax
addq $0x10e0, %rsp           # imm = 0x10E0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movsd 0x38(%rbx), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x58(%rbx), %xmm0
movsd %xmm0, 0x60(%rsp)
movsd 0x48(%rbx), %xmm1
mulsd 0x938f0(%rip), %xmm1    # 0xf4470
movapd %xmm6, %xmm0
callq 0x8620
movsd %xmm0, 0xd0(%rsp)
movsd 0x38(%rbx), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x91adb(%rip), %xmm0    # 0xf2680
movapd %xmm0, 0x10(%rsp)
movsd 0x48(%rbx), %xmm1
mulsd %xmm0, %xmm1
movsd (%rsp), %xmm0
callq 0x8620
movsd %xmm0, 0xd8(%rsp)
movsd 0x58(%rbx), %xmm0
movaps %xmm0, 0x40(%rsp)
movsd 0x48(%rbx), %xmm1
mulsd 0x93892(%rip), %xmm1    # 0xf4470
movsd (%rsp), %xmm0
callq 0x8620
movsd %xmm0, 0x8(%rsp)
movsd 0x58(%rbx), %xmm0
movsd 0x93875(%rip), %xmm2    # 0xf4470
mulsd %xmm2, %xmm0
movsd %xmm0, 0x58(%rsp)
movsd 0x48(%rbx), %xmm1
movsd %xmm1, 0xb0(%rsp)
mulsd %xmm2, %xmm1
addsd 0x90bc9(%rip), %xmm1    # 0xf17e8
movsd (%rsp), %xmm0
callq 0x8620
movsd %xmm0, 0xc0(%rsp)
movsd 0x38(%rbx), %xmm0
movsd %xmm0, 0xc8(%rsp)
movsd 0x48(%rbx), %xmm1
movsd 0x91a33(%rip), %xmm0    # 0xf2680
mulsd %xmm0, %xmm1
movsd (%rsp), %xmm0
callq 0x8620
movsd %xmm0, 0x98(%rsp)
movsd 0x38(%rbx), %xmm0
movsd %xmm0, 0xa0(%rsp)
movsd 0x58(%rbx), %xmm0
movsd %xmm0, 0x80(%rsp)
movsd 0x48(%rbx), %xmm1
mulsd 0x937e3(%rip), %xmm1    # 0xf4470
movsd (%rsp), %xmm0
callq 0x8620
movsd %xmm0, 0x70(%rsp)
movsd 0x905bb(%rip), %xmm0    # 0xf1260
subsd 0x38(%rbx), %xmm0
movsd %xmm0, 0x78(%rsp)
movsd 0x48(%rbx), %xmm1
movsd %xmm1, 0xa8(%rsp)
movsd 0x919ba(%rip), %xmm0    # 0xf2680
mulsd %xmm0, %xmm1
addsd 0x90b16(%rip), %xmm1    # 0xf17e8
movsd (%rsp), %xmm0
callq 0x8620
movsd %xmm0, 0xb8(%rsp)
movsd 0x38(%rbx), %xmm0
movsd %xmm0, 0x88(%rsp)
movsd 0x48(%rbx), %xmm1
movsd 0x91980(%rip), %xmm0    # 0xf2680
mulsd %xmm0, %xmm1
movsd (%rsp), %xmm0
callq 0x8620
movsd %xmm0, 0x68(%rsp)
movapd 0x10(%rsp), %xmm0
mulsd 0x58(%rbx), %xmm0
movapd %xmm0, 0x10(%rsp)
movsd 0x48(%rbx), %xmm1
movsd %xmm1, 0x90(%rsp)
mulsd 0x93735(%rip), %xmm1    # 0xf4470
addsd 0x90aa5(%rip), %xmm1    # 0xf17e8
movsd (%rsp), %xmm0
callq 0x8620
movsd 0x20(%rbx), %xmm1
cmpw $0x1, 0x4b4(%rbx)
jne 0x60d61
addsd 0x28(%rbx), %xmm1
cmpw $0x1, 0x4b6(%rbx)
movsd (%rsp), %xmm6
movapd 0x10(%rsp), %xmm5
movapd 0x40(%rsp), %xmm7
jne 0x60d84
addsd 0xf0(%rbx), %xmm1
cmpw $0x1, 0x4b8(%rbx)
jne 0x60e4c
leaq 0xad4a3(%rip), %rsi     # 0x10e23c
leaq 0x8e0(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0x907d3(%rip), %rsi     # 0xf1585
leaq 0xe0(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x30c2c
addq $0xd1c, %rbx            # imm = 0xD1C
leaq 0x9025f(%rip), %rsi     # 0xf1034
leaq 0xad532(%rip), %rdx     # 0x10e30e
movq %rbx, %rdi
movl $0x318, %ecx            # imm = 0x318
jmp 0x60e38
leaq 0xad532(%rip), %rsi     # 0x10e31f
leaq 0x8e0(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0x9077f(%rip), %rsi     # 0xf1585
leaq 0xe0(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x30c2c
addq $0xd1c, %rbx            # imm = 0xD1C
leaq 0x9020b(%rip), %rsi     # 0xf1034
leaq 0xad4de(%rip), %rdx     # 0x10e30e
movq %rbx, %rdi
movl $0x35e, %ecx            # imm = 0x35E
movq %r15, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %ebp
jmp 0x60b4b
movsd 0x9040b(%rip), %xmm8    # 0xf1260
movapd %xmm8, %xmm2
subsd 0x70(%rsp), %xmm2
movsd 0x80(%rsp), %xmm3
mulsd %xmm2, %xmm3
movsd 0xa0(%rsp), %xmm10
subsd %xmm3, %xmm10
mulsd 0x78(%rsp), %xmm10
mulsd 0x935e4(%rip), %xmm10   # 0xf4470
movapd %xmm8, %xmm2
movsd 0x88(%rsp), %xmm14
subsd %xmm14, %xmm2
mulsd 0x68(%rsp), %xmm2
movapd %xmm8, %xmm3
subsd 0xd0(%rsp), %xmm3
movsd 0x60(%rsp), %xmm4
mulsd %xmm3, %xmm4
movsd 0x30(%rsp), %xmm9
subsd %xmm4, %xmm9
movsd 0x58(%rsp), %xmm11
mulsd 0xb0(%rsp), %xmm11
movapd %xmm8, %xmm3
movsd 0xc8(%rsp), %xmm12
subsd %xmm12, %xmm3
mulsd 0x98(%rsp), %xmm3
movsd 0xa8(%rsp), %xmm13
mulsd %xmm10, %xmm13
addsd %xmm14, %xmm2
movapd %xmm8, %xmm4
movsd 0x28(%rsp), %xmm10
subsd %xmm10, %xmm4
mulsd 0xd8(%rsp), %xmm4
mulsd 0xc0(%rsp), %xmm11
addsd %xmm12, %xmm3
divsd %xmm3, %xmm11
movsd 0xb8(%rsp), %xmm3
mulsd %xmm13, %xmm3
mulsd %xmm2, %xmm2
divsd %xmm2, %xmm3
addsd %xmm11, %xmm3
addsd %xmm10, %xmm4
divsd %xmm4, %xmm9
movapd %xmm8, %xmm2
subsd 0x8(%rsp), %xmm2
mulsd %xmm2, %xmm7
mulsd 0x90(%rsp), %xmm5
mulsd %xmm0, %xmm5
addsd %xmm9, %xmm7
movsd 0x10(%rbx), %xmm2
mulsd 0x94b4b(%rip), %xmm2    # 0xf5ad8
addsd %xmm3, %xmm5
movapd 0x90297(%rip), %xmm0    # 0xf1230
xorpd %xmm5, %xmm0
mulsd %xmm6, %xmm0
unpcklpd %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0]
subsd %xmm7, %xmm8
movapd %xmm7, %xmm2
unpcklpd %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
divpd %xmm2, %xmm0
movapd %xmm0, %xmm1
divpd 0xacb4e(%rip), %xmm1    # 0x10db10
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
movapd %xmm0, %xmm2
addsd %xmm6, %xmm2
unpcklpd %xmm2, %xmm8            # xmm8 = xmm8[0],xmm2[0]
divpd %xmm8, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
jmp 0x60825