// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, 0x8(%rsp)
movq %rdx, %rbp
andl $0x0, 0xc(%rsp)
movq %rsi, %r14
movq %rdi, %r13
movslq 0x43c(%rsi), %rbx
leaq (,%rbx,8), %rdi
callq 0x8490
testq %rax, %rax
je 0x635e9
movq %rax, %r15
movsd 0x18(%r14), %xmm1
mulsd 0xa0ff2(%rip), %xmm1    # 0x104560
movsd 0x86532(%rip), %xmm0    # 0xe9aa8
divsd %xmm1, %xmm0
addsd 0x82266(%rip), %xmm0    # 0xe57e8
pushq $0x2
popq %rsi
leaq 0x34(%rsp), %rcx
movq %r14, %rdi
xorl %edx, %edx
movq %rax, %r8
callq 0x585e8
cmpl $0x1, %eax
jne 0x63630
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0x81e42(%rip), %rsi     # 0xe53f0
leaq 0xa166f(%rip), %rdx     # 0x104c24
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x1064, %rbp           # imm = 0x1064
leaq 0x81a5f(%rip), %rsi     # 0xe5034
leaq 0xa1629(%rip), %rdx     # 0x104c05
movq %rbp, %rdi
movl $0x235, %ecx            # imm = 0x235
jmp 0x6394e
shll $0x3, %ebx
leaq 0x81a11(%rip), %rsi     # 0xe5004
leaq 0xa8b38(%rip), %rdx     # 0x10c132
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x2e014
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0x81a1b(%rip), %rsi     # 0xe5034
leaq 0xa15e5(%rip), %rdx     # 0x104c05
movq %r14, %rdi
movl $0x229, %ecx            # imm = 0x229
movq %r15, %r8
jmp 0x63951
movslq 0x404(%r14), %rax
movsd (%r15,%rax,8), %xmm0
movslq 0x408(%r14), %rax
movslq 0x38c(%r14), %rcx
movsd (%r15,%rcx,8), %xmm1
movsd %xmm1, 0x20(%rsp)
mulsd (%r15,%rax,8), %xmm0
movsd %xmm0, 0x58(%rsp)
addq $0x90, %r13
leaq 0xa05f3(%rip), %rsi     # 0x103c64
movq %r13, %rdi
callq 0x8420
testq %rax, %rax
je 0x6390a
movq %rax, %r12
movq %rbp, 0x10(%rsp)
movsd 0x58(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
subsd %xmm1, %xmm0
mulsd 0x9e2de(%rip), %xmm1    # 0x101980
divsd %xmm1, %xmm0
addsd 0xa0eba(%rip), %xmm0    # 0x104568
movsd %xmm0, 0x58(%rsp)
leaq 0x1060(%rsp), %rbp
xorl %eax, %eax
xorl %ebx, %ebx
movq $0x0, 0x48(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
movq %rax, 0x18(%rsp)
movq %rbx, 0x28(%rsp)
xorl %ebx, %ebx
movq %rbp, %rdi
movl $0x3ff, %esi            # imm = 0x3FF
movq %r12, %rdx
callq 0x8570
testq %rax, %rax
je 0x63888
movq %rbp, %rax
movb (%rax), %cl
incq %rax
cmpb $0x20, %cl
je 0x6370c
cmpb $0x28, %cl
jl 0x636f0
movl 0x8(%rsp), %ecx
movl 0xc(%rsp), %eax
orl %ecx, %eax
je 0x63769
movl %ebx, %eax
cltd
idivl %ecx
movq 0x50(%rsp), %rcx
leaq (%rcx,%rdx,8), %rdx
cltq
movq 0x40(%rsp), %rcx
leaq (%rcx,%rax,8), %rcx
movl %ebx, %eax
movq 0x20(%rsp), %rsi
leaq (%rsi,%rax,8), %r8
movq %rbp, %rdi
leaq 0xbcd46(%rip), %rsi     # 0x12049b
xorl %eax, %eax
callq 0x83b0
cmpl $0x3, %eax
jne 0x63b8c
incl %ebx
jmp 0x636f0
movq %rbp, %rdi
leaq 0xa1500(%rip), %rsi     # 0x104c73
leaq 0x8(%rsp), %rdx
leaq 0xc(%rsp), %rcx
xorl %eax, %eax
callq 0x83b0
cmpl $0x2, %eax
jne 0x63d4e
movslq 0x8(%rsp), %rbx
movq %rbx, %rdi
shlq $0x3, %rdi
movq %rdi, 0x28(%rsp)
callq 0x8490
movq %rax, 0x50(%rsp)
testq %rax, %rax
je 0x63dae
movq %rbx, 0x18(%rsp)
movslq 0xc(%rsp), %rbx
movq %rbx, %rdi
shlq $0x3, %rdi
callq 0x8490
testq %rax, %rax
je 0x63df6
movq %rax, 0x40(%rsp)
imull 0x18(%rsp), %ebx
movq %rbx, 0x38(%rsp)
movslq %ebx, %rbx
shlq $0x3, %rbx
movq %rbx, %rdi
callq 0x8490
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x63e3e
movq %rbx, %rdi
callq 0x8490
movq %rax, 0x48(%rsp)
testq %rax, %rax
je 0x63e87
movq 0x28(%rsp), %rdi
callq 0x8490
testq %rax, %rax
je 0x63ed0
movq %rax, %rbx
movq 0x28(%rsp), %rdi
callq 0x8490
testq %rax, %rax
jne 0x636e4
movq 0x18(%rsp), %rax
leal (,%rax,8), %ecx
leaq 0x817b6(%rip), %rsi     # 0xe5004
leaq 0xa14aa(%rip), %rdx     # 0x104cff
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
movq 0x10(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x817bd(%rip), %rsi     # 0xe5034
leaq 0xa1387(%rip), %rdx     # 0x104c05
movl $0x26e, %ecx            # imm = 0x26E
jmp 0x6394e
movq %r12, %rdi
callq 0x83c0
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %ecx
movq 0x10(%rsp), %rax
leaq 0x1064(%rax), %r13
subq $0x8, %rsp
movq 0x48(%rsp), %rbx
movq %rbx, %rdi
movq 0x28(%rsp), %rdx
movq 0x50(%rsp), %rbp
movq %rbp, %r8
xorl %r9d, %r9d
pushq %r13
callq 0x125a5
popq %rcx
popq %rdx
cmpl $0x1, %eax
jne 0x6396f
leaq 0x81b17(%rip), %rsi     # 0xe53f0
leaq 0xa14ea(%rip), %rdx     # 0x104dca
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x8173b(%rip), %rsi     # 0xe5034
leaq 0xa1305(%rip), %rdx     # 0x104c05
movq %r13, %rdi
movl $0x28b, %ecx            # imm = 0x28B
jmp 0x6394e
leaq 0x84097(%rip), %rsi     # 0xe79a8
leaq 0xa1358(%rip), %rdx     # 0x104c70
leaq 0x840be(%rip), %r8      # 0xe79dd
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x1064, %rbp           # imm = 0x1064
leaq 0x816f5(%rip), %rsi     # 0xe5034
leaq 0xa12bf(%rip), %rdx     # 0x104c05
movq %rbp, %rdi
movl $0x251, %ecx            # imm = 0x251
movq %rbx, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x1468, %rsp           # imm = 0x1468
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movsd 0x8(%r14), %xmm0
movsd 0x20(%r14), %xmm2
mulsd %xmm0, %xmm2
mulsd %xmm0, %xmm2
movq 0x50(%rsp), %r12
movsd (%r12), %xmm0
ucomisd %xmm2, %xmm0
jbe 0x639ec
leaq 0xa148b(%rip), %rsi     # 0x104e26
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movapd %xmm2, %xmm0
movb $0x1, %al
callq 0x2e014
leaq 0x816cd(%rip), %rsi     # 0xe5082
leaq 0xa1562(%rip), %rdx     # 0x104f1e
leaq 0x860(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x8165c(%rip), %rsi     # 0xe5034
leaq 0xa1226(%rip), %rdx     # 0x104c05
movq %r13, %rdi
movl $0x292, %ecx            # imm = 0x292
jmp 0x63be7
movslq 0x8(%rsp), %r8
ucomisd -0x8(%r12,%r8,8), %xmm2
jbe 0x63a52
leaq 0xa1531(%rip), %rsi     # 0x104f32
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movapd %xmm2, %xmm0
movb $0x1, %al
callq 0x2e014
leaq 0x81667(%rip), %rsi     # 0xe5082
leaq 0xa1607(%rip), %rdx     # 0x105029
leaq 0x860(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x815f6(%rip), %rsi     # 0xe5034
leaq 0xa11c0(%rip), %rdx     # 0x104c05
movq %r13, %rdi
movl $0x297, %ecx            # imm = 0x297
jmp 0x63be7
movsd (%rbx), %xmm0
movsd 0x58(%rsp), %xmm1
ucomisd %xmm1, %xmm0
movapd %xmm1, %xmm0
jbe 0x63aba
leaq 0xa15db(%rip), %rsi     # 0x105048
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movb $0x1, %al
callq 0x2e014
leaq 0x815ff(%rip), %rsi     # 0xe5082
leaq 0xa16bd(%rip), %rdx     # 0x105147
leaq 0x860(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x8158e(%rip), %rsi     # 0xe5034
leaq 0xa1158(%rip), %rdx     # 0x104c05
movq %r13, %rdi
movl $0x29c, %ecx            # imm = 0x29C
jmp 0x63be7
movslq 0xc(%rsp), %rsi
ucomisd -0x8(%rbx,%rsi,8), %xmm0
jbe 0x63b1b
leaq 0xa168f(%rip), %rsi     # 0x10515d
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movb $0x1, %al
callq 0x2e014
leaq 0x8159e(%rip), %rsi     # 0xe5082
leaq 0xa1770(%rip), %rdx     # 0x10525b
leaq 0x860(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x8152d(%rip), %rsi     # 0xe5034
leaq 0xa10f7(%rip), %rdx     # 0x104c05
movq %r13, %rdi
movl $0x2a1, %ecx            # imm = 0x2A1
jmp 0x63be7
movsd %xmm2, 0x38(%rsp)
subq $0x8, %rsp
leaq 0x3c(%rsp), %r9
movq %rbx, %rdi
movq 0x28(%rsp), %rdx
movq %rbp, %rcx
pushq %r13
pushq %r8
movq 0x40(%rsp), %rbx
pushq %rbx
callq 0x1604b
addq $0x20, %rsp
cmpl $0x1, %eax
jne 0x63bef
leaq 0x81898(%rip), %rsi     # 0xe53f0
leaq 0xa171d(%rip), %rdx     # 0x10527c
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x814bc(%rip), %rsi     # 0xe5034
leaq 0xa1086(%rip), %rdx     # 0x104c05
movq %r13, %rdi
movl $0x2af, %ecx            # imm = 0x2AF
jmp 0x6394e
leaq 0xa117c(%rip), %rsi     # 0x104d0f
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x2e014
leaq 0x814d6(%rip), %rsi     # 0xe5082
leaq 0xa119f(%rip), %rdx     # 0x104d52
leaq 0x860(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
movq 0x10(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x81459(%rip), %rsi     # 0xe5034
leaq 0xa1023(%rip), %rdx     # 0x104c05
movl $0x27a, %ecx            # imm = 0x27A
movq %r14, %r8
jmp 0x63951
movl 0x8(%rsp), %esi
subq $0x8, %rsp
pushq $0x1
popq %rbp
movq %r12, %rdi
movq %rbx, %rdx
movl %ebp, %ecx
movq 0x20(%rsp), %r8
xorl %r9d, %r9d
pushq %r13
callq 0x125a5
popq %rcx
popq %rdx
cmpl $0x1, %eax
jne 0x63c50
leaq 0x817d1(%rip), %rsi     # 0xe53f0
leaq 0xa16e2(%rip), %rdx     # 0x105308
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x813f5(%rip), %rsi     # 0xe5034
leaq 0xa0fbf(%rip), %rdx     # 0x104c05
movq %r13, %rdi
movl $0x2ba, %ecx            # imm = 0x2BA
jmp 0x63cc2
movl 0x8(%rsp), %esi
subq $0x8, %rsp
pushq $0x1
popq %rbp
leaq 0x3c(%rsp), %r9
movq %r12, %rdi
movq %rbx, %rdx
movq 0x20(%rsp), %rcx
movl %ebp, %r8d
movsd 0x40(%rsp), %xmm0
pushq %r13
pushq $0x1
movq 0x28(%rsp), %rbx
pushq %rbx
callq 0x1604b
addq $0x20, %rsp
cmpl $0x1, %eax
jne 0x63cd1
leaq 0x8175d(%rip), %rsi     # 0xe53f0
leaq 0xa16d5(%rip), %rdx     # 0x10536f
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x81381(%rip), %rsi     # 0xe5034
leaq 0xa0f4b(%rip), %rdx     # 0x104c05
movq %r13, %rdi
movl $0x2c8, %ecx            # imm = 0x2C8
movq %rbx, %r8
xorl %eax, %eax
callq 0x2e014
jmp 0x6395b
cmpw $0x1, 0xe78(%rbx)
jne 0x63d05
movslq 0x42c(%r14), %rax
movsd (%r15,%rax,8), %xmm0
addsd 0x81af8(%rip), %xmm0    # 0xe57e8
mulsd 0x8(%rbx), %xmm0
addsd 0x81563(%rip), %xmm0    # 0xe5260
mulsd (%rbx), %xmm0
movsd %xmm0, (%rbx)
movq %r12, %rdi
callq 0x8430
movq 0x40(%rsp), %rdi
callq 0x8430
movq 0x20(%rsp), %rdi
callq 0x8430
movq 0x48(%rsp), %rdi
callq 0x8430
movq 0x28(%rsp), %rdi
callq 0x8430
movq 0x18(%rsp), %rdi
callq 0x8430
movq %r15, %rdi
callq 0x8430
xorl %ebp, %ebp
jmp 0x6395b
leaq 0xa0f24(%rip), %rsi     # 0x104c79
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x2e014
leaq 0x81314(%rip), %rsi     # 0xe5082
leaq 0xa0f4b(%rip), %rdx     # 0x104cc0
leaq 0x860(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
movq 0x10(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x81297(%rip), %rsi     # 0xe5034
leaq 0xa0e61(%rip), %rdx     # 0x104c05
movl $0x267, %ecx            # imm = 0x267
jmp 0x63be7
leal (,%rbx,8), %ecx
leaq 0x81248(%rip), %rsi     # 0xe5004
leaq 0xa0f2f(%rip), %rdx     # 0x104cf2
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
movq 0x10(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x8124f(%rip), %rsi     # 0xe5034
leaq 0xa0e19(%rip), %rdx     # 0x104c05
movl $0x269, %ecx            # imm = 0x269
jmp 0x6394e
leal (,%rbx,8), %ecx
leaq 0x81200(%rip), %rsi     # 0xe5004
leaq 0xa0efd(%rip), %rdx     # 0x104d08
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
movq 0x10(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x81207(%rip), %rsi     # 0xe5034
leaq 0xa0dd1(%rip), %rdx     # 0x104c05
movl $0x26a, %ecx            # imm = 0x26A
jmp 0x6394e
movq 0x38(%rsp), %rcx
shll $0x3, %ecx
leaq 0x811b7(%rip), %rsi     # 0xe5004
leaq 0xa0ea7(%rip), %rdx     # 0x104cfb
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
movq 0x10(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x811be(%rip), %rsi     # 0xe5034
leaq 0xa0d88(%rip), %rdx     # 0x104c05
movl $0x26b, %ecx            # imm = 0x26B
jmp 0x6394e
movq 0x38(%rsp), %rcx
shll $0x3, %ecx
leaq 0x8116e(%rip), %rsi     # 0xe5004
leaq 0xa0e5c(%rip), %rdx     # 0x104cf9
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
movq 0x10(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x81175(%rip), %rsi     # 0xe5034
leaq 0xa0d3f(%rip), %rdx     # 0x104c05
movl $0x26c, %ecx            # imm = 0x26C
jmp 0x6394e
movq 0x18(%rsp), %rax
leal (,%rax,8), %ecx
leaq 0x81121(%rip), %rsi     # 0xe5004
leaq 0xa0e17(%rip), %rdx     # 0x104d01
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
movq 0x10(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x81128(%rip), %rsi     # 0xe5034
leaq 0xa0cf2(%rip), %rdx     # 0x104c05
movl $0x26d, %ecx            # imm = 0x26D
jmp 0x6394e