// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10e8, %rsp           # imm = 0x10E8
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movapd %xmm0, %xmm6
movq %rdi, %rbx
movl 0x40(%rdi), %ecx
cmpl $0x1, %ecx
movsd %xmm0, (%rsp)
je 0x5a139
testl %ecx, %ecx
jne 0x5a1c8
movsd 0x8b13e(%rip), %xmm2    # 0xe5260
subsd %xmm6, %xmm2
mulsd 0x50(%rbx), %xmm2
addsd 0x48(%rbx), %xmm2
xorpd %xmm5, %xmm5
jmp 0x5a1b9
movl 0x44(%rbx), %eax
xorpd %xmm5, %xmm5
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0x5a30e
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 0x8c5be(%rip), %xmm1    # 0xe6748
mulsd %xmm2, %xmm1
divsd 0x60(%rbx), %xmm1
callq 0x8650
movapd 0x30(%rsp), %xmm2
xorpd %xmm5, %xmm5
movsd (%rsp), %xmm6
addsd 0x8b0b1(%rip), %xmm0    # 0xe5260
divsd %xmm0, %xmm2
addsd 0x40(%rsp), %xmm2
xorpd %xmm7, %xmm7
movsd %xmm2, (%r12)
movl 0x40(%rbx), %ecx
jmp 0x5a1d0
xorpd %xmm5, %xmm5
xorpd %xmm7, %xmm7
cmpl $0x1, %ecx
je 0x5a1f4
testl %ecx, %ecx
jne 0x5a2ad
movsd 0x50(%rbx), %xmm0
xorpd 0x8b046(%rip), %xmm0    # 0xe5230
movlpd %xmm0, (%r15)
jmp 0x5a2c0
movl 0x44(%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0x5a324
movsd 0x1c8(%rbx), %xmm0
movsd 0x8c535(%rip), %xmm1    # 0xe6748
movapd %xmm0, %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, 0x28(%rsp)
divsd %xmm6, %xmm0
movsd 0x10(%rsp), %xmm2
addsd 0x8b02d(%rip), %xmm2    # 0xe5260
movsd %xmm2, 0x8(%rsp)
mulsd %xmm2, %xmm1
movsd %xmm1, 0x30(%rsp)
divsd 0x60(%rbx), %xmm1
addsd 0x8b598(%rip), %xmm1    # 0xe57e8
callq 0x8650
movsd (%rsp), %xmm6
mulsd 0x28(%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
subsd 0x40(%rsp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm6, %xmm0
mulsd %xmm6, %xmm0
movsd 0x60(%rbx), %xmm2
mulsd %xmm2, %xmm0
movsd 0x30(%rsp), %xmm3
divsd %xmm2, %xmm3
addsd 0x8afc7(%rip), %xmm3    # 0xe5260
mulsd %xmm3, %xmm3
mulsd %xmm0, %xmm3
divsd %xmm3, %xmm1
movsd %xmm1, (%r15)
movl 0x40(%rbx), %ecx
cmpl $0x1, %ecx
je 0x5a3be
xorl %eax, %eax
testl %ecx, %ecx
jne 0x5a4f8
movsd 0x8af98(%rip), %xmm0    # 0xe5260
movsd 0x48(%rbx), %xmm1
addsd %xmm0, %xmm1
addsd 0x50(%rbx), %xmm1
movsd %xmm1, 0x10(%rsp)
divsd %xmm6, %xmm0
callq 0x82e0
movsd (%rsp), %xmm1
addsd 0x8b4f6(%rip), %xmm1    # 0xe57e8
mulsd 0x50(%rbx), %xmm1
mulsd 0x10(%rsp), %xmm0
addsd %xmm1, %xmm0
mulsd 0x8c43f(%rip), %xmm0    # 0xe6748
jmp 0x5a4f1
cmpl $0x3, %eax
jne 0x5a507
movsd 0x8e0e9(%rip), %xmm2    # 0xe8408
jmp 0x5a134
xorpd %xmm3, %xmm3
cmpl $0x3, %eax
je 0x5a3b9
movsd 0x8e18f(%rip), %xmm1    # 0xe84c8
mulsd %xmm6, %xmm1
movsd 0x8af1b(%rip), %xmm3    # 0xe5260
subsd %xmm7, %xmm3
movsd 0x8c3f7(%rip), %xmm2    # 0xe6748
movapd %xmm5, %xmm4
divsd %xmm2, %xmm4
divsd %xmm3, %xmm4
divsd %xmm7, %xmm4
mulsd %xmm5, %xmm5
mulsd %xmm6, %xmm5
divsd %xmm2, %xmm5
unpcklpd %xmm5, %xmm1            # xmm1 = xmm1[0],xmm5[0]
movapd 0x8c3d7(%rip), %xmm5    # 0xe6750
unpcklpd %xmm3, %xmm5            # xmm5 = xmm5[0],xmm3[0]
divpd %xmm5, %xmm1
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
divpd %xmm3, %xmm1
unpcklpd %xmm7, %xmm7            # xmm7 = xmm7[0,0]
divpd %xmm7, %xmm1
movapd %xmm1, %xmm3
subsd %xmm4, %xmm3
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm3, %xmm1
movapd %xmm0, %xmm3
divsd %xmm2, %xmm3
addsd %xmm6, %xmm0
divsd %xmm0, %xmm3
divsd %xmm0, %xmm3
addsd %xmm1, %xmm3
movsd %xmm3, (%r15)
movl 0x44(%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
movsd 0x10(%rsp), %xmm1
jae 0x5a4d6
movsd 0x1c8(%rbx), %xmm0
movapd %xmm1, %xmm2
addsd 0x8ae79(%rip), %xmm2    # 0xe5260
movsd %xmm2, 0x28(%rsp)
movsd 0x8c353(%rip), %xmm3    # 0xe6748
mulsd %xmm2, %xmm3
movsd %xmm3, 0x8(%rsp)
movsd %xmm1, 0x10(%rsp)
movapd %xmm3, %xmm1
divsd 0x60(%rbx), %xmm1
callq 0x8650
movsd %xmm0, 0x30(%rsp)
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x8650
movsd %xmm0, 0x60(%rsp)
movsd 0x40(%rsp), %xmm0
addsd 0x8ae23(%rip), %xmm0    # 0xe5260
mulsd 0x8dffb(%rip), %xmm0    # 0xe8440
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0x82e0
movsd 0x10(%rsp), %xmm1
subsd 0x40(%rsp), %xmm1
mulsd 0x60(%rbx), %xmm1
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, (%rsp)
movsd 0x8ade7(%rip), %xmm0    # 0xe5260
movapd %xmm0, %xmm1
divsd 0x30(%rsp), %xmm1
movsd %xmm1, 0x58(%rsp)
addsd %xmm1, %xmm0
callq 0x82e0
movsd %xmm0, 0x40(%rsp)
movsd 0x60(%rsp), %xmm0
addsd 0x30(%rsp), %xmm0
mulsd 0x58(%rsp), %xmm0
callq 0x82e0
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 0x5a4f1
cmpl $0x3, %eax
jne 0x5a790
movsd (%rsp), %xmm0
callq 0x82e0
mulsd 0x8df37(%rip), %xmm0    # 0xe8428
movsd %xmm0, (%r14)
xorl %eax, %eax
addq $0x10e8, %rsp           # imm = 0x10E8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movsd 0x38(%rbx), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x58(%rbx), %xmm0
movsd %xmm0, 0x60(%rsp)
movsd 0x48(%rbx), %xmm1
mulsd 0x8df16(%rip), %xmm1    # 0xe8440
movapd %xmm6, %xmm0
callq 0x8650
movsd %xmm0, 0xd0(%rsp)
movsd 0x38(%rbx), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x8c1f9(%rip), %xmm0    # 0xe6748
movapd %xmm0, 0x10(%rsp)
movsd 0x48(%rbx), %xmm1
mulsd %xmm0, %xmm1
movsd (%rsp), %xmm0
callq 0x8650
movsd %xmm0, 0xd8(%rsp)
movsd 0x58(%rbx), %xmm0
movaps %xmm0, 0x40(%rsp)
movsd 0x48(%rbx), %xmm1
mulsd 0x8deb8(%rip), %xmm1    # 0xe8440
movsd (%rsp), %xmm0
callq 0x8650
movsd %xmm0, 0x8(%rsp)
movsd 0x58(%rbx), %xmm0
movsd 0x8de9b(%rip), %xmm2    # 0xe8440
mulsd %xmm2, %xmm0
movsd %xmm0, 0x58(%rsp)
movsd 0x48(%rbx), %xmm1
movsd %xmm1, 0xb0(%rsp)
mulsd %xmm2, %xmm1
addsd 0x8b21f(%rip), %xmm1    # 0xe57e8
movsd (%rsp), %xmm0
callq 0x8650
movsd %xmm0, 0xc0(%rsp)
movsd 0x38(%rbx), %xmm0
movsd %xmm0, 0xc8(%rsp)
movsd 0x48(%rbx), %xmm1
movsd 0x8c151(%rip), %xmm0    # 0xe6748
mulsd %xmm0, %xmm1
movsd (%rsp), %xmm0
callq 0x8650
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 0x8de09(%rip), %xmm1    # 0xe8440
movsd (%rsp), %xmm0
callq 0x8650
movsd %xmm0, 0x70(%rsp)
movsd 0x8ac11(%rip), %xmm0    # 0xe5260
subsd 0x38(%rbx), %xmm0
movsd %xmm0, 0x78(%rsp)
movsd 0x48(%rbx), %xmm1
movsd %xmm1, 0xa8(%rsp)
movsd 0x8c0d8(%rip), %xmm0    # 0xe6748
mulsd %xmm0, %xmm1
addsd 0x8b16c(%rip), %xmm1    # 0xe57e8
movsd (%rsp), %xmm0
callq 0x8650
movsd %xmm0, 0xb8(%rsp)
movsd 0x38(%rbx), %xmm0
movsd %xmm0, 0x88(%rsp)
movsd 0x48(%rbx), %xmm1
movsd 0x8c09e(%rip), %xmm0    # 0xe6748
mulsd %xmm0, %xmm1
movsd (%rsp), %xmm0
callq 0x8650
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 0x8dd5b(%rip), %xmm1    # 0xe8440
addsd 0x8b0fb(%rip), %xmm1    # 0xe57e8
movsd (%rsp), %xmm0
callq 0x8650
movsd 0x20(%rbx), %xmm1
cmpw $0x1, 0x4b4(%rbx)
jne 0x5a70b
addsd 0x28(%rbx), %xmm1
cmpw $0x1, 0x4b6(%rbx)
movsd (%rsp), %xmm6
movapd 0x10(%rsp), %xmm5
movapd 0x40(%rsp), %xmm7
jne 0x5a72e
addsd 0xf0(%rbx), %xmm1
cmpw $0x1, 0x4b8(%rbx)
jne 0x5a7f4
leaq 0xa79d9(%rip), %rsi     # 0x10211c
leaq 0x8e0(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x8ae29(%rip), %rsi     # 0xe5585
leaq 0xe0(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2e014
addq $0xd1c, %rbx            # imm = 0xD1C
leaq 0x8a8b5(%rip), %rsi     # 0xe5034
leaq 0xa7a68(%rip), %rdx     # 0x1021ee
movq %rbx, %rdi
movl $0x318, %ecx            # imm = 0x318
jmp 0x5a7e2
leaq 0xa7a68(%rip), %rsi     # 0x1021ff
leaq 0x8e0(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x8add5(%rip), %rsi     # 0xe5585
leaq 0xe0(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2e014
addq $0xd1c, %rbx            # imm = 0xD1C
leaq 0x8a861(%rip), %rsi     # 0xe5034
leaq 0xa7a14(%rip), %rdx     # 0x1021ee
movq %rbx, %rdi
movl $0x35e, %ecx            # imm = 0x35E
movq %r15, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
jmp 0x5a4f8
movsd 0x8aa63(%rip), %xmm8    # 0xe5260
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 0x8dc0c(%rip), %xmm10   # 0xe8440
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 0x8f093(%rip), %xmm2    # 0xe99c8
addsd %xmm3, %xmm5
movapd 0x8a8ef(%rip), %xmm0    # 0xe5230
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 0xa7096(%rip), %xmm1    # 0x101a00
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 0x5a1bd