// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/thermodynamics.c
// Function: thermodynamics_helium_from_bbn
int thermodynamics_helium_from_bbn(
                                   struct precision * ppr,
                                   struct background * pba,
                                   struct thermodynamics * pth
                                   ) {

  /** Summary: */

  /** Define local variables */
  FILE * fA;
  char line[_LINE_LENGTH_MAX_];
  char * left;

  int num_omegab=0;
  int num_deltaN=0;

  double * omegab=NULL;
  double * deltaN=NULL;
  double * YHe=NULL;
  double * ddYHe=NULL;
  double * YHe_at_deltaN=NULL;
  double * ddYHe_at_deltaN=NULL;

  int array_line=0;
  double DeltaNeff;
  double omega_b;
  int last_index;
  double Neff_bbn, z_bbn, * pvecback;

  /** - Infer effective number of neutrinos at the time of BBN */
  class_alloc(pvecback,pba->bg_size*sizeof(double),pba->error_message);

  /** - We randomly choose 0.1 MeV to be the temperature of BBN */
  z_bbn = 0.1*1e6/(_eV_over_Kelvin_*pba->T_cmb)-1.0;

  class_call(background_at_z(pba,
                             z_bbn,
                             long_info,
                             inter_normal,
                             &last_index,
                             pvecback),
             pba->error_message,
             pth->error_message);

  Neff_bbn = (pvecback[pba->index_bg_Omega_r]
              *pvecback[pba->index_bg_rho_crit]
              -pvecback[pba->index_bg_rho_g])
    /(7./8.*pow(4./11.,4./3.)*pvecback[pba->index_bg_rho_g]);


  //  printf("Neff early = %g, Neff at bbn: %g\n",pba->Neff,Neff_bbn);

  /** - compute Delta N_eff as defined in bbn file, i.e. \f$ \Delta N_{eff}=0\f$ means \f$ N_{eff}=3.046\f$.
   * Note that even if 3.044 is a better default value, we must keep 3.046 here as long as the BBN file we are
   * using has been computed assuming 3.046.
   */
  DeltaNeff = Neff_bbn - 3.046;

  /* the following file is assumed to contain (apart from comments and blank lines):
     - the two numbers (num_omegab, num_deltaN) = number of values of BBN free parameters
     - three columns (omegab, deltaN, YHe) where omegab = Omega0_b h^2 and deltaN = Neff-3.046 by definition
     - omegab and deltaN are assumed to be arranged as:
     omegab1 deltaN1 YHe
     omegab2 deltaN1 YHe
     .....
     omegab1 delatN2 YHe
     omegab2 deltaN2 YHe
     .....
  */

  class_open(fA,ppr->sBBN_file, "r",pth->error_message);

  /* go through each line */
  while (fgets(line,_LINE_LENGTH_MAX_-1,fA) != NULL) {

    /* eliminate blank spaces at beginning of line */
    left=line;
    while (left[0]==' ') {
      left++;
    }

    /* check that the line is neither blank neither a comment. In ASCII, left[0]>39 means that first non-blank character might
       be the beginning of some data (it is not a newline, a #, a %, etc.) */
    if (left[0] > 39) {

      /* if the line contains data, we must interpret it. If (num_omegab, num_deltaN)=(0,0), the current line must contain
         their values. Otherwise, it must contain (omegab, delatN, YHe). */
      if ((num_omegab==0) && (num_deltaN==0)) {

        /* read (num_omegab, num_deltaN), infer size of arrays and allocate them */
        class_test(sscanf(line,"%d %d",&num_omegab,&num_deltaN) != 2,
                   pth->error_message,
                   "could not read value of parameters (num_omegab,num_deltaN) in file %s\n",ppr->sBBN_file);

        class_alloc(omegab,num_omegab*sizeof(double),pth->error_message);
        class_alloc(deltaN,num_deltaN*sizeof(double),pth->error_message);
        class_alloc(YHe,num_omegab*num_deltaN*sizeof(double),pth->error_message);
        class_alloc(ddYHe,num_omegab*num_deltaN*sizeof(double),pth->error_message);
        class_alloc(YHe_at_deltaN,num_omegab*sizeof(double),pth->error_message);
        class_alloc(ddYHe_at_deltaN,num_omegab*sizeof(double),pth->error_message);
        array_line=0;

      }
      else{

        /* read (omegab, deltaN, YHe) */
        class_test(sscanf(line,"%lg %lg %lg",&(omegab[array_line%num_omegab]),
                          &(deltaN[array_line/num_omegab]),
                          &(YHe[array_line])
                          ) != 3,
                   pth->error_message,
                   "could not read value of parameters (omegab,deltaN,YHe) in file %s\n",ppr->sBBN_file);
        array_line ++;
      }
    }
  }

  fclose(fA);

  /** - spline in one dimension (along deltaN) */
  class_call(array_spline_table_lines(deltaN,
                                      num_deltaN,
                                      YHe,
                                      num_omegab,
                                      ddYHe,
                                      _SPLINE_NATURAL_,
                                      pth->error_message),
             pth->error_message,
             pth->error_message);

  omega_b=pba->Omega0_b*pba->h*pba->h;

  class_test(omega_b < omegab[0],
             pth->error_message,
             "You have asked for an unrealistic small value omega_b = %e. The corresponding value of the primordial helium fraction cannot be found in the interpolation table. If you really want this value, you should fix YHe to a given value rather than to BBN",
             omega_b);

  class_test(omega_b > omegab[num_omegab-1],
             pth->error_message,
             "You have asked for an unrealistic high value omega_b = %e. The corresponding value of the primordial helium fraction cannot be found in the interpolation table. If you really want this value, you should fix YHe to a given value rather than to BBN",
             omega_b);

  class_test(DeltaNeff < deltaN[0],
             pth->error_message,
             "You have asked for an unrealistic small value of Delta N_eff = %e. The corresponding value of the primordial helium fraction cannot be found in the interpolation table. If you really want this value, you should fix YHe to a given value rather than to BBN",
             DeltaNeff);

  class_test(DeltaNeff > deltaN[num_deltaN-1],
             pth->error_message,
             "You have asked for an unrealistic high value of Delta N_eff = %e. The corresponding value of the primordial helium fraction cannot be found in the interpolation table. If you really want this value, you should fix YHe to a given value rather than to BBN",
             DeltaNeff);

  /** - interpolate in one dimension (along deltaN) */
  class_call(array_interpolate_spline(deltaN,
                                      num_deltaN,
                                      YHe,
                                      ddYHe,
                                      num_omegab,
                                      DeltaNeff,
                                      &last_index,
                                      YHe_at_deltaN,
                                      num_omegab,
                                      pth->error_message),
             pth->error_message,
             pth->error_message);

  /** - spline in remaining dimension (along omegab) */
  class_call(array_spline_table_lines(omegab,
                                      num_omegab,
                                      YHe_at_deltaN,
                                      1,
                                      ddYHe_at_deltaN,
                                      _SPLINE_NATURAL_,
                                      pth->error_message),
             pth->error_message,
             pth->error_message);

  /** - interpolate in remaining dimension (along omegab) */
  class_call(array_interpolate_spline(omegab,
                                      num_omegab,
                                      YHe_at_deltaN,
                                      ddYHe_at_deltaN,
                                      1,
                                      omega_b,
                                      &last_index,
                                      &(pth->YHe),
                                      1,
                                      pth->error_message),
             pth->error_message,
             pth->error_message);

  /** - Take into account impact of varying alpha on helium fraction */
  if (pth->has_varconst == _TRUE_) {
    pth->YHe *= pth->bbn_alpha_sensitivity * (pvecback[pba->index_bg_varc_alpha]-1.)+1.;
  }

  /** - deallocate arrays */
  free(omegab);
  free(deltaN);
  free(YHe);
  free(ddYHe);
  free(YHe_at_deltaN);
  free(ddYHe_at_deltaN);
  free(pvecback);

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1468, %rsp           # imm = 0x1468
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
xorl %eax, %eax
movl %eax, (%rsp)
movl %eax, 0x4(%rsp)
movslq 0x43c(%rsi), %rbx
leaq (,%rbx,8), %rdi
callq 0x8460
testq %rax, %rax
je 0x6a204
movq %rax, %r13
movsd 0x18(%r14), %xmm1
mulsd 0xa64f9(%rip), %xmm1    # 0x110680
movsd 0x8ba29(%rip), %xmm0    # 0xf5bb8
divsd %xmm1, %xmm0
addsd 0x8764d(%rip), %xmm0    # 0xf17e8
leaq 0x24(%rsp), %rcx
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
movq %rax, %r8
callq 0x5ea8c
cmpl $0x1, %eax
jne 0x6a24b
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0x87227(%rip), %rsi     # 0xf13f0
leaq 0xa6b64(%rip), %rdx     # 0x110d34
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x1064, %r15           # imm = 0x1064
leaq 0x86e44(%rip), %rsi     # 0xf1034
leaq 0xa6b1e(%rip), %rdx     # 0x110d15
movq %r15, %rdi
movl $0x235, %ecx            # imm = 0x235
jmp 0x6a49a
shll $0x3, %ebx
leaq 0x86df6(%rip), %rsi     # 0xf1004
leaq 0xae03d(%rip), %rdx     # 0x118252
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0x86e00(%rip), %rsi     # 0xf1034
leaq 0xa6ada(%rip), %rdx     # 0x110d15
movq %r14, %rdi
movl $0x229, %ecx            # imm = 0x229
movq %r15, %r8
jmp 0x6a49d
movslq 0x404(%r14), %rax
movsd (%r13,%rax,8), %xmm0
movslq 0x408(%r14), %rax
movslq 0x38c(%r14), %rcx
movsd (%r13,%rcx,8), %xmm1
movsd %xmm1, 0x30(%rsp)
mulsd (%r13,%rax,8), %xmm0
movsd %xmm0, 0x38(%rsp)
addq $0x90, %r12
leaq 0xa5af5(%rip), %rsi     # 0x10fd84
movq %r12, %rdi
callq 0x8400
testq %rax, %rax
je 0x6a456
movq %r14, 0x50(%rsp)
movq %r13, 0x58(%rsp)
movq %r15, 0x8(%rsp)
leaq 0x860(%rsp), %rdi
movl $0x3ff, %esi            # imm = 0x3FF
movq %rax, 0x18(%rsp)
movq %rax, %rdx
callq 0x8540
testq %rax, %rax
je 0x6a4bd
movq %r12, 0x48(%rsp)
xorl %ebp, %ebp
xorl %r12d, %r12d
xorl %r14d, %r14d
xorl %r15d, %r15d
movq $0x0, 0x28(%rsp)
movq $0x0, 0x10(%rsp)
xorl %r13d, %r13d
leaq 0x860(%rsp), %rbx
movq %rbx, %rax
movb (%rax), %cl
incq %rax
cmpb $0x20, %cl
je 0x6a302
cmpb $0x28, %cl
jl 0x6a436
movl (%rsp), %ecx
movl 0x4(%rsp), %eax
orl %ecx, %eax
jne 0x6a3f0
movq %rbx, %rdi
leaq 0xa6a55(%rip), %rsi     # 0x110d83
movq %rsp, %rdx
leaq 0x4(%rsp), %rcx
xorl %eax, %eax
callq 0x8390
cmpl $0x2, %eax
jne 0x6a723
movslq (%rsp), %rbp
movq %rbp, %rbx
shlq $0x3, %rbx
movq %rbx, %rdi
callq 0x8460
movq %rax, 0x40(%rsp)
testq %rax, %rax
je 0x6a785
movslq 0x4(%rsp), %r13
movq %r13, %rdi
shlq $0x3, %rdi
callq 0x8460
testq %rax, %rax
je 0x6a7cd
movq %rax, %r12
imull %ebp, %r13d
movslq %r13d, %r15
shlq $0x3, %r15
movq %r15, %rdi
callq 0x8460
testq %rax, %rax
je 0x6a816
movq %rax, %r14
movq %r15, %rdi
callq 0x8460
testq %rax, %rax
je 0x6a85e
movq %rax, %r15
movq %rbx, %rdi
callq 0x8460
testq %rax, %rax
je 0x6a8a6
movq %rax, %r13
movq %rbx, %rdi
callq 0x8460
testq %rax, %rax
je 0x6a8ee
movq %rax, 0x10(%rsp)
movq %r13, 0x28(%rsp)
xorl %r13d, %r13d
movq 0x40(%rsp), %rbp
jmp 0x6a42e
movl %r13d, %eax
cltd
idivl %ecx
movslq %edx, %rcx
leaq (,%rcx,8), %rdx
addq %rbp, %rdx
cltq
leaq (%r12,%rax,8), %rcx
movslq %r13d, %rax
leaq (%r14,%rax,8), %r8
movq %rbx, %rdi
leaq 0xc21a0(%rip), %rsi     # 0x12c5bb
xorl %eax, %eax
callq 0x8390
cmpl $0x3, %eax
jne 0x6a6c1
incl %r13d
leaq 0x860(%rsp), %rbx
movq %rbx, %rdi
movl $0x3ff, %esi            # imm = 0x3FF
movq 0x18(%rsp), %rdx
callq 0x8540
testq %rax, %rax
jne 0x6a2ff
jmp 0x6a4da
leaq 0x8957b(%rip), %rsi     # 0xf39d8
leaq 0xa691c(%rip), %rdx     # 0x110d80
leaq 0x895a2(%rip), %r8      # 0xf3a0d
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x1064, %r15           # imm = 0x1064
leaq 0x86ba9(%rip), %rsi     # 0xf1034
leaq 0xa6883(%rip), %rdx     # 0x110d15
movq %r15, %rdi
movl $0x251, %ecx            # imm = 0x251
movq %rbx, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %ebp
movl %ebp, %eax
addq $0x1468, %rsp           # imm = 0x1468
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq $0x0, 0x10(%rsp)
movq $0x0, 0x28(%rsp)
xorl %r15d, %r15d
xorl %r14d, %r14d
xorl %r12d, %r12d
xorl %ebp, %ebp
movq 0x18(%rsp), %rdi
callq 0x83a0
movl 0x4(%rsp), %esi
movl (%rsp), %ecx
movq %r15, %r8
movq 0x8(%rsp), %r15
leaq 0x1064(%r15), %r13
subq $0x8, %rsp
movq %r12, %rdi
movq %r14, %rdx
movq %r8, 0x20(%rsp)
xorl %r9d, %r9d
pushq %r13
callq 0x14191
addq $0x10, %rsp
cmpl $0x1, %eax
jne 0x6a55a
leaq 0x86ecd(%rip), %rsi     # 0xf13f0
leaq 0xa69b0(%rip), %rdx     # 0x110eda
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %r13, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x86af1(%rip), %rsi     # 0xf1034
leaq 0xa67cb(%rip), %rdx     # 0x110d15
movq %r13, %rdi
movl $0x28b, %ecx            # imm = 0x28B
movq %r14, %r8
jmp 0x6a49d
movq 0x50(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd 0x20(%rax), %xmm2
mulsd %xmm0, %xmm2
mulsd %xmm0, %xmm2
movsd (%rbp), %xmm0
ucomisd %xmm2, %xmm0
jbe 0x6a5d4
leaq 0xa69b3(%rip), %rsi     # 0x110f36
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movapd %xmm2, %xmm0
movb $0x1, %al
callq 0x30c2c
leaq 0x86ae5(%rip), %rsi     # 0xf1082
leaq 0xa6a8a(%rip), %rdx     # 0x11102e
leaq 0xc60(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x86a74(%rip), %rsi     # 0xf1034
leaq 0xa674e(%rip), %rdx     # 0x110d15
movq %r13, %rdi
movl $0x292, %ecx            # imm = 0x292
jmp 0x6a243
movslq (%rsp), %r8
ucomisd -0x8(%rbp,%r8,8), %xmm2
jbe 0x6a639
leaq 0xa6a5a(%rip), %rsi     # 0x111042
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movapd %xmm2, %xmm0
movb $0x1, %al
callq 0x30c2c
leaq 0x86a80(%rip), %rsi     # 0xf1082
leaq 0xa6b30(%rip), %rdx     # 0x111139
leaq 0xc60(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x86a0f(%rip), %rsi     # 0xf1034
leaq 0xa66e9(%rip), %rdx     # 0x110d15
movq %r13, %rdi
movl $0x297, %ecx            # imm = 0x297
jmp 0x6a243
movsd 0x38(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
subsd %xmm1, %xmm0
mulsd 0xa343f(%rip), %xmm1    # 0x10da90
divsd %xmm1, %xmm0
addsd 0xa602b(%rip), %xmm0    # 0x110688
movsd (%r12), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x6a936
leaq 0xa6ae4(%rip), %rsi     # 0x111158
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movb $0x1, %al
callq 0x30c2c
leaq 0x869f8(%rip), %rsi     # 0xf1082
leaq 0xa6bc6(%rip), %rdx     # 0x111257
leaq 0xc60(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x86987(%rip), %rsi     # 0xf1034
leaq 0xa6661(%rip), %rdx     # 0x110d15
movq %r13, %rdi
movl $0x29c, %ecx            # imm = 0x29C
jmp 0x6a243
leaq 0xa6757(%rip), %rsi     # 0x110e1f
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movq 0x48(%rsp), %rdx
xorl %eax, %eax
callq 0x30c2c
leaq 0x8699f(%rip), %rsi     # 0xf1082
leaq 0xa6778(%rip), %rdx     # 0x110e62
leaq 0xc60(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
movq 0x8(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x86922(%rip), %rsi     # 0xf1034
leaq 0xa65fc(%rip), %rdx     # 0x110d15
movl $0x27a, %ecx            # imm = 0x27A
jmp 0x6a552
leaq 0xa665f(%rip), %rsi     # 0x110d89
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movq 0x48(%rsp), %rdx
xorl %eax, %eax
callq 0x30c2c
leaq 0x8693d(%rip), %rsi     # 0xf1082
leaq 0xa6684(%rip), %rdx     # 0x110dd0
leaq 0xc60(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
movq 0x8(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x868c0(%rip), %rsi     # 0xf1034
leaq 0xa659a(%rip), %rdx     # 0x110d15
movl $0x267, %ecx            # imm = 0x267
jmp 0x6a552
leal (,%rbp,8), %ecx
leaq 0x86871(%rip), %rsi     # 0xf1004
leaq 0xa6668(%rip), %rdx     # 0x110e02
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
movq 0x8(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x86878(%rip), %rsi     # 0xf1034
leaq 0xa6552(%rip), %rdx     # 0x110d15
movl $0x269, %ecx            # imm = 0x269
jmp 0x6a49a
leal (,%r13,8), %ecx
leaq 0x86828(%rip), %rsi     # 0xf1004
leaq 0xa6635(%rip), %rdx     # 0x110e18
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
movq 0x8(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x8682f(%rip), %rsi     # 0xf1034
leaq 0xa6509(%rip), %rdx     # 0x110d15
movl $0x26a, %ecx            # imm = 0x26A
jmp 0x6a49a
shll $0x3, %r13d
leaq 0x867e3(%rip), %rsi     # 0xf1004
leaq 0xa65e3(%rip), %rdx     # 0x110e0b
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x30c2c
movq 0x8(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x867e7(%rip), %rsi     # 0xf1034
leaq 0xa64c1(%rip), %rdx     # 0x110d15
movl $0x26b, %ecx            # imm = 0x26B
jmp 0x6a49a
shll $0x3, %r13d
leaq 0x8679b(%rip), %rsi     # 0xf1004
leaq 0xa6599(%rip), %rdx     # 0x110e09
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x30c2c
movq 0x8(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x8679f(%rip), %rsi     # 0xf1034
leaq 0xa6479(%rip), %rdx     # 0x110d15
movl $0x26c, %ecx            # imm = 0x26C
jmp 0x6a49a
leal (,%rbp,8), %ecx
leaq 0x86750(%rip), %rsi     # 0xf1004
leaq 0xa6556(%rip), %rdx     # 0x110e11
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
movq 0x8(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x86757(%rip), %rsi     # 0xf1034
leaq 0xa6431(%rip), %rdx     # 0x110d15
movl $0x26d, %ecx            # imm = 0x26D
jmp 0x6a49a
leal (,%rbp,8), %ecx
leaq 0x86708(%rip), %rsi     # 0xf1004
leaq 0xa650c(%rip), %rdx     # 0x110e0f
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
movq 0x8(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x8670f(%rip), %rsi     # 0xf1034
leaq 0xa63e9(%rip), %rdx     # 0x110d15
movl $0x26e, %ecx            # imm = 0x26E
jmp 0x6a49a
movslq 0x4(%rsp), %rsi
ucomisd -0x8(%r12,%rsi,8), %xmm0
jbe 0x6a998
leaq 0xa6922(%rip), %rsi     # 0x11126d
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movb $0x1, %al
callq 0x30c2c
leaq 0x86721(%rip), %rsi     # 0xf1082
leaq 0xa6a03(%rip), %rdx     # 0x11136b
leaq 0xc60(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x866b0(%rip), %rsi     # 0xf1034
leaq 0xa638a(%rip), %rdx     # 0x110d15
movq %r13, %rdi
movl $0x2a1, %ecx            # imm = 0x2A1
jmp 0x6a243
movsd %xmm2, 0x38(%rsp)
subq $0x8, %rsp
leaq 0x2c(%rsp), %r9
movq %r12, %rdi
movq %r14, %rdx
movq 0x20(%rsp), %rcx
pushq %r13
pushq %r8
movq 0x40(%rsp), %rbx
pushq %rbx
callq 0x17ee6
addq $0x20, %rsp
cmpl $0x1, %eax
jne 0x6aa05
leaq 0x86a1f(%rip), %rsi     # 0xf13f0
leaq 0xa69b4(%rip), %rdx     # 0x11138c
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %r13, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x86643(%rip), %rsi     # 0xf1034
leaq 0xa631d(%rip), %rdx     # 0x110d15
movq %r13, %rdi
movl $0x2af, %ecx            # imm = 0x2AF
jmp 0x6a552
movl (%rsp), %esi
subq $0x8, %rsp
movq %rbp, %rdi
movl $0x1, %ebp
movq %rdi, 0x48(%rsp)
movq %rbx, %rdx
movl $0x1, %ecx
movq 0x18(%rsp), %r8
movq %r8, 0x18(%rsp)
xorl %r9d, %r9d
pushq %r13
callq 0x14191
addq $0x10, %rsp
cmpl $0x1, %eax
jne 0x6aa76
leaq 0x869ab(%rip), %rsi     # 0xf13f0
leaq 0xa69cc(%rip), %rdx     # 0x111418
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %r13, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x865cf(%rip), %rsi     # 0xf1034
leaq 0xa62a9(%rip), %rdx     # 0x110d15
movq %r13, %rdi
movl $0x2ba, %ecx            # imm = 0x2BA
jmp 0x6aaf2
movq %r12, 0x30(%rsp)
movl (%rsp), %esi
subq $0x8, %rsp
movl $0x1, %ebp
leaq 0x2c(%rsp), %r9
movq 0x48(%rsp), %rdi
movq %rdi, %r12
movq %rbx, %rdx
movq 0x18(%rsp), %rcx
movl $0x1, %r8d
movsd 0x40(%rsp), %xmm0
pushq %r13
pushq $0x1
pushq %r15
callq 0x17ee6
addq $0x20, %rsp
cmpl $0x1, %eax
jne 0x6ab01
leaq 0x8692d(%rip), %rsi     # 0xf13f0
leaq 0xa69b5(%rip), %rdx     # 0x11147f
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %r13, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x86551(%rip), %rsi     # 0xf1034
leaq 0xa622b(%rip), %rdx     # 0x110d15
movq %r13, %rdi
movl $0x2c8, %ecx            # imm = 0x2C8
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
jmp 0x6a4a9
cmpw $0x1, 0xe78(%r15)
movq 0x58(%rsp), %r13
jne 0x6ab44
movq 0x50(%rsp), %rax
movslq 0x42c(%rax), %rax
movsd (%r13,%rax,8), %xmm0
addsd 0x86cbc(%rip), %xmm0    # 0xf17e8
mulsd 0x8(%r15), %xmm0
addsd 0x86726(%rip), %xmm0    # 0xf1260
mulsd (%r15), %xmm0
movsd %xmm0, (%r15)
movq %r12, %rdi
callq 0x8410
movq 0x30(%rsp), %rdi
callq 0x8410
movq %r14, %rdi
callq 0x8410
movq 0x18(%rsp), %rdi
callq 0x8410
movq 0x28(%rsp), %rdi
callq 0x8410
movq 0x10(%rsp), %rdi
callq 0x8410
movq %r13, %rdi
callq 0x8410
xorl %ebp, %ebp
jmp 0x6a4a9