// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xcd38, %rsp           # imm = 0xCD38
movq %rdi, 0xcd28(%rsp)
movq %rsi, 0xcd20(%rsp)
movq %rdx, 0xcd18(%rsp)
movl $0x0, 0xc904(%rsp)
movl $0x0, 0xc900(%rsp)
movq $0x0, 0xc8f8(%rsp)
movq $0x0, 0xc8f0(%rsp)
movq $0x0, 0xc8e8(%rsp)
movq $0x0, 0xc8e0(%rsp)
movq $0x0, 0xc8d8(%rsp)
movq $0x0, 0xc8d0(%rsp)
movl $0x0, 0xc8cc(%rsp)
movq 0xcd20(%rsp), %rax
movslq 0x43c(%rax), %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, 0xc898(%rsp)
cmpq $0x0, 0xc898(%rsp)
jne 0xb3582
movq 0xcd20(%rsp), %rax
movslq 0x43c(%rax), %rax
shlq $0x3, %rax
movl %eax, 0xc894(%rsp)
leaq 0xc090(%rsp), %rdi
movl 0xc894(%rsp), %ecx
leaq 0x11ead1(%rip), %rsi    # 0x1d2004
leaq 0x145d3d(%rip), %rdx    # 0x1f9277
movb $0x0, %al
callq 0x5b9c0
movq 0xcd20(%rsp), %rdi
addq $0xd1c, %rdi            # imm = 0xD1C
leaq 0xc090(%rsp), %r8
leaq 0x11ead5(%rip), %rsi    # 0x1d2034
leaq 0x13e646(%rip), %rdx    # 0x1f1bac
movl $0x229, %ecx            # imm = 0x229
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xcd34(%rsp)
jmp 0xb44f8
movq 0xcd20(%rsp), %rax
movsd 0x13df4e(%rip), %xmm1   # 0x1f14e0
mulsd 0x18(%rax), %xmm1
movsd 0x123151(%rip), %xmm0   # 0x1d66f0
divsd %xmm1, %xmm0
movsd 0x11ec9d(%rip), %xmm1   # 0x1d2248
subsd %xmm1, %xmm0
movsd %xmm0, 0xc8a0(%rsp)
movq 0xcd20(%rsp), %rdi
movsd 0xc8a0(%rsp), %xmm0
movq 0xc898(%rsp), %r8
movl $0x2, %esi
xorl %edx, %edx
leaq 0xc8b4(%rsp), %rcx
callq 0x9e4b0
cmpl $0x1, %eax
jne 0xb3657
leaq 0xb890(%rsp), %rdi
movq 0xcd20(%rsp), %rcx
addq $0xd1c, %rcx            # imm = 0xD1C
leaq 0x11edd0(%rip), %rsi    # 0x1d23d8
leaq 0x13e5bc(%rip), %rdx    # 0x1f1bcb
movb $0x0, %al
callq 0x5b9c0
movq 0xcd18(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0xb890(%rsp), %r8
leaq 0x11ea00(%rip), %rsi    # 0x1d2034
leaq 0x13e571(%rip), %rdx    # 0x1f1bac
movl $0x235, %ecx            # imm = 0x235
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xcd34(%rsp)
jmp 0xb44f8
movq 0xc898(%rsp), %rax
movq 0xcd20(%rsp), %rcx
movslq 0x404(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0xc898(%rsp), %rax
movq 0xcd20(%rsp), %rcx
movslq 0x408(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm2
movq 0xc898(%rsp), %rax
movq 0xcd20(%rsp), %rcx
movslq 0x38c(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x122f78(%rip), %xmm0   # 0x1d6650
movsd 0x121e30(%rip), %xmm1   # 0x1d5510
callq 0x8610
movaps %xmm0, %xmm2
movsd 0x28(%rsp), %xmm0
movsd 0x11eba2(%rip), %xmm1   # 0x1d2298
mulsd %xmm2, %xmm1
movq 0xc898(%rsp), %rax
movq 0xcd20(%rsp), %rcx
movslq 0x38c(%rcx), %rcx
mulsd (%rax,%rcx,8), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0xc8a8(%rsp)
movsd 0xc8a8(%rsp), %xmm0
movsd 0x13ddb4(%rip), %xmm1   # 0x1f14e8
subsd %xmm1, %xmm0
movsd %xmm0, 0xc8c0(%rsp)
movq 0xcd28(%rsp), %rdi
addq $0x90, %rdi
leaq 0x13d4e0(%rip), %rsi    # 0x1f0c37
callq 0x8410
movq %rax, 0xcd10(%rsp)
cmpq $0x0, 0xcd10(%rsp)
jne 0xb37e3
leaq 0xb090(%rsp), %rdi
movq 0xcd28(%rsp), %rcx
addq $0x90, %rcx
leaq 0x121243(%rip), %rsi    # 0x1d49d0
leaq 0x13e483(%rip), %rdx    # 0x1f1c17
leaq 0x12126a(%rip), %r8     # 0x1d4a05
movb $0x0, %al
callq 0x5b9c0
movq 0xcd18(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0xb090(%rsp), %r8
leaq 0x11e874(%rip), %rsi    # 0x1d2034
leaq 0x13e3e5(%rip), %rdx    # 0x1f1bac
movl $0x251, %ecx            # imm = 0x251
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xcd34(%rsp)
jmp 0xb44f8
jmp 0xb37e5
leaq 0xc910(%rsp), %rdi
movq 0xcd10(%rsp), %rdx
movl $0x3ff, %esi            # imm = 0x3FF
callq 0x8530
cmpq $0x0, %rax
je 0xb3e3d
leaq 0xc910(%rsp), %rax
movq %rax, 0xc908(%rsp)
movq 0xc908(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0xb383f
movq 0xc908(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xc908(%rsp)
jmp 0xb3819
movq 0xc908(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x27, %eax
jle 0xb3e38
cmpl $0x0, 0xc904(%rsp)
jne 0xb3d0f
cmpl $0x0, 0xc900(%rsp)
jne 0xb3d0f
leaq 0xc910(%rsp), %rdi
leaq 0x13e39c(%rip), %rsi    # 0x1f1c1a
leaq 0xc904(%rsp), %rdx
leaq 0xc900(%rsp), %rcx
movb $0x0, %al
callq 0x83b0
cmpl $0x2, %eax
je 0xb3929
leaq 0xa890(%rsp), %rdi
movq 0xcd28(%rsp), %rdx
addq $0x90, %rdx
leaq 0x13e364(%rip), %rsi    # 0x1f1c20
movb $0x0, %al
callq 0x5b9c0
leaq 0xa090(%rsp), %rdi
leaq 0xa890(%rsp), %rcx
leaq 0x11e7a8(%rip), %rsi    # 0x1d2082
leaq 0x13e386(%rip), %rdx    # 0x1f1c67
movb $0x0, %al
callq 0x5b9c0
movq 0xcd18(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0xa090(%rsp), %r8
leaq 0x11e72e(%rip), %rsi    # 0x1d2034
leaq 0x13e29f(%rip), %rdx    # 0x1f1bac
movl $0x267, %ecx            # imm = 0x267
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xcd34(%rsp)
jmp 0xb44f8
movslq 0xc904(%rsp), %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, 0xc8f8(%rsp)
cmpq $0x0, 0xc8f8(%rsp)
jne 0xb39c5
movslq 0xc904(%rsp), %rax
shlq $0x3, %rax
movl %eax, 0xa08c(%rsp)
leaq 0x9880(%rsp), %rdi
movl 0xa08c(%rsp), %ecx
leaq 0x11e68e(%rip), %rsi    # 0x1d2004
leaq 0x13e31c(%rip), %rdx    # 0x1f1c99
movb $0x0, %al
callq 0x5b9c0
movq 0xcd18(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x9880(%rsp), %r8
leaq 0x11e692(%rip), %rsi    # 0x1d2034
leaq 0x13e203(%rip), %rdx    # 0x1f1bac
movl $0x269, %ecx            # imm = 0x269
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xcd34(%rsp)
jmp 0xb44f8
movslq 0xc900(%rsp), %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, 0xc8f0(%rsp)
cmpq $0x0, 0xc8f0(%rsp)
jne 0xb3a61
movslq 0xc900(%rsp), %rax
shlq $0x3, %rax
movl %eax, 0x987c(%rsp)
leaq 0x9070(%rsp), %rdi
movl 0x987c(%rsp), %ecx
leaq 0x11e5f2(%rip), %rsi    # 0x1d2004
leaq 0x13e296(%rip), %rdx    # 0x1f1caf
movb $0x0, %al
callq 0x5b9c0
movq 0xcd18(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x9070(%rsp), %r8
leaq 0x11e5f6(%rip), %rsi    # 0x1d2034
leaq 0x13e167(%rip), %rdx    # 0x1f1bac
movl $0x26a, %ecx            # imm = 0x26A
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xcd34(%rsp)
jmp 0xb44f8
movl 0xc904(%rsp), %eax
imull 0xc900(%rsp), %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, 0xc8e8(%rsp)
cmpq $0x0, 0xc8e8(%rsp)
jne 0xb3b14
movl 0xc904(%rsp), %eax
imull 0xc900(%rsp), %eax
cltq
shlq $0x3, %rax
movl %eax, 0x906c(%rsp)
leaq 0x8860(%rsp), %rdi
movl 0x906c(%rsp), %ecx
leaq 0x11e53f(%rip), %rsi    # 0x1d2004
leaq 0x13e1d6(%rip), %rdx    # 0x1f1ca2
movb $0x0, %al
callq 0x5b9c0
movq 0xcd18(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x8860(%rsp), %r8
leaq 0x11e543(%rip), %rsi    # 0x1d2034
leaq 0x13e0b4(%rip), %rdx    # 0x1f1bac
movl $0x26b, %ecx            # imm = 0x26B
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xcd34(%rsp)
jmp 0xb44f8
movl 0xc904(%rsp), %eax
imull 0xc900(%rsp), %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, 0xc8e0(%rsp)
cmpq $0x0, 0xc8e0(%rsp)
jne 0xb3bc7
movl 0xc904(%rsp), %eax
imull 0xc900(%rsp), %eax
cltq
shlq $0x3, %rax
movl %eax, 0x885c(%rsp)
leaq 0x8050(%rsp), %rdi
movl 0x885c(%rsp), %ecx
leaq 0x11e48c(%rip), %rsi    # 0x1d2004
leaq 0x13e121(%rip), %rdx    # 0x1f1ca0
movb $0x0, %al
callq 0x5b9c0
movq 0xcd18(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x8050(%rsp), %r8
leaq 0x11e490(%rip), %rsi    # 0x1d2034
leaq 0x13e001(%rip), %rdx    # 0x1f1bac
movl $0x26c, %ecx            # imm = 0x26C
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xcd34(%rsp)
jmp 0xb44f8
movslq 0xc904(%rsp), %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, 0xc8d8(%rsp)
cmpq $0x0, 0xc8d8(%rsp)
jne 0xb3c63
movslq 0xc904(%rsp), %rax
shlq $0x3, %rax
movl %eax, 0x804c(%rsp)
leaq 0x7840(%rsp), %rdi
movl 0x804c(%rsp), %ecx
leaq 0x11e3f0(%rip), %rsi    # 0x1d2004
leaq 0x13e08d(%rip), %rdx    # 0x1f1ca8
movb $0x0, %al
callq 0x5b9c0
movq 0xcd18(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x7840(%rsp), %r8
leaq 0x11e3f4(%rip), %rsi    # 0x1d2034
leaq 0x13df65(%rip), %rdx    # 0x1f1bac
movl $0x26d, %ecx            # imm = 0x26D
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xcd34(%rsp)
jmp 0xb44f8
movslq 0xc904(%rsp), %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, 0xc8d0(%rsp)
cmpq $0x0, 0xc8d0(%rsp)
jne 0xb3cff
movslq 0xc904(%rsp), %rax
shlq $0x3, %rax
movl %eax, 0x783c(%rsp)
leaq 0x7030(%rsp), %rdi
movl 0x783c(%rsp), %ecx
leaq 0x11e354(%rip), %rsi    # 0x1d2004
leaq 0x13dfef(%rip), %rdx    # 0x1f1ca6
movb $0x0, %al
callq 0x5b9c0
movq 0xcd18(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x7030(%rsp), %r8
leaq 0x11e358(%rip), %rsi    # 0x1d2034
leaq 0x13dec9(%rip), %rdx    # 0x1f1bac
movl $0x26e, %ecx            # imm = 0x26E
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xcd34(%rsp)
jmp 0xb44f8
movl $0x0, 0xc8cc(%rsp)
jmp 0xb3e36
leaq 0xc910(%rsp), %rdi
movq 0xc8f8(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0xc8cc(%rsp), %eax
cltd
idivl 0xc904(%rsp)
movq 0x18(%rsp), %rax
movslq %edx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0xc8f0(%rsp), %rcx
movl 0xc8cc(%rsp), %eax
cltd
idivl 0xc904(%rsp)
movq 0x20(%rsp), %rdx
cltq
shlq $0x3, %rax
addq %rax, %rcx
movq 0xc8e8(%rsp), %r8
movslq 0xc8cc(%rsp), %rax
shlq $0x3, %rax
addq %rax, %r8
leaq 0x159de9(%rip), %rsi    # 0x20db73
movb $0x0, %al
callq 0x83b0
cmpl $0x3, %eax
je 0xb3e25
leaq 0x6830(%rsp), %rdi
movq 0xcd28(%rsp), %rdx
addq $0x90, %rdx
leaq 0x13defe(%rip), %rsi    # 0x1f1cb6
movb $0x0, %al
callq 0x5b9c0
leaq 0x6030(%rsp), %rdi
leaq 0x6830(%rsp), %rcx
leaq 0x11e2ac(%rip), %rsi    # 0x1d2082
leaq 0x13df1c(%rip), %rdx    # 0x1f1cf9
movb $0x0, %al
callq 0x5b9c0
movq 0xcd18(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x6030(%rsp), %r8
leaq 0x11e232(%rip), %rsi    # 0x1d2034
leaq 0x13dda3(%rip), %rdx    # 0x1f1bac
movl $0x27a, %ecx            # imm = 0x27A
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xcd34(%rsp)
jmp 0xb44f8
movl 0xc8cc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc8cc(%rsp)
jmp 0xb3e38
jmp 0xb37e5
movq 0xcd10(%rsp), %rdi
callq 0x83c0
movq 0xc8f0(%rsp), %rdi
movl 0xc900(%rsp), %esi
movq 0xc8e8(%rsp), %rdx
movl 0xc904(%rsp), %ecx
movq 0xc8e0(%rsp), %r8
movq 0xcd18(%rsp), %rax
addq $0x1064, %rax           # imm = 0x1064
xorl %r9d, %r9d
movq %rax, (%rsp)
callq 0x1cf90
cmpl $0x1, %eax
jne 0xb3efc
leaq 0x5830(%rsp), %rdi
movq 0xcd18(%rsp), %rcx
addq $0x1064, %rcx           # imm = 0x1064
leaq 0x11e52b(%rip), %rsi    # 0x1d23d8
leaq 0x13debd(%rip), %rdx    # 0x1f1d71
movb $0x0, %al
callq 0x5b9c0
movq 0xcd18(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x5830(%rsp), %r8
leaq 0x11e15b(%rip), %rsi    # 0x1d2034
leaq 0x13dccc(%rip), %rdx    # 0x1f1bac
movl $0x28b, %ecx            # imm = 0x28B
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xcd34(%rsp)
jmp 0xb44f8
movq 0xcd20(%rsp), %rax
movsd 0x20(%rax), %xmm0
movq 0xcd20(%rsp), %rax
mulsd 0x8(%rax), %xmm0
movq 0xcd20(%rsp), %rax
mulsd 0x8(%rax), %xmm0
movsd %xmm0, 0xc8b8(%rsp)
movsd 0xc8b8(%rsp), %xmm1
movq 0xc8f8(%rsp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb3fd0
leaq 0x5030(%rsp), %rdi
movsd 0xc8b8(%rsp), %xmm0
leaq 0x13de6a(%rip), %rsi    # 0x1f1dcd
movb $0x1, %al
callq 0x5b9c0
leaq 0x4830(%rsp), %rdi
leaq 0x5030(%rsp), %rcx
leaq 0x11e101(%rip), %rsi    # 0x1d2082
leaq 0x13df3d(%rip), %rdx    # 0x1f1ec5
movb $0x0, %al
callq 0x5b9c0
movq 0xcd18(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x4830(%rsp), %r8
leaq 0x11e087(%rip), %rsi    # 0x1d2034
leaq 0x13dbf8(%rip), %rdx    # 0x1f1bac
movl $0x292, %ecx            # imm = 0x292
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xcd34(%rsp)
jmp 0xb44f8
movsd 0xc8b8(%rsp), %xmm0
movq 0xc8f8(%rsp), %rax
movl 0xc904(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
ucomisd (%rax,%rcx,8), %xmm0
jbe 0xb407e
leaq 0x4030(%rsp), %rdi
movsd 0xc8b8(%rsp), %xmm0
leaq 0x13dec8(%rip), %rsi    # 0x1f1ed9
movb $0x1, %al
callq 0x5b9c0
leaq 0x3830(%rsp), %rdi
leaq 0x4030(%rsp), %rcx
leaq 0x11e053(%rip), %rsi    # 0x1d2082
leaq 0x13df9a(%rip), %rdx    # 0x1f1fd0
movb $0x0, %al
callq 0x5b9c0
movq 0xcd18(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x3830(%rsp), %r8
leaq 0x11dfd9(%rip), %rsi    # 0x1d2034
leaq 0x13db4a(%rip), %rdx    # 0x1f1bac
movl $0x297, %ecx            # imm = 0x297
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xcd34(%rsp)
jmp 0xb44f8
movsd 0xc8c0(%rsp), %xmm1
movq 0xc8f0(%rsp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb4122
leaq 0x3030(%rsp), %rdi
movsd 0xc8c0(%rsp), %xmm0
leaq 0x13df3a(%rip), %rsi    # 0x1f1fef
movb $0x1, %al
callq 0x5b9c0
leaq 0x2830(%rsp), %rdi
leaq 0x3030(%rsp), %rcx
leaq 0x11dfaf(%rip), %rsi    # 0x1d2082
leaq 0x13e014(%rip), %rdx    # 0x1f20ee
movb $0x0, %al
callq 0x5b9c0
movq 0xcd18(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x2830(%rsp), %r8
leaq 0x11df35(%rip), %rsi    # 0x1d2034
leaq 0x13daa6(%rip), %rdx    # 0x1f1bac
movl $0x29c, %ecx            # imm = 0x29C
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xcd34(%rsp)
jmp 0xb44f8
movsd 0xc8c0(%rsp), %xmm0
movq 0xc8f0(%rsp), %rax
movl 0xc900(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
ucomisd (%rax,%rcx,8), %xmm0
jbe 0xb41d0
leaq 0x2030(%rsp), %rdi
movsd 0xc8c0(%rsp), %xmm0
leaq 0x13dfa1(%rip), %rsi    # 0x1f2104
movb $0x1, %al
callq 0x5b9c0
leaq 0x1830(%rsp), %rdi
leaq 0x2030(%rsp), %rcx
leaq 0x11df01(%rip), %rsi    # 0x1d2082
leaq 0x13e07a(%rip), %rdx    # 0x1f2202
movb $0x0, %al
callq 0x5b9c0
movq 0xcd18(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x1830(%rsp), %r8
leaq 0x11de87(%rip), %rsi    # 0x1d2034
leaq 0x13d9f8(%rip), %rdx    # 0x1f1bac
movl $0x2a1, %ecx            # imm = 0x2A1
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xcd34(%rsp)
jmp 0xb44f8
movq 0xc8f0(%rsp), %rdi
movl 0xc900(%rsp), %esi
movq 0xc8e8(%rsp), %rdx
movq 0xc8e0(%rsp), %rcx
movl 0xc904(%rsp), %r8d
movsd 0xc8c0(%rsp), %xmm0
movq 0xc8d8(%rsp), %r11
movl 0xc904(%rsp), %r10d
movq 0xcd18(%rsp), %rax
addq $0x1064, %rax           # imm = 0x1064
leaq 0xc8b4(%rsp), %r9
movq %r11, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x24220
cmpl $0x1, %eax
jne 0xb42ab
leaq 0x1030(%rsp), %rdi
movq 0xcd18(%rsp), %rcx
addq $0x1064, %rcx           # imm = 0x1064
leaq 0x11e17c(%rip), %rsi    # 0x1d23d8
leaq 0x13dfc0(%rip), %rdx    # 0x1f2223
movb $0x0, %al
callq 0x5b9c0
movq 0xcd18(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x1030(%rsp), %r8
leaq 0x11ddac(%rip), %rsi    # 0x1d2034
leaq 0x13d91d(%rip), %rdx    # 0x1f1bac
movl $0x2af, %ecx            # imm = 0x2AF
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xcd34(%rsp)
jmp 0xb44f8
movq 0xc8f8(%rsp), %rdi
movl 0xc904(%rsp), %esi
movq 0xc8d8(%rsp), %rdx
movq 0xc8d0(%rsp), %r8
movq 0xcd18(%rsp), %rax
addq $0x1064, %rax           # imm = 0x1064
movl $0x1, %ecx
xorl %r9d, %r9d
movq %rax, (%rsp)
callq 0x1cf90
cmpl $0x1, %eax
jne 0xb435b
leaq 0x830(%rsp), %rdi
movq 0xcd18(%rsp), %rcx
addq $0x1064, %rcx           # imm = 0x1064
leaq 0x11e0cc(%rip), %rsi    # 0x1d23d8
leaq 0x13df9c(%rip), %rdx    # 0x1f22af
movb $0x0, %al
callq 0x5b9c0
movq 0xcd18(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x830(%rsp), %r8
leaq 0x11dcfc(%rip), %rsi    # 0x1d2034
leaq 0x13d86d(%rip), %rdx    # 0x1f1bac
movl $0x2ba, %ecx            # imm = 0x2BA
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xcd34(%rsp)
jmp 0xb44f8
movq 0xc8f8(%rsp), %rdi
movl 0xc904(%rsp), %esi
movq 0xc8d8(%rsp), %rdx
movq 0xc8d0(%rsp), %rcx
movsd 0xc8b8(%rsp), %xmm0
movq 0xcd18(%rsp), %r10
movq 0xcd18(%rsp), %rax
addq $0x1064, %rax           # imm = 0x1064
movl $0x1, %r8d
leaq 0xc8b4(%rsp), %r9
movq %r10, (%rsp)
movl $0x1, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x24220
cmpl $0x1, %eax
jne 0xb4429
leaq 0x30(%rsp), %rdi
movq 0xcd18(%rsp), %rcx
addq $0x1064, %rcx           # imm = 0x1064
leaq 0x11dffb(%rip), %rsi    # 0x1d23d8
leaq 0x13df32(%rip), %rdx    # 0x1f2316
movb $0x0, %al
callq 0x5b9c0
movq 0xcd18(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x30(%rsp), %r8
leaq 0x11dc2e(%rip), %rsi    # 0x1d2034
leaq 0x13d79f(%rip), %rdx    # 0x1f1bac
movl $0x2c8, %ecx            # imm = 0x2C8
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xcd34(%rsp)
jmp 0xb44f8
movq 0xcd18(%rsp), %rax
movswl 0xe78(%rax), %eax
cmpl $0x1, %eax
jne 0xb4492
movq 0xcd18(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq 0xc898(%rsp), %rax
movq 0xcd20(%rsp), %rcx
movslq 0x42c(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd 0x11ddda(%rip), %xmm2   # 0x1d2248
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd 0x11ddca(%rip), %xmm1   # 0x1d2248
addsd %xmm1, %xmm0
movq 0xcd18(%rsp), %rax
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq 0xc8f8(%rsp), %rdi
callq 0x8420
movq 0xc8f0(%rsp), %rdi
callq 0x8420
movq 0xc8e8(%rsp), %rdi
callq 0x8420
movq 0xc8e0(%rsp), %rdi
callq 0x8420
movq 0xc8d8(%rsp), %rdi
callq 0x8420
movq 0xc8d0(%rsp), %rdi
callq 0x8420
movq 0xc898(%rsp), %rdi
callq 0x8420
movl $0x0, 0xcd34(%rsp)
movl 0xcd34(%rsp), %eax
addq $0xcd38, %rsp           # imm = 0xCD38
retq
nopw (%rax,%rax)