// File: /workspace/github_c_makefile_star2_O3/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 0x678c1
movq %rax, %r13
movsd 0x18(%r14), %xmm1
mulsd 0xa5e5c(%rip), %xmm1    # 0x10d6a0
movsd 0x8b39c(%rip), %xmm0    # 0xf2be8
divsd %xmm1, %xmm0
addsd 0x86f90(%rip), %xmm0    # 0xee7e8
leaq 0x24(%rsp), %rcx
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
movq %rax, %r8
callq 0x5c3a8
cmpl $0x1, %eax
jne 0x67908
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0x86b6a(%rip), %rsi     # 0xee3f0
leaq 0xa64f7(%rip), %rdx     # 0x10dd84
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x1064, %r15           # imm = 0x1064
leaq 0x86787(%rip), %rsi     # 0xee034
leaq 0xa64b1(%rip), %rdx     # 0x10dd65
movq %r15, %rdi
movl $0x235, %ecx            # imm = 0x235
jmp 0x67b57
shll $0x3, %ebx
leaq 0x86739(%rip), %rsi     # 0xee004
leaq 0xad9c0(%rip), %rdx     # 0x115292
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0x86743(%rip), %rsi     # 0xee034
leaq 0xa646d(%rip), %rdx     # 0x10dd65
movq %r14, %rdi
movl $0x229, %ecx            # imm = 0x229
movq %r15, %r8
jmp 0x67b5a
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 0xa5458(%rip), %rsi     # 0x10cda4
movq %r12, %rdi
callq 0x8400
testq %rax, %rax
je 0x67b13
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 0x67b7a
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 0x679bf
cmpb $0x28, %cl
jl 0x67af3
movl (%rsp), %ecx
movl 0x4(%rsp), %eax
orl %ecx, %eax
jne 0x67aad
movq %rbx, %rdi
leaq 0xa63e8(%rip), %rsi     # 0x10ddd3
movq %rsp, %rdx
leaq 0x4(%rsp), %rcx
xorl %eax, %eax
callq 0x8390
cmpl $0x2, %eax
jne 0x67de0
movslq (%rsp), %rbp
movq %rbp, %rbx
shlq $0x3, %rbx
movq %rbx, %rdi
callq 0x8460
movq %rax, 0x40(%rsp)
testq %rax, %rax
je 0x67e42
movslq 0x4(%rsp), %r13
movq %r13, %rdi
shlq $0x3, %rdi
callq 0x8460
testq %rax, %rax
je 0x67e8a
movq %rax, %r12
imull %ebp, %r13d
movslq %r13d, %r15
shlq $0x3, %r15
movq %r15, %rdi
callq 0x8460
testq %rax, %rax
je 0x67ed3
movq %rax, %r14
movq %r15, %rdi
callq 0x8460
testq %rax, %rax
je 0x67f1b
movq %rax, %r15
movq %rbx, %rdi
callq 0x8460
testq %rax, %rax
je 0x67f63
movq %rax, %r13
movq %rbx, %rdi
callq 0x8460
testq %rax, %rax
je 0x67fab
movq %rax, 0x10(%rsp)
movq %r13, 0x28(%rsp)
xorl %r13d, %r13d
movq 0x40(%rsp), %rbp
jmp 0x67aeb
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 0xc1b13(%rip), %rsi     # 0x1295eb
xorl %eax, %eax
callq 0x8390
cmpl $0x3, %eax
jne 0x67d7e
incl %r13d
leaq 0x860(%rsp), %rbx
movq %rbx, %rdi
movl $0x3ff, %esi            # imm = 0x3FF
movq 0x18(%rsp), %rdx
callq 0x8540
testq %rax, %rax
jne 0x679bc
jmp 0x67b97
leaq 0x88ece(%rip), %rsi     # 0xf09e8
leaq 0xa62af(%rip), %rdx     # 0x10ddd0
leaq 0x88ef5(%rip), %r8      # 0xf0a1d
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x1064, %r15           # imm = 0x1064
leaq 0x864ec(%rip), %rsi     # 0xee034
leaq 0xa6216(%rip), %rdx     # 0x10dd65
movq %r15, %rdi
movl $0x251, %ecx            # imm = 0x251
movq %rbx, %r8
xorl %eax, %eax
callq 0x30af0
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 0x142a8
addq $0x10, %rsp
cmpl $0x1, %eax
jne 0x67c17
leaq 0x86810(%rip), %rsi     # 0xee3f0
leaq 0xa6343(%rip), %rdx     # 0x10df2a
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %r13, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x86434(%rip), %rsi     # 0xee034
leaq 0xa615e(%rip), %rdx     # 0x10dd65
movq %r13, %rdi
movl $0x28b, %ecx            # imm = 0x28B
movq %r14, %r8
jmp 0x67b5a
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 0x67c91
leaq 0xa6346(%rip), %rsi     # 0x10df86
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movapd %xmm2, %xmm0
movb $0x1, %al
callq 0x30af0
leaq 0x86428(%rip), %rsi     # 0xee082
leaq 0xa641d(%rip), %rdx     # 0x10e07e
leaq 0xc60(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x863b7(%rip), %rsi     # 0xee034
leaq 0xa60e1(%rip), %rdx     # 0x10dd65
movq %r13, %rdi
movl $0x292, %ecx            # imm = 0x292
jmp 0x67900
movslq (%rsp), %r8
ucomisd -0x8(%rbp,%r8,8), %xmm2
jbe 0x67cf6
leaq 0xa63ed(%rip), %rsi     # 0x10e092
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movapd %xmm2, %xmm0
movb $0x1, %al
callq 0x30af0
leaq 0x863c3(%rip), %rsi     # 0xee082
leaq 0xa64c3(%rip), %rdx     # 0x10e189
leaq 0xc60(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x86352(%rip), %rsi     # 0xee034
leaq 0xa607c(%rip), %rdx     # 0x10dd65
movq %r13, %rdi
movl $0x297, %ecx            # imm = 0x297
jmp 0x67900
movsd 0x38(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
subsd %xmm1, %xmm0
mulsd 0xa2daa(%rip), %xmm1    # 0x10aab8
divsd %xmm1, %xmm0
addsd 0xa598e(%rip), %xmm0    # 0x10d6a8
movsd (%r12), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x67ff3
leaq 0xa6477(%rip), %rsi     # 0x10e1a8
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movb $0x1, %al
callq 0x30af0
leaq 0x8633b(%rip), %rsi     # 0xee082
leaq 0xa6559(%rip), %rdx     # 0x10e2a7
leaq 0xc60(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x862ca(%rip), %rsi     # 0xee034
leaq 0xa5ff4(%rip), %rdx     # 0x10dd65
movq %r13, %rdi
movl $0x29c, %ecx            # imm = 0x29C
jmp 0x67900
leaq 0xa60ea(%rip), %rsi     # 0x10de6f
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movq 0x48(%rsp), %rdx
xorl %eax, %eax
callq 0x30af0
leaq 0x862e2(%rip), %rsi     # 0xee082
leaq 0xa610b(%rip), %rdx     # 0x10deb2
leaq 0xc60(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
movq 0x8(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x86265(%rip), %rsi     # 0xee034
leaq 0xa5f8f(%rip), %rdx     # 0x10dd65
movl $0x27a, %ecx            # imm = 0x27A
jmp 0x67c0f
leaq 0xa5ff2(%rip), %rsi     # 0x10ddd9
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movq 0x48(%rsp), %rdx
xorl %eax, %eax
callq 0x30af0
leaq 0x86280(%rip), %rsi     # 0xee082
leaq 0xa6017(%rip), %rdx     # 0x10de20
leaq 0xc60(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
movq 0x8(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x86203(%rip), %rsi     # 0xee034
leaq 0xa5f2d(%rip), %rdx     # 0x10dd65
movl $0x267, %ecx            # imm = 0x267
jmp 0x67c0f
leal (,%rbp,8), %ecx
leaq 0x861b4(%rip), %rsi     # 0xee004
leaq 0xa5ffb(%rip), %rdx     # 0x10de52
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
movq 0x8(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x861bb(%rip), %rsi     # 0xee034
leaq 0xa5ee5(%rip), %rdx     # 0x10dd65
movl $0x269, %ecx            # imm = 0x269
jmp 0x67b57
leal (,%r13,8), %ecx
leaq 0x8616b(%rip), %rsi     # 0xee004
leaq 0xa5fc8(%rip), %rdx     # 0x10de68
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
movq 0x8(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x86172(%rip), %rsi     # 0xee034
leaq 0xa5e9c(%rip), %rdx     # 0x10dd65
movl $0x26a, %ecx            # imm = 0x26A
jmp 0x67b57
shll $0x3, %r13d
leaq 0x86126(%rip), %rsi     # 0xee004
leaq 0xa5f76(%rip), %rdx     # 0x10de5b
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x30af0
movq 0x8(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x8612a(%rip), %rsi     # 0xee034
leaq 0xa5e54(%rip), %rdx     # 0x10dd65
movl $0x26b, %ecx            # imm = 0x26B
jmp 0x67b57
shll $0x3, %r13d
leaq 0x860de(%rip), %rsi     # 0xee004
leaq 0xa5f2c(%rip), %rdx     # 0x10de59
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x30af0
movq 0x8(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x860e2(%rip), %rsi     # 0xee034
leaq 0xa5e0c(%rip), %rdx     # 0x10dd65
movl $0x26c, %ecx            # imm = 0x26C
jmp 0x67b57
leal (,%rbp,8), %ecx
leaq 0x86093(%rip), %rsi     # 0xee004
leaq 0xa5ee9(%rip), %rdx     # 0x10de61
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
movq 0x8(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x8609a(%rip), %rsi     # 0xee034
leaq 0xa5dc4(%rip), %rdx     # 0x10dd65
movl $0x26d, %ecx            # imm = 0x26D
jmp 0x67b57
leal (,%rbp,8), %ecx
leaq 0x8604b(%rip), %rsi     # 0xee004
leaq 0xa5e9f(%rip), %rdx     # 0x10de5f
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
movq 0x8(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x86052(%rip), %rsi     # 0xee034
leaq 0xa5d7c(%rip), %rdx     # 0x10dd65
movl $0x26e, %ecx            # imm = 0x26E
jmp 0x67b57
movslq 0x4(%rsp), %rsi
ucomisd -0x8(%r12,%rsi,8), %xmm0
jbe 0x68055
leaq 0xa62b5(%rip), %rsi     # 0x10e2bd
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movb $0x1, %al
callq 0x30af0
leaq 0x86064(%rip), %rsi     # 0xee082
leaq 0xa6396(%rip), %rdx     # 0x10e3bb
leaq 0xc60(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x85ff3(%rip), %rsi     # 0xee034
leaq 0xa5d1d(%rip), %rdx     # 0x10dd65
movq %r13, %rdi
movl $0x2a1, %ecx            # imm = 0x2A1
jmp 0x67900
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 0x18071
addq $0x20, %rsp
cmpl $0x1, %eax
jne 0x680c2
leaq 0x86362(%rip), %rsi     # 0xee3f0
leaq 0xa6347(%rip), %rdx     # 0x10e3dc
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %r13, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x85f86(%rip), %rsi     # 0xee034
leaq 0xa5cb0(%rip), %rdx     # 0x10dd65
movq %r13, %rdi
movl $0x2af, %ecx            # imm = 0x2AF
jmp 0x67c0f
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 0x142a8
addq $0x10, %rsp
cmpl $0x1, %eax
jne 0x68133
leaq 0x862ee(%rip), %rsi     # 0xee3f0
leaq 0xa635f(%rip), %rdx     # 0x10e468
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %r13, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x85f12(%rip), %rsi     # 0xee034
leaq 0xa5c3c(%rip), %rdx     # 0x10dd65
movq %r13, %rdi
movl $0x2ba, %ecx            # imm = 0x2BA
jmp 0x681af
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 0x18071
addq $0x20, %rsp
cmpl $0x1, %eax
jne 0x681be
leaq 0x86270(%rip), %rsi     # 0xee3f0
leaq 0xa6348(%rip), %rdx     # 0x10e4cf
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %r13, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x85e94(%rip), %rsi     # 0xee034
leaq 0xa5bbe(%rip), %rdx     # 0x10dd65
movq %r13, %rdi
movl $0x2c8, %ecx            # imm = 0x2C8
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
jmp 0x67b66
cmpw $0x1, 0xe78(%r15)
movq 0x58(%rsp), %r13
jne 0x68201
movq 0x50(%rsp), %rax
movslq 0x42c(%rax), %rax
movsd (%r13,%rax,8), %xmm0
addsd 0x865ff(%rip), %xmm0    # 0xee7e8
mulsd 0x8(%r15), %xmm0
addsd 0x86069(%rip), %xmm0    # 0xee260
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 0x67b66