LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../external/HyRec2020/history.c
// Function: Tm_implicit
double Tm_implicit(double z, double xe, double Tm, REC_COSMOPARAMS *cosmo, double dEdtdV, double H, double DLNA) {
  double fsR = cosmo->fsR;
  double meR = cosmo->meR;
  double Tr  = cosmo->T0 *(1.+z);
  double nH  = cosmo->nH0 *cube(1.+z);
  double gamma = fsR*fsR/meR/meR/meR*4.91466895548409e-22*Tr*Tr*Tr*Tr*xe/(1.+xe+cosmo->fHe)/H;
  return (Tm + DLNA*(gamma*Tr + (1.+2.*xe)/3. *dEdtdV /kBoltz /(1.5 *nH*(1.+xe+cosmo->fHe))/H) )/ ( 1.+(2.+gamma)*DLNA );
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movsd %xmm5, 0x48(%rsp)
movsd %xmm4, 0x38(%rsp)
movsd %xmm3, 0x30(%rsp)
movq %rdi, %rbx
movsd %xmm2, 0x40(%rsp)
movsd %xmm1, 0x28(%rsp)
movsd 0x88(%rdi), %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x98(%rdi), %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0xa0(%rdi), %xmm1
movsd %xmm1, 0x18(%rsp)
addsd 0x14177(%rip), %xmm0    # 0xf1260
movsd 0x8(%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x20(%rsp)
callq 0xd6f51
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm2
mulsd %xmm2, %xmm2
movsd 0x18(%rsp), %xmm1
divsd %xmm1, %xmm2
divsd %xmm1, %xmm2
divsd %xmm1, %xmm2
mulsd 0x50669(%rip), %xmm2    # 0x12d790
movsd 0x20(%rsp), %xmm4
mulsd %xmm4, %xmm2
mulsd %xmm4, %xmm2
mulsd %xmm4, %xmm2
mulsd %xmm4, %xmm2
movsd 0x28(%rsp), %xmm6
mulsd %xmm6, %xmm2
movapd %xmm6, %xmm1
movsd 0x1410d(%rip), %xmm3    # 0xf1260
addsd %xmm3, %xmm1
addsd 0x80(%rbx), %xmm1
addsd %xmm6, %xmm6
addsd %xmm3, %xmm6
divsd 0x15511(%rip), %xmm6    # 0xf2680
divsd %xmm1, %xmm2
mulsd 0x30(%rsp), %xmm6
divsd 0x501b7(%rip), %xmm6    # 0x12d338
movsd 0x38(%rsp), %xmm5
divsd %xmm5, %xmm2
mulsd 0x16e25(%rip), %xmm0    # 0xf3fb8
mulsd %xmm1, %xmm0
divsd %xmm0, %xmm6
divsd %xmm5, %xmm6
mulsd %xmm2, %xmm4
addsd %xmm6, %xmm4
movsd 0x48(%rsp), %xmm0
mulsd %xmm0, %xmm4
addsd 0x40(%rsp), %xmm4
addsd 0x14b41(%rip), %xmm2    # 0xf1d00
mulsd %xmm0, %xmm2
addsd %xmm3, %xmm2
divsd %xmm2, %xmm4
movapd %xmm4, %xmm0
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../external/HyRec2020/history.c
// Function: hyrec_integrator
double hyrec_integrator(double deriv, double deriv_prev[2], double z) {
  double result;

  if (MODEL == FULL) result = 1.25 * deriv - 0.25 *deriv_prev[1];
  else result = 23./12.*deriv -16./12. * deriv_prev[0] + 5./12. *deriv_prev[1];

  // update derivatives
  deriv_prev[1] = deriv_prev[0];
  deriv_prev[0] = deriv;

  return result;
}

// Assembly:
movsd (%rdi), %xmm2
movsd 0x8(%rdi), %xmm1
movsd 0x3086a(%rip), %xmm3    # 0x10da50
mulsd %xmm2, %xmm3
movsd 0x505ae(%rip), %xmm4    # 0x12d7a0
mulsd %xmm0, %xmm4
addsd %xmm3, %xmm4
mulsd 0x505a6(%rip), %xmm1    # 0x12d7a8
addsd %xmm4, %xmm1
movsd %xmm2, 0x8(%rdi)
movsd %xmm0, (%rdi)
movapd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../external/HyRec2020/history.c
// Function: hyrec_allocate
void hyrec_allocate(HYREC_DATA *data, double zmax, double zmin) {
  double DLNA;
  if (MODEL == SWIFT) DLNA = DLNA_SWIFT;
  else DLNA = DLNA_HYREC;

  data->error = 0;
  data->error_message=malloc(SIZE_ErrorM);
  sprintf(data->error_message, "\n**** ERROR HAS OCCURRED in HYREC-2 ****\n");

  data->zmax = (zmax > 3000.? zmax : 3000.);
  data->zmin = zmin;

  data->atomic = (HYREC_ATOMIC *) malloc(sizeof(HYREC_ATOMIC));
  allocate_and_read_atomic(data->atomic, &data->error, data->path_to_hyrec, data->error_message);

  data->fit = (FIT_FUNC *) malloc(sizeof(FIT_FUNC));
  allocate_and_read_fit(data->fit, &data->error, data->path_to_hyrec, data->error_message);

  data->cosmo  = (REC_COSMOPARAMS *) malloc(sizeof(REC_COSMOPARAMS));
  data->cosmo->inj_params = (INJ_PARAMS *)  malloc(sizeof(INJ_PARAMS));

  data->Nz = (long int) (log((1.+zmax)/(1.+zmin))/DLNA) + 2;
  data->rad = (RADIATION *) malloc(sizeof(RADIATION));

  // For now assume that radiation field never needed over more than 1 decade in redshift
  // (typically from z ~ 1700 to 800 for recombination history)
  // Will have to adapt for outputting radiation fields at lower z
  if (MODEL == FULL)  allocate_radiation(data->rad, (long int) (log(10.)/DLNA), &data->error, data->error_message);

  data->xe_output = create_1D_array(data->Nz, &data->error, data->error_message);
  data->Tm_output = create_1D_array(data->Nz, &data->error, data->error_message);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
movl $0x0, 0x38(%rdi)
movl $0x800, %edi            # imm = 0x800
callq 0x8460
movq %rax, %r15
movq %rax, 0x48(%rbx)
movups 0x4ec02(%rip), %xmm0    # 0x12e285
movups %xmm0, (%rax)
movups 0x4ec08(%rip), %xmm0    # 0x12e295
movups %xmm0, 0x10(%rax)
movups 0x4ec07(%rip), %xmm0    # 0x12e29f
movups %xmm0, 0x1a(%rax)
movsd (%rsp), %xmm0
maxsd 0x4e0ef(%rip), %xmm0    # 0x12d798
movsd %xmm0, 0x10(%rbx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x18(%rbx)
movl $0x3848, %edi           # imm = 0x3848
callq 0x8460
movq %rax, (%rbx)
movq 0x50(%rbx), %rdx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0xd87f8
movl $0x28, %edi
callq 0x8460
movq %rax, 0x60(%rbx)
movq 0x48(%rbx), %rcx
movq 0x50(%rbx), %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0xd8d3e
movl $0xc0, %edi
callq 0x8460
movq %rax, %r15
movq %rax, 0x8(%rbx)
movl $0x70, %edi
callq 0x8460
movq %rax, 0xb8(%r15)
movsd 0x11b3d(%rip), %xmm0    # 0xf1260
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm2
addsd %xmm0, %xmm2
divsd %xmm2, %xmm1
movapd %xmm1, %xmm0
callq 0x82c0
divsd 0x4dc1d(%rip), %xmm0    # 0x12d368
cvttsd2si %xmm0, %r15
addq $0x2, %r15
movq %r15, 0x20(%rbx)
movl $0x28, %edi
callq 0x8460
movq %rax, 0x58(%rbx)
movq 0x48(%rbx), %rdx
movl %r15d, %edi
movq %r14, %rsi
callq 0xd6f5e
movq %rax, 0x28(%rbx)
movl 0x20(%rbx), %edi
movq 0x48(%rbx), %rdx
movq %r14, %rsi
callq 0xd6f5e
movq %rax, 0x30(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../external/HyRec2020/history.c
// Function: hyrec_free
void hyrec_free(HYREC_DATA *data) {
  free_atomic(data->atomic);
  free(data->cosmo->inj_params);
  free(data->cosmo);
  free(data->atomic);
  free(data->xe_output);
  free(data->Tm_output);
  free(data->error_message);
  if (MODEL == FULL) free_radiation(data->rad);
  free(data->rad);
  free_fit(data->fit);
  free(data->fit);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xd8cf5
movq 0x8(%rbx), %rax
movq 0xb8(%rax), %rdi
callq 0x8410
movq 0x8(%rbx), %rdi
callq 0x8410
movq (%rbx), %rdi
callq 0x8410
movq 0x28(%rbx), %rdi
callq 0x8410
movq 0x30(%rbx), %rdi
callq 0x8410
movq 0x48(%rbx), %rdi
callq 0x8410
movq 0x58(%rbx), %rdi
callq 0x8410
movq 0x60(%rbx), %rdi
callq 0xd8f03
movq 0x60(%rbx), %rdi
popq %rbx
jmp 0x8410
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../external/HyRec2020/history.c
// Function: hyrec_xe
double hyrec_xe(double z, HYREC_DATA *data) {
  if (z > data->zmax) return data->xe_output[0];
  if (z < data->zmin) {
    fprintf(stderr, "\033[1m\033[31m error\033[22;30m in hyrec_xe: requesting x_e at z = %f ", z);
    fprintf(stderr, "lower than zmin\n");
    exit(1);
  }
  double DLNA = data->cosmo->dlna;
  return rec_interp1d(-log(1.+data->zmax), DLNA, data->xe_output, data->Nz, -log(1.+z), &data->error, data->error_message);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movapd %xmm0, %xmm2
movsd 0x10(%rdi), %xmm0
ucomisd %xmm0, %xmm2
jbe 0xdf83d
movq 0x28(%rbx), %rax
movsd (%rax), %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movsd 0x18(%rbx), %xmm1
movsd %xmm2, (%rsp)
ucomisd %xmm2, %xmm1
ja 0xdf8c7
movq 0x8(%rbx), %rax
movsd 0xa8(%rax), %xmm1
movsd %xmm1, 0x8(%rsp)
addsd 0x119f9(%rip), %xmm0    # 0xf1260
callq 0x82c0
xorpd 0x119bc(%rip), %xmm0    # 0xf1230
movapd %xmm0, 0x10(%rsp)
movq 0x28(%rbx), %r14
movl 0x20(%rbx), %ebp
movsd (%rsp), %xmm0
addsd 0x119d2(%rip), %xmm0    # 0xf1260
callq 0x82c0
movapd 0x11995(%rip), %xmm2    # 0xf1230
xorpd %xmm0, %xmm2
movq 0x48(%rbx), %rcx
addq $0x38, %rbx
movaps 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xd727d
movsd (%rsp), %xmm0
callq 0x99f3
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../external/HyRec2020/history.c
// Function: hyrec_Tm
double hyrec_Tm(double z, HYREC_DATA *data) {
  if(z > data->zmax) return data->cosmo->T0*(1.+z);
  if (z < data->zmin) {
    fprintf(stderr, "\033[1m\033[31m error\033[22;30m in hyrec_Tm: requesting x_e at z = %f ", z);
    fprintf(stderr, "lower than zmin\n");
    exit(1);
  }
  double DLNA = data->cosmo->dlna;
  return rec_interp1d(-log(1.+data->zmax), DLNA, data->Tm_output, data->Nz, -log(1.+z), &data->error, data->error_message);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movapd %xmm0, %xmm2
movsd 0x10(%rdi), %xmm0
ucomisd %xmm0, %xmm2
jbe 0xdf909
addsd 0x1196d(%rip), %xmm2    # 0xf1260
movq 0x8(%rbx), %rax
mulsd 0x8(%rax), %xmm2
movapd %xmm2, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movsd 0x18(%rbx), %xmm1
movsd %xmm2, (%rsp)
ucomisd %xmm2, %xmm1
ja 0xdf993
movq 0x8(%rbx), %rax
movsd 0xa8(%rax), %xmm1
movsd %xmm1, 0x8(%rsp)
addsd 0x1192d(%rip), %xmm0    # 0xf1260
callq 0x82c0
xorpd 0x118f0(%rip), %xmm0    # 0xf1230
movapd %xmm0, 0x10(%rsp)
movq 0x30(%rbx), %r14
movl 0x20(%rbx), %ebp
movsd (%rsp), %xmm0
addsd 0x11906(%rip), %xmm0    # 0xf1260
callq 0x82c0
movapd 0x118c9(%rip), %xmm2    # 0xf1230
xorpd %xmm0, %xmm2
movq 0x48(%rbx), %rcx
addq $0x38, %rbx
movaps 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xd727d
movsd (%rsp), %xmm0
callq 0x9a29
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../external/HyRec2020/wrap_hyrec.c
// Function: thermodynamics_hyrec_free
int thermodynamics_hyrec_free(struct thermohyrec* phy){

  /* We just need to free hyrec (without error management) */
  hyrec_free(phy->data);
  free(phy->data);

  return _SUCCESS_;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xdf796
movq (%rbx), %rdi
callq 0x8410
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../external/HyRec2020/energy_injection.c
// Function: beta_pbh
double beta_pbh(double Mpbh, double z, double xe, double Teff) {
  double a, vB, tB;

  a     = 1./(1.+z);
  vB    = 9.09e3 * sqrt((1.+xe)*Teff);    /* Bondi speed in cm/s */
  tB    = 1.33e26 *Mpbh/vB/vB/vB;         /* Bondi timescale in sec*/

  return 5.60e-24 *xe/a/a/a/a *tB;       
}

// Assembly:
subq $0x38, %rsp
movapd %xmm0, %xmm5
movsd 0x11113(%rip), %xmm4    # 0xf1260
addsd %xmm4, %xmm1
movapd %xmm2, %xmm0
addsd %xmm4, %xmm0
divsd %xmm1, %xmm4
mulsd %xmm3, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xe0171
sqrtsd %xmm0, %xmm0
jmp 0xe0198
movapd %xmm2, 0x20(%rsp)
movapd %xmm4, 0x10(%rsp)
movapd %xmm5, (%rsp)
callq 0x82b0
movapd (%rsp), %xmm5
movapd 0x10(%rsp), %xmm4
movapd 0x20(%rsp), %xmm2
mulsd 0x4e310(%rip), %xmm0    # 0x12e4b0
mulsd 0x4e310(%rip), %xmm5    # 0x12e4b8
mulsd 0x4e310(%rip), %xmm2    # 0x12e4c0
divsd %xmm4, %xmm2
unpcklpd %xmm5, %xmm2            # xmm2 = xmm2[0],xmm5[0]
unpcklpd %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0]
divpd %xmm4, %xmm2
divpd %xmm4, %xmm2
divpd %xmm4, %xmm2
movapd %xmm2, %xmm0
unpckhpd %xmm2, %xmm0            # xmm0 = xmm0[1],xmm2[1]
mulsd %xmm2, %xmm0
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../external/HyRec2020/energy_injection.c
// Function: lambda_pbh
double lambda_pbh(double Mpbh, double z, double xe, double Teff) {
  double beta, gamma, lam_ricotti, lam_ad, lam_iso, lam_nodrag;

  beta  = beta_pbh(Mpbh, z, xe, Teff);
  gamma = gamma_pbh(Mpbh, z, xe, Teff);        
  
  lam_ricotti = exp(4.5/(3.+pow(beta, 0.75)))/square(sqrt(1.+beta)+1.);
  /* Fitting formula from Ricotti 2007 for the fully isothermal case */
  lam_ad      = pow(0.6, 1.5)/4.;
  lam_iso     = exp(1.5)/4.; 
  
  lam_nodrag = lam_ad + (lam_iso - lam_ad) * pow(gamma*gamma/(88. + gamma*gamma), 0.22); /* Fitting formula for the no-drag case */
   
  return lam_ricotti *lam_nodrag /lam_iso;
}

// Assembly:
subq $0x68, %rsp
movapd %xmm3, %xmm4
movapd %xmm0, %xmm3
movsd 0x10fb5(%rip), %xmm6    # 0xf1260
addsd %xmm6, %xmm1
movapd %xmm2, %xmm5
addsd %xmm6, %xmm5
divsd %xmm1, %xmm6
mulsd %xmm5, %xmm4
xorps %xmm1, %xmm1
sqrtsd %xmm4, %xmm1
xorpd %xmm7, %xmm7
ucomisd %xmm7, %xmm4
movapd %xmm1, %xmm0
jae 0xe0329
movapd %xmm4, %xmm0
movapd %xmm2, 0x30(%rsp)
movapd %xmm3, 0x20(%rsp)
movsd %xmm4, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm5, 0x48(%rsp)
movapd %xmm6, 0x50(%rsp)
callq 0x82b0
xorpd %xmm7, %xmm7
movapd 0x50(%rsp), %xmm6
movsd 0x48(%rsp), %xmm5
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm4
movapd 0x20(%rsp), %xmm3
movapd 0x30(%rsp), %xmm2
mulsd 0x4e17f(%rip), %xmm0    # 0x12e4b0
mulsd 0x4e17f(%rip), %xmm3    # 0x12e4b8
mulsd 0x4e17f(%rip), %xmm2    # 0x12e4c0
divsd %xmm6, %xmm2
unpcklpd %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0]
unpcklpd %xmm0, %xmm6            # xmm6 = xmm6[0],xmm0[0]
divpd %xmm6, %xmm2
divpd %xmm6, %xmm2
divpd %xmm6, %xmm2
movapd %xmm2, %xmm0
unpckhpd %xmm2, %xmm0            # xmm0 = xmm0[1],xmm2[1]
mulsd %xmm2, %xmm0
movapd %xmm0, 0x10(%rsp)
movsd 0x4e155(%rip), %xmm0    # 0x12e4c8
divsd %xmm5, %xmm0
ucomisd %xmm7, %xmm4
jae 0xe03ae
movsd %xmm0, 0x8(%rsp)
movapd %xmm4, %xmm0
movapd %xmm2, 0x30(%rsp)
movapd %xmm3, 0x20(%rsp)
callq 0x82b0
movapd 0x20(%rsp), %xmm3
movapd 0x30(%rsp), %xmm2
movapd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd 0x4e0fa(%rip), %xmm1    # 0x12e4b0
divsd %xmm1, %xmm3
divsd %xmm1, %xmm3
divsd %xmm1, %xmm3
mulsd %xmm2, %xmm3
mulsd %xmm3, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x15750(%rip), %xmm1    # 0xf5b28
movapd 0x10(%rsp), %xmm0
callq 0x8620
addsd 0x12295(%rip), %xmm0    # 0xf2680
movsd 0x3517d(%rip), %xmm1    # 0x115570
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x8670
movapd 0x10(%rsp), %xmm1
addsd 0x10e52(%rip), %xmm1    # 0xf1260
movsd %xmm0, 0x10(%rsp)
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
movapd %xmm1, %xmm0
jb 0xe0428
sqrtsd %xmm0, %xmm0
jmp 0xe042d
callq 0x82b0
addsd 0x10e2b(%rip), %xmm0    # 0xf1260
callq 0xd6f4c
movsd 0x10(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd %xmm0, %xmm0
movsd 0x4b204(%rip), %xmm1    # 0x12b660
addsd %xmm0, %xmm1
divsd %xmm1, %xmm0
movsd 0x4b1fc(%rip), %xmm1    # 0x12b668
callq 0x8620
mulsd 0x4b1f7(%rip), %xmm0    # 0x12b670
addsd 0x4b1f7(%rip), %xmm0    # 0x12b678
mulsd 0x10(%rsp), %xmm0
divsd 0x4b1f1(%rip), %xmm0    # 0x12b680
addq $0x68, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../external/HyRec2020/energy_injection.c
// Function: TS_over_me_pbh
double TS_over_me_pbh(double Mpbh, double z, double xe, double Teff) {
  double gamma, tau, omega, Y;
  
  gamma = gamma_pbh(Mpbh, z, xe, Teff);

  tau = 1.5/(5. + pow(gamma, 2./3.));     /* T/Teff -> tau *rB/r        for r << rB */
  omega = sqrt(2. - 5*tau);               /* v/vB -> -omega *sqrt(rB/r) for r << rB */

  Y = pow((1.+ xe)/2., 7.) * tau/2. *pow(omega/4.,2./3.)*1836.;

  return Y /pow(1.+Y/0.27, 1./3.); 
}

// Assembly:
subq $0x48, %rsp
movapd %xmm0, %xmm6
movsd 0x10d0c(%rip), %xmm5    # 0xf1260
movapd %xmm2, %xmm0
addsd %xmm5, %xmm0
movsd 0x4df64(%rip), %xmm4    # 0x12e4c8
divsd %xmm0, %xmm4
addsd %xmm5, %xmm1
divsd %xmm1, %xmm5
movsd %xmm0, (%rsp)
mulsd %xmm0, %xmm3
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm3
jb 0xe058c
xorps %xmm0, %xmm0
sqrtsd %xmm3, %xmm0
jmp 0xe05c5
movapd %xmm3, %xmm0
movapd %xmm2, 0x10(%rsp)
movsd %xmm4, 0x8(%rsp)
movapd %xmm5, 0x30(%rsp)
movapd %xmm6, 0x20(%rsp)
callq 0x82b0
movapd 0x20(%rsp), %xmm6
movapd 0x30(%rsp), %xmm5
movsd 0x8(%rsp), %xmm4
movapd 0x10(%rsp), %xmm2
mulsd 0x4dee3(%rip), %xmm0    # 0x12e4b0
mulsd 0x4dee3(%rip), %xmm6    # 0x12e4b8
mulsd 0x4dee3(%rip), %xmm2    # 0x12e4c0
divsd %xmm5, %xmm2
unpcklpd %xmm6, %xmm2            # xmm2 = xmm2[0],xmm6[0]
unpcklpd %xmm0, %xmm5            # xmm5 = xmm5[0],xmm0[0]
divpd %xmm5, %xmm2
divpd %xmm5, %xmm2
divpd %xmm5, %xmm2
movapd %xmm2, %xmm0
unpckhpd %xmm2, %xmm0            # xmm0 = xmm0[1],xmm2[1]
mulsd %xmm2, %xmm0
mulsd %xmm0, %xmm4
movsd 0x13ed3(%rip), %xmm1    # 0xf44e0
movapd %xmm4, %xmm0
callq 0x8620
addsd 0x10c52(%rip), %xmm0    # 0xf1270
movsd 0x13992(%rip), %xmm1    # 0xf3fb8
divsd %xmm0, %xmm1
movsd 0x2d426(%rip), %xmm0    # 0x10da58
movsd %xmm1, 0x10(%rsp)
mulsd %xmm1, %xmm0
addsd 0x116bc(%rip), %xmm0    # 0xf1d00
ucomisd 0x10c0c(%rip), %xmm0    # 0xf1258
jb 0xe0654
sqrtsd %xmm0, %xmm0
jmp 0xe0659
callq 0x82b0
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
mulsd 0x11664(%rip), %xmm0    # 0xf1cd0
movsd 0x120ec(%rip), %xmm1    # 0xf2760
callq 0x8620
mulsd 0x10(%rsp), %xmm0
mulsd 0x11649(%rip), %xmm0    # 0xf1cd0
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x13ed6(%rip), %xmm0    # 0xf4570
movsd 0x13e3e(%rip), %xmm1    # 0xf44e0
callq 0x8620
mulsd (%rsp), %xmm0
mulsd 0x4de24(%rip), %xmm0    # 0x12e4d8
movsd %xmm0, (%rsp)
divsd 0x4afe7(%rip), %xmm0    # 0x12b6a8
addsd 0x10b97(%rip), %xmm0    # 0xf1260
movsd 0x13d67(%rip), %xmm1    # 0xf4438
callq 0x8620
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../external/HyRec2020/energy_injection.c
// Function: eps_over_mdot_pbh
double eps_over_mdot_pbh(double Mpbh, double z, double xe, double Teff) {
  double X, G;

  X = TS_over_me_pbh(Mpbh, z, xe, Teff);
  
  /* Fit to the (e-e + e-p) free-free Gaunt factor */
  if (X < 1) G = 4./M_PI * sqrt(2./M_PI/X) *(1.+ 5.5*pow(X, 1.25));
  else       G = 27./2./M_PI *(log(2.*X*0.56146 + 0.08) + 4./3.);

  return X/1836./137. * G;   /* alpha[fine-struct] * TS/mp * G */
}

// Assembly:
subq $0x18, %rsp
callq 0xe0544
movapd %xmm0, %xmm2
movsd 0x10b63(%rip), %xmm0    # 0xf1260
ucomisd %xmm2, %xmm0
movsd %xmm2, 0x8(%rsp)
jbe 0xe0725
movsd 0x4ddd7(%rip), %xmm0    # 0x12e4e8
divsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xe0754
sqrtsd %xmm0, %xmm0
jmp 0xe075f
movapd %xmm2, %xmm0
addsd %xmm2, %xmm0
mulsd 0x4ddab(%rip), %xmm0    # 0x12e4e0
addsd 0x4af93(%rip), %xmm0    # 0x12b6d0
callq 0x82c0
addsd 0x13d66(%rip), %xmm0    # 0xf44b0
mulsd 0x4af86(%rip), %xmm0    # 0x12b6d8
jmp 0xe0794
callq 0x82b0
movsd 0x8(%rsp), %xmm2
mulsd 0x4dd89(%rip), %xmm0    # 0x12e4f0
movsd %xmm0, 0x10(%rsp)
movsd 0x1154b(%rip), %xmm1    # 0xf1cc0
movapd %xmm2, %xmm0
callq 0x8620
mulsd 0x4af3a(%rip), %xmm0    # 0x12b6c0
addsd 0x10ad2(%rip), %xmm0    # 0xf1260
mulsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
divsd 0x4dd36(%rip), %xmm1    # 0x12e4d8
divsd 0x4dd4e(%rip), %xmm1    # 0x12e4f8
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../external/HyRec2020/energy_injection.c
// Function: L_pbh
double L_pbh(double Mpbh, double z, double xe, double Teff) {
  double Mdot, mdot, eff;

  Mdot = Mdot_pbh(Mpbh, z, xe, Teff); 
  mdot = Mdot / (1.4e17 * Mpbh);        /* Mdot c^2 / L_Eddington */ 
  eff  = mdot *eps_over_mdot_pbh(Mpbh, z, xe, Teff); 
  
  return eff * Mdot * 9e20;  /* L = epsilon Mdot c^2 */  
}

// Assembly:
subq $0x38, %rsp
movsd %xmm3, 0x30(%rsp)
movsd %xmm2, 0x28(%rsp)
movsd %xmm1, 0x20(%rsp)
movsd %xmm0, 0x8(%rsp)
callq 0xe0494
movsd %xmm0, 0x18(%rsp)
movsd 0x4dd1a(%rip), %xmm1    # 0x12e500
movsd 0x8(%rsp), %xmm2
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movapd %xmm2, %xmm0
movsd 0x20(%rsp), %xmm1
movsd 0x28(%rsp), %xmm2
movsd 0x30(%rsp), %xmm3
callq 0xe06e8
mulsd 0x10(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
mulsd 0x4dcdf(%rip), %xmm0    # 0x12e508
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../external/HyRec2020/energy_injection.c
// Function: L_pbh_av
double L_pbh_av(double Mpbh, double z, double xe, double Tgas) {
  double vbc_rms, vbc_max, vbc, P_vbc, num, denom, x, Teff;
  int i, Nvbc;

  Nvbc = 50; // More than enough at the level of precision we use
  
  vbc_rms = vbc_rms_func(z);
 
  vbc_max = 5.*vbc_rms;

  num = denom = 0.;
  for (i = 0; i < Nvbc; i++) {
    vbc    = i*vbc_max/(Nvbc-1.);
    x      = vbc/vbc_rms;
    denom += P_vbc = x*x* exp(-1.5*x*x);

    Teff = Tgas + 121e-10 *vbc*vbc/(1.+xe); 
    
    num += L_pbh(Mpbh, z, xe, Teff) * P_vbc;
  }

  return num/denom;
}

// Assembly:
pushq %rbx
subq $0x80, %rsp
movsd %xmm3, 0x40(%rsp)
movsd %xmm0, 0x28(%rsp)
movsd 0x109e0(%rip), %xmm5    # 0xf1260
movapd %xmm1, %xmm0
addsd %xmm5, %xmm0
movsd 0x4dc80(%rip), %xmm4    # 0x12e510
mulsd %xmm4, %xmm0
movsd 0x1534c(%rip), %xmm3    # 0xf5be8
divsd %xmm3, %xmm0
movsd %xmm1, 0x30(%rsp)
cmpltsd %xmm3, %xmm1
andpd %xmm1, %xmm0
andnpd %xmm4, %xmm1
orpd %xmm0, %xmm1
movapd %xmm1, 0x60(%rsp)
mulsd 0x109ab(%rip), %xmm1    # 0xf1270
movapd %xmm1, 0x50(%rsp)
movsd %xmm2, 0x38(%rsp)
addsd %xmm5, %xmm2
movsd %xmm2, 0x20(%rsp)
xorpd %xmm0, %xmm0
movl $0x32, %ebx
xorpd %xmm2, %xmm2
xorpd %xmm1, %xmm1
movsd %xmm1, (%rsp)
movsd %xmm2, 0x48(%rsp)
movsd %xmm0, 0x8(%rsp)
movapd 0x50(%rsp), %xmm1
mulsd %xmm2, %xmm1
divsd 0x4dc09(%rip), %xmm1    # 0x12e518
movapd %xmm1, 0x70(%rsp)
divsd 0x60(%rsp), %xmm1
movapd %xmm1, %xmm0
mulsd 0x13f19(%rip), %xmm0    # 0xf4840
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm1
movapd %xmm1, 0x10(%rsp)
callq 0x8670
movapd %xmm0, %xmm1
mulsd 0x10(%rsp), %xmm1
movsd %xmm1, 0x10(%rsp)
movsd (%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movapd 0x70(%rsp), %xmm0
movapd %xmm0, %xmm3
mulsd 0x4dbb6(%rip), %xmm3    # 0x12e520
mulsd %xmm0, %xmm3
divsd 0x20(%rsp), %xmm3
addsd 0x40(%rsp), %xmm3
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movsd 0x38(%rsp), %xmm2
callq 0xe07b7
movsd 0x48(%rsp), %xmm2
mulsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
addsd 0x108a5(%rip), %xmm2    # 0xf1260
decl %ebx
jne 0xe08f1
divsd (%rsp), %xmm0
addq $0x80, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../external/HyRec2020/energy_injection.c
// Function: dEdtdV_pbh
double dEdtdV_pbh(double fpbh, double Mpbh, double z, double xe, double Tgas) { 
  double xe_used = (xe < 1.? xe : 1.); /* Since we are not accounting for Helium */
  if (fpbh > 0.) {
    return 6.12e-52/Mpbh * cube(1.+z) * fpbh *L_pbh_av(Mpbh, z, xe_used, Tgas);
  }
  else return 0.;
}

// Assembly:
movapd %xmm0, %xmm5
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm5
jbe 0xe0a65
subq $0x38, %rsp
movsd 0x10871(%rip), %xmm0    # 0xf1260
minsd %xmm0, %xmm3
movsd %xmm3, 0x28(%rsp)
movsd 0x4db27(%rip), %xmm3    # 0x12e528
divsd %xmm1, %xmm3
movsd %xmm3, 0x8(%rsp)
addsd %xmm2, %xmm0
movsd %xmm4, 0x30(%rsp)
movsd %xmm2, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd %xmm5, 0x10(%rsp)
callq 0xd6f51
mulsd 0x8(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movsd 0x28(%rsp), %xmm2
movsd 0x30(%rsp), %xmm3
callq 0xe0864
mulsd 0x8(%rsp), %xmm0
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../external/HyRec2020/energy_injection.c
// Function: update_dEdtdV_dep
void update_dEdtdV_dep(double z_out, double dlna, double xe, double Tgas,
		       double nH, double H, INJ_PARAMS *params, double *dEdtdV_dep) {

  double inj  = dEdtdV_inj(z_out, xe, Tgas, params);
  
  if (params->on_the_spot == 1) *dEdtdV_dep = inj;

  // Else put in your favorite recipe to translate from injection to deposition
  // Here I assume injected photon spectrum Compton cools at rate dE/dt = - 0.1 n_h c sigma_T E
  // This is valid for E_photon ~ MeV or so.
  
  else { // c sigma_T = 2e-14 (cgs)
    *dEdtdV_dep = (*dEdtdV_dep *exp(-7.*dlna) + 2e-15* dlna*nH/H *inj)
                 /(1.+ 2e-15 *dlna*nH/H);                              
  }       
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd %xmm5, 0x20(%rsp)
movsd %xmm4, 0x18(%rsp)
movsd %xmm3, 0x8(%rsp)
movsd %xmm2, (%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x28(%rsp)
callq 0xdff14
movsd %xmm0, 0x30(%rsp)
movsd 0x48(%r14), %xmm1
movsd 0x50(%r14), %xmm0
movsd 0x28(%rsp), %xmm2
movsd (%rsp), %xmm3
movsd 0x8(%rsp), %xmm4
callq 0xe09d1
addsd 0x30(%rsp), %xmm0
cmpl $0x1, 0x58(%r14)
je 0xe0b7b
movsd (%rbx), %xmm1
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movsd 0x13999(%rip), %xmm0    # 0xf44d0
mulsd 0x10(%rsp), %xmm0
callq 0x8670
movsd 0x10(%rsp), %xmm1
mulsd 0x4d9e0(%rip), %xmm1    # 0x12e530
mulsd 0x18(%rsp), %xmm1
divsd 0x20(%rsp), %xmm1
movsd (%rsp), %xmm2
mulsd %xmm1, %xmm2
mulsd 0x8(%rsp), %xmm0
addsd %xmm2, %xmm0
addsd 0x106e9(%rip), %xmm1    # 0xf1260
divsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../external/HMcode/hmcode.c
// Function: hmcode_workspace_free
int hmcode_workspace_free(
                          struct fourier *pfo,
                          struct hmcode_workspace *phw
                          ) {

  int index_pk;

  free(phw->rtab);
  free(phw->stab);
  free(phw->ddstab);

  free(phw->growtable);
  free(phw->ztable);
  free(phw->tautable);

  for (index_pk=0; index_pk<pfo->pk_size; index_pk++){
    free(phw->sigma_8[index_pk]);
    free(phw->sigma_disp[index_pk]);
    free(phw->sigma_disp_100[index_pk]);
    free(phw->sigma_prime[index_pk]);
  }

  free(phw->sigma_8);
  free(phw->sigma_disp);
  free(phw->sigma_disp_100);
  free(phw->sigma_prime);

  free(phw->pk_wiggle);
  free(phw->ddpk_wiggle);
  free(phw->lnk_wiggle);

  return _SUCCESS_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
callq 0x8410
movq 0x8(%rbx), %rdi
callq 0x8410
movq 0x10(%rbx), %rdi
callq 0x8410
movq 0x18(%rbx), %rdi
callq 0x8410
movq 0x20(%rbx), %rdi
callq 0x8410
movq 0x28(%rbx), %rdi
callq 0x8410
cmpl $0x0, 0x64(%r14)
jle 0xe58f2
xorl %r15d, %r15d
movq 0x30(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x8410
movq 0x38(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x8410
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x8410
movq 0x48(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x8410
incq %r15
movslq 0x64(%r14), %rax
cmpq %rax, %r15
jl 0xe58b2
movq 0x30(%rbx), %rdi
callq 0x8410
movq 0x38(%rbx), %rdi
callq 0x8410
movq 0x40(%rbx), %rdi
callq 0x8410
movq 0x48(%rbx), %rdi
callq 0x8410
movq 0x60(%rbx), %rdi
callq 0x8410
movq 0x68(%rbx), %rdi
callq 0x8410
movq 0x58(%rbx), %rdi
callq 0x8410
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../external/HMcode/hmcode.c
// Function: hmcode_noradiation_growth_free
int hmcode_noradiation_growth_free(
                                   struct fourier *pfo,
                                   struct hmcode_workspace *phw
                                   ){

  struct hmcode_growth *phg;

  phg = phw->phg;
  free(phg->a_table);
  free(phg->growth_table);
  free(phg->normgrowth_table);
  free(phg->ddnormgrowth_table);
  free(phg->dda_table);
  free(phg->pvecnorad);
  free(phg);

  return _SUCCESS_;
}

// Assembly:
pushq %rbx
movq 0x70(%rsi), %rbx
movq (%rbx), %rdi
callq 0x8410
movq 0x10(%rbx), %rdi
callq 0x8410
movq 0x18(%rbx), %rdi
callq 0x8410
movq 0x20(%rbx), %rdi
callq 0x8410
movq 0x28(%rbx), %rdi
callq 0x8410
movq 0xe8(%rbx), %rdi
callq 0x8410
movq %rbx, %rdi
callq 0x8410
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../external/HMcode/hmcode.c
// Function: hmcode_growth_derivs
int hmcode_growth_derivs(
                         double a,
                         double *y,
                         double *dy,
                         void *parameters_and_workspace,
                         ErrorMsg error_message
                         ){

  struct hmcode_growth *phg;
  double Om_norad;
  double AH_norad, H2_norad;

  //phg = parameters_and_workspace;
  phg = (struct hmcode_growth *)parameters_and_workspace;

  class_call(hmcode_norad(phg, a),
             phg->error_message,
             phg->error_message);

  H2_norad = phg->pvecnorad[phg->index_norad_H2];
  AH_norad = phg->pvecnorad[phg->index_norad_AH];
  Om_norad = phg->pvecnorad[phg->index_norad_Om];

  dy[phg->index_fg_g] = y[phg->index_fg_dg];
  dy[phg->index_fg_dg] = 1.5*Om_norad*y[phg->index_fg_g]/(a*a) - (2.+AH_norad/H2_norad)*y[phg->index_fg_dg]/a;

  return _SUCCESS_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movsd %xmm0, 0x8(%rsp)
movq %rdx, %rdi
callq 0xe8a0b
movq 0xe8(%r14), %rax
movslq 0xd4(%r14), %rcx
movslq 0xd8(%r14), %rdx
movsd (%rax,%rdx,8), %xmm0
movslq 0xdc(%r14), %rdx
movsd (%rax,%rdx,8), %xmm1
movslq 0xcc(%r14), %rdx
movsd (%r15,%rdx,8), %xmm2
movslq 0xc8(%r14), %rsi
divsd (%rax,%rcx,8), %xmm0
movsd %xmm2, (%rbx,%rsi,8)
mulsd 0xb2d6(%rip), %xmm1     # 0xf3fb8
mulsd (%r15,%rsi,8), %xmm1
movsd 0x8(%rsp), %xmm3
movapd %xmm3, %xmm2
mulsd %xmm3, %xmm2
divsd %xmm2, %xmm1
addsd 0x8ffe(%rip), %xmm0     # 0xf1d00
mulsd (%r15,%rdx,8), %xmm0
divsd %xmm3, %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rdx,8)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../external/HMcode/hmcode.c
// Function: hmcode_growth_sources
int hmcode_growth_sources(
                          double a,
                          double *y,
                          double *dy,
                          int index_a,
                          void *parameters_and_workspace,
                          ErrorMsg error_message
                          ) {

  struct hmcode_growth *phg;

  //phg = parameters_and_workspace;
  phg = (struct hmcode_growth *)parameters_and_workspace;

  phg->a_table[index_a] = a;
  phg->growth_table[index_a*phg->gt_size+phg->index_gt_g] = y[phg->index_fg_g]/a; //It is actually g(a)/a
  phg->normgrowth_table[index_a] = y[phg->index_fg_g];

  class_call(hmcode_norad(phg, a),
             phg->error_message,
             phg->error_message);

  phg->growth_table[index_a*phg->gt_size+phg->index_gt_Omnorad] = phg->pvecnorad[phg->index_norad_Om];

  return _SUCCESS_;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq (%rcx), %rax
movslq %edx, %r14
movsd %xmm0, (%rax,%r14,8)
movslq 0xc8(%rcx), %rax
movsd (%rdi,%rax,8), %xmm1
divsd %xmm0, %xmm1
movq 0x10(%rcx), %rcx
movslq 0x30(%rbx), %rdx
imulq %r14, %rdx
movslq 0x34(%rbx), %rsi
addq %rdx, %rsi
movsd %xmm1, (%rcx,%rsi,8)
movsd (%rdi,%rax,8), %xmm1
movq 0x18(%rbx), %rax
movsd %xmm1, (%rax,%r14,8)
movq %rbx, %rdi
callq 0xe8a0b
movq 0x10(%rbx), %rax
movq 0xe8(%rbx), %rcx
movslq 0xdc(%rbx), %rdx
movsd (%rcx,%rdx,8), %xmm0
movslq 0x30(%rbx), %rcx
imulq %r14, %rcx
movslq 0x44(%rbx), %rdx
addq %rcx, %rdx
movsd %xmm0, (%rax,%rdx,8)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/output.c
// Function: output_one_line_of_pk
int output_one_line_of_pk(
                          FILE * pkfile,
                          double one_k,
                          double one_pk
                          ) {

  fprintf(pkfile," ");
  class_fprintf_double(pkfile,one_k,_TRUE_);
  class_fprintf_double(pkfile,one_pk,_TRUE_);
  fprintf(pkfile,"\n");

  return _SUCCESS_;

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movl $0x20, %edi
movq %rbx, %rsi
callq 0x8440
leaq 0x433a2(%rip), %r14     # 0x1338ca
movq %rbx, %rdi
movq %r14, %rsi
movl $0x18, %edx
movl $0xc, %ecx
movsd 0x8(%rsp), %xmm0
movb $0x1, %al
callq 0x84e0
movq %rbx, %rdi
movq %r14, %rsi
movl $0x18, %edx
movl $0xc, %ecx
movsd 0x10(%rsp), %xmm0
movb $0x1, %al
callq 0x84e0
movl $0xa, %edi
movq %rbx, %rsi
callq 0x8440
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/output.c
// Function: output_print_data
int output_print_data(FILE *out,
                      char titles[_MAXTITLESTRINGLENGTH_],
                      double *dataptr,
                      int size_dataptr){
  int colnum=1, number_of_titles;
  int index_title, index_tau;
  char thetitle[_MAXTITLESTRINGLENGTH_];
  char *pch;

  /** Summary*/

  /** - First we print the titles */
  fprintf(out,"#");

  strcpy(thetitle,titles);
  pch = strtok(thetitle,_DELIMITER_);
  while (pch != NULL){
    class_fprintf_columntitle(out, pch, _TRUE_, colnum);
    pch = strtok(NULL,_DELIMITER_);
  }
  fprintf(out,"\n");

  /** - Then we print the data */
  number_of_titles = colnum-1;
  if (number_of_titles>0){
    for (index_tau=0; index_tau<size_dataptr/number_of_titles; index_tau++){
      fprintf(out," ");
      for (index_title=0; index_title<number_of_titles; index_title++){
        class_fprintf_double(out, dataptr[index_tau*number_of_titles+index_title], _TRUE_);
      }
      fprintf(out,"\n");
    }
  }
  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f68, %rsp           # imm = 0x1F68
movl %ecx, 0x8(%rsp)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x23, %edi
movq %r14, %rsi
callq 0x8440
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x8350
leaq 0x43300(%rip), %rsi     # 0x1338bb
movq %r12, %rdi
callq 0x8530
testq %rax, %rax
je 0xf063c
movq %rax, %rbp
movl $0x1, %r15d
leaq 0x432e3(%rip), %r13     # 0x1338bb
movq %rbp, %rdi
callq 0x8180
movl $0x15, %edx
subl %eax, %edx
cmpl $0x3, %edx
movl $0x3, %eax
cmovgel %eax, %edx
testl %edx, %edx
movl $0x0, %eax
cmovlel %eax, %edx
leal 0x1(%r15), %r12d
movq %rbp, (%rsp)
movq %r14, %rdi
leaq 0x432af(%rip), %rsi     # 0x1338bd
leaq 0x432a7(%rip), %rcx     # 0x1338bc
movl %r15d, %r8d
movl $0x12, %r9d
xorl %eax, %eax
callq 0x84e0
xorl %edi, %edi
movq %r13, %rsi
callq 0x8530
movq %rax, %rbp
movl %r12d, %r15d
testq %rax, %rax
jne 0xf05d8
jmp 0xf0642
movl $0x1, %r12d
movl $0xa, %edi
movq %r14, %rsi
callq 0x8440
cmpl $0x2, %r12d
jb 0xf06ed
leal -0x1(%r12), %ecx
movl 0x8(%rsp), %eax
cltd
idivl %ecx
testl %eax, %eax
jle 0xf06ed
movslq %ecx, %rdx
movl %eax, %eax
movq %rax, 0x10(%rsp)
movl %ecx, %ebp
shlq $0x3, %rdx
movq %rdx, 0x8(%rsp)
xorl %r13d, %r13d
leaq 0x4323e(%rip), %r15     # 0x1338ca
movq %r12, 0x18(%rsp)
movl $0x20, %edi
movq %r14, %rsi
callq 0x8440
cmpl $0x2, %r12d
jl 0xf06cc
xorl %r12d, %r12d
movsd (%rbx,%r12,8), %xmm0
movq %r14, %rdi
movq %r15, %rsi
movl $0x18, %edx
movl $0xc, %ecx
movb $0x1, %al
callq 0x84e0
incq %r12
cmpq %r12, %rbp
jne 0xf06a7
movl $0xa, %edi
movq %r14, %rsi
callq 0x8440
incq %r13
addq 0x8(%rsp), %rbx
cmpq 0x10(%rsp), %r13
movq 0x18(%rsp), %r12
jne 0xf0691
xorl %eax, %eax
addq $0x1f68, %rsp           # imm = 0x1F68
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/OhYee[P]computer_application_programming_experiment/utils/radix_tree/test/test_radix_tree.c
// Function: main
int main() {
    mp_init(1 << 30, mp_exit);
    boolean pass = T;

    radix_tree *rt = rt_init(2);
    rt_print(rt);
    rt_add(rt, "Oh", 2); // 01001111 01101000
    rt_print(rt);
    rt_add(rt, "My", 2); // 01001101 01111001
    rt_print(rt);
    rt_add(rt, "God", 3); // 01000111 01101111 01100100
    rt_print(rt);
    rt_add(rt, "My", 2); // 01001101 01111001
    rt_print(rt);

    if (rt_exist(rt, "Va", 2) == T) {
        print_err("want F got T\n");
        pass = F;
    }
    printf("==\n");

    if (rt_exist(rt, "God", 3) == F) {
        print_err("want T got F\n");
        pass = F;
    }

    /*

    1111001000010110
    1011001010011110
    111000101111011000100110
    1011001010011110



    */

    if (pass) {
        print_ok("All testcases passed\n");
    } else {
        print_err("Some errors!\n");
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leaq -0xbeb(%rip), %rsi      # 0x127c
movl $0x40000000, %edi       # imm = 0x40000000
callq 0x1287
leaq 0x31c(%rip), %rax       # 0x2194
movl (%rax), %ebp
movl $0x2, %edi
callq 0x1564
movq %rax, %rbx
movq %rax, %rdi
callq 0x15e9
leaq 0x34e(%rip), %rsi       # 0x21e4
movq %rbx, %rdi
movl $0x2, %edx
callq 0x1590
movq %rbx, %rdi
callq 0x15e9
leaq 0x335(%rip), %r14       # 0x21e7
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %edx
callq 0x1590
movq %rbx, %rdi
callq 0x15e9
leaq 0x319(%rip), %rsi       # 0x21ea
movq %rbx, %rdi
movl $0x3, %edx
callq 0x1590
movq %rbx, %rdi
callq 0x15e9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %edx
callq 0x1590
movq %rbx, %rdi
callq 0x15e9
leaq 0x2e9(%rip), %rsi       # 0x21ee
movq %rbx, %rdi
movl $0x2, %edx
callq 0x15c4
cmpl %ebp, %eax
jne 0x1f2d
leaq 0x2d4(%rip), %rdi       # 0x21f1
xorl %eax, %eax
callq 0x10c0
leaq 0x26d(%rip), %rax       # 0x2198
movl (%rax), %ebp
leaq 0x2fd(%rip), %rdi       # 0x2231
callq 0x1040
leaq 0x2aa(%rip), %rsi       # 0x21ea
movq %rbx, %rdi
movl $0x3, %edx
callq 0x15c4
leaq 0x244(%rip), %rcx       # 0x2198
movl (%rcx), %ebx
cmpl %ebx, %eax
jne 0x1f6a
leaq 0x29e(%rip), %rdi       # 0x21ff
xorl %eax, %eax
callq 0x10c0
movl %ebx, %ebp
testl %ebp, %ebp
je 0x1f7e
leaq 0x298(%rip), %rdi       # 0x220d
xorl %eax, %eax
callq 0x1a4d
jmp 0x1f8c
leaq 0x29e(%rip), %rdi       # 0x2223
xorl %eax, %eax
callq 0x10c0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Mikejmoffitt[P]romtools/binpad/binpad.c
// Function: main
int main(int argc, char **argv)
{
	if (argc < 2)
	{
		printf("Pads a file to the next highest power of two.\n"
		        "Specification of a minimum size, in bytes, is optional.\n");
		printf("Usage: %s unpadded_file [min_bytes]\n", argv[0]);
		return 0;
	}

	FILE *f = fopen(argv[1], "r+");
	if (!f)
	{
		fprintf(stderr, "Couldn't open \"%s\"\n", argv[1]);
		return -1;
	}

	const size_t min_bytes = (argc >= 3) ? strtoul(argv[2], NULL, 0) : 0;

	// 0xFF is the value that Flash and EPROM memory assume in the erased state,
	// so padding with it will result in a faster burn as it can be skipped.
	const uint8_t pad_value = 0xFF;

	fseek(f, 0, SEEK_END);
	const size_t original_size = ftell(f);
	printf("Original filesize is $%X (%lu) bytes.\n",
	       (int)original_size, original_size);
	size_t next_size = 1;
	do
	{
		next_size = next_size * 2;
	} while (next_size < original_size);

	if (next_size < min_bytes) next_size = min_bytes;

	printf("New target size of $%X (%lu) bytes.\n",
	       (int)next_size, next_size);

	for (size_t i = 0; i < next_size - original_size; i++)
	{
		fputc(pad_value, f);
	}

	fclose(f);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
cmpl $0x1, %edi
jg 0x120f
leaq 0xe9a(%rip), %rdi       # 0x208c
callq 0x1030
movq (%r14), %rsi
leaq 0xe03(%rip), %rdi       # 0x2004
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x1050
jmp 0x12be
movl %edi, %ebp
movq 0x8(%r14), %rdi
leaq 0xe0d(%rip), %rsi       # 0x2029
callq 0x10a0
testq %rax, %rax
je 0x12cb
movq %rax, %rbx
cmpl $0x2, %ebp
jne 0x1237
xorl %r14d, %r14d
jmp 0x1247
movq 0x10(%r14), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10b0
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x1090
movq %rbx, %rdi
callq 0x1080
movq %rax, %r15
leaq 0xdd8(%rip), %rdi       # 0x2040
movl %r15d, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1050
movl $0x1, %eax
addq %rax, %rax
cmpq %r15, %rax
jb 0x127a
cmpq %r14, %rax
cmovaq %rax, %r14
leaq 0xdd7(%rip), %rdi       # 0x2067
xorl %ebp, %ebp
movl %r14d, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1050
subq %r15, %r14
je 0x12b6
movl $0xff, %edi
movq %rbx, %rsi
callq 0x1060
decq %r14
jne 0x12a4
movq %rbx, %rdi
callq 0x1040
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq $0x8, %r14
movq %r14, %rdi
callq 0x10d0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x12be
// File: /workspace/github_c_makefile_star2_O1/Keith-S-Thompson[P]kst-time-utils/nanosleep-until.c
// Function: main
int main(int argc, char **argv) {
    if (argc < 2) {
        usage_error(argv[0]);
    }
    const int seconds = atoi(argv[1]);
    if (seconds <= 0) {
        usage_error(argv[0]);
    }

    struct timespec ts;
    int result = clock_gettime(CLOCK_REALTIME, &ts);
    if (result != 0) {
        perror("clock_gettime");
        exit(EXIT_FAILURE);
    }

    time_t sleep_sec = seconds - ts.tv_sec % seconds - 1;
    long sleep_nsec = ONE_BILLION - ts.tv_nsec;
    if (sleep_nsec == ONE_BILLION) {
        sleep_nsec = 0;
        sleep_sec ++;
    }

    const struct timespec how_long = {
        .tv_sec  = sleep_sec,
        .tv_nsec = sleep_nsec
    };

    nanosleep(&how_long, NULL);

    if (argc > 2) {
        execvp(argv[2], argv+2);
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
cmpl $0x1, %edi
jle 0x128a
movl %edi, %ebp
movq 0x8(%rbx), %rdi
callq 0x1080
testl %eax, %eax
jle 0x1292
movl %eax, %r14d
movq %rsp, %rsi
xorl %edi, %edi
callq 0x1030
testl %eax, %eax
jne 0x129a
movl %r14d, %ecx
movq (%rsp), %rax
movq 0x8(%rsp), %rsi
cqto
idivq %rcx
subq %rdx, %rcx
movl $0x3b9aca00, %eax       # imm = 0x3B9ACA00
subq %rsi, %rax
xorl %edx, %edx
testq %rsi, %rsi
setne %dl
cmoveq %rsi, %rax
subq %rdx, %rcx
leaq 0x10(%rsp), %rdi
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
xorl %esi, %esi
callq 0x1040
cmpl $0x2, %ebp
je 0x127f
movq 0x10(%rbx), %rdi
addq $0x10, %rbx
movq %rbx, %rsi
callq 0x1070
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x10e9
movq %rbx, %rdi
callq 0x10c5
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ctags.c
// Function: examine_symbol_list
static inline void examine_symbol_list(struct symbol_list *list)
{
	struct symbol *sym;

	if (!list)
		return;
	FOR_EACH_PTR(list, sym) {
		examine_namespace(sym);
	} END_FOR_EACH_PTR(sym);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xeda9
movq %rdi, %rbx
leaq 0x3236d(%rip), %r13     # 0x41004
movq %rdi, %rbp
movzwl (%rbp), %eax
testb %al, %al
jle 0xed9c
xorl %r14d, %r14d
movq 0x18(%rbp,%r14,8), %r15
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0xecc1
testq %r15, %r15
je 0xed89
testb $0x1, 0xd1(%r15)
jne 0xed89
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0xece2
testb $0x2, 0x11(%rdi)
jne 0xed89
movl (%r15), %r12d
shrl $0x8, %r12d
andl $0x1ff, %r12d           # imm = 0x1FF
cmpl $0xf, %r12d
jg 0xed18
leal -0x1(%r12), %eax
cmpl $0x7, %eax
ja 0xedb8
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movb $0x74, 0xd0(%r15)
jmp 0xed2f
cmpl $0x7f, %r12d
jg 0xed39
cmpl $0x10, %r12d
je 0xed2f
cmpl $0x40, %r12d
je 0xed89
jmp 0xedb8
movq %r15, %rdi
callq 0xee68
jmp 0xed5f
cmpl $0x80, %r12d
je 0xed4d
cmpl $0x100, %r12d           # imm = 0x100
je 0xed89
jmp 0xedb8
movb $0x64, 0xd0(%r15)
jmp 0xed5f
movb $0x6c, 0xd0(%r15)
cmpq $0x0, 0x18(%r15)
je 0xed89
movb 0xd1(%r15), %al
testb $0x1, %al
jne 0xed89
orb $0x1, %al
movb %al, 0xd1(%r15)
leaq 0x58727(%rip), %rdi     # 0x674a8
movq %r15, %rsi
callq 0x19e7f
incq %r14
movl (%rbp), %eax
movsbq %al, %rcx
cmpq %rcx, %r14
jl 0xeca9
movq 0x10(%rbp), %rbp
cmpq %rbx, %rbp
jne 0xec9a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1f465
movzbl (%r15), %ecx
leaq 0x32284(%rip), %rdi     # 0x4104c
movl %r12d, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0xf45e
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ctags.c
// Function: cmp_sym
static int cmp_sym(const void *m, const void *n)
{
	const struct ident *a = ((const struct symbol *)m)->ident;
	const struct ident *b = ((const struct symbol *)n)->ident;
	int ret = strncmp(a->name, b->name, MAX(a->len, b->len));
	if (!ret) {
		const struct position a_pos = ((const struct symbol *)m)->pos;
		const struct position b_pos = ((const struct symbol *)n)->pos;

		ret = strcmp(stream_name(a_pos.stream),
		             stream_name(b_pos.stream));
		if (!ret)
			return a_pos.line < b_pos.line;
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq 0x18(%rsi), %rsi
movl 0x10(%rdi), %eax
addq $0x12, %rdi
movl 0x10(%rsi), %ecx
addq $0x12, %rsi
cmpb %cl, %al
cmoval %eax, %ecx
movzbl %cl, %edx
callq 0xe080
testl %eax, %eax
jne 0xee5d
movq 0x4(%r14), %r14
movq 0x4(%rbx), %r15
movl %r14d, %edi
shrl $0x6, %edi
movl $0x3fff, %ebp           # imm = 0x3FFF
andl %ebp, %edi
callq 0x1f3c4
movq %rax, %rbx
movl %r15d, %edi
shrl $0x6, %edi
andl %ebp, %edi
callq 0x1f3c4
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe1d0
testl %eax, %eax
jne 0xee5d
shrq $0x20, %r14
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andl %eax, %r14d
shrq $0x20, %r15
andl %eax, %r15d
xorl %eax, %eax
cmpl %r15d, %r14d
setb %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ctags.c
// Function: examine_symbol
static void examine_symbol(struct symbol *sym)
{
	struct symbol *base = sym;

	if (!sym || sym->visited)
		return;
	if (sym->ident && sym->ident->reserved)
		return;
	if (sym->type == SYM_KEYWORD || sym->type == SYM_PREPROCESSOR)
		return;

	add_tag(sym);
	base = sym->ctype.base_type;

	switch (sym->type) {
	case SYM_NODE:
		if (base && base->type == SYM_FN)
			sym->kind = 'f';
		examine_symbol(base);
		break;
	case SYM_STRUCT:
		sym->kind = 's';
		examine_members(sym->symbol_list);
		break;
	case SYM_UNION:
		sym->kind = 'u';
		examine_members(sym->symbol_list);
		break;
	case SYM_ENUM:
		sym->kind = 'e';
	case SYM_PTR:
	case SYM_TYPEOF:
	case SYM_BITFIELD:
	case SYM_FN:
	case SYM_ARRAY:
		examine_symbol(sym->ctype.base_type);
		break;
	case SYM_BASETYPE:
		break;

	default:
		die("unknown symbol %s namespace:%d type:%d\n", show_ident(sym->ident),
		    sym->namespace, sym->type);
	}
	if (!sym->kind)
		sym->kind = 'v';
	return;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xef35
movq %rdi, %rbx
movb 0xd1(%rdi), %al
testb $0x1, %al
jne 0xef35
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0xee96
testb $0x2, 0x11(%rcx)
jne 0xef35
movzbl (%rbx), %edx
cmpl $0x1, %edx
je 0xef35
cmpl $0xf, %edx
je 0xef35
testq %rcx, %rcx
je 0xeec7
orb $0x1, %al
movb %al, 0xd1(%rbx)
leaq 0x585e9(%rip), %rdi     # 0x674a8
movq %rbx, %rsi
callq 0x19e7f
movzbl (%rbx), %eax
addl $-0x2, %eax
cmpl $0x9, %eax
ja 0xef37
movq 0x60(%rbx), %rdi
leaq 0x32147(%rip), %rcx     # 0x41024
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0xee68
jmp 0xef25
movb $0x65, 0xd0(%rbx)
jmp 0xeee6
movb $0x73, 0xd0(%rbx)
jmp 0xef19
testq %rdi, %rdi
je 0xeee6
cmpb $0x5, (%rdi)
jne 0xeee6
movb $0x66, 0xd0(%rbx)
jmp 0xeee6
movb $0x75, 0xd0(%rbx)
movq 0x98(%rbx), %rdi
callq 0xef5f
cmpb $0x0, 0xd0(%rbx)
jne 0xef35
movb $0x76, 0xd0(%rbx)
popq %rbx
retq
movq 0x18(%rbx), %rdi
callq 0x1f465
movl (%rbx), %edx
movzbl %dl, %ecx
shrl $0x8, %edx
andl $0x1ff, %edx            # imm = 0x1FF
leaq 0x3211f(%rip), %rdi     # 0x41074
movq %rax, %rsi
xorl %eax, %eax
callq 0xf45e
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ctags.c
// Function: examine_members
static inline void examine_members(struct symbol_list *list)
{
	struct symbol *sym;

	FOR_EACH_PTR(list, sym) {
		sym->kind = 'm';
		examine_symbol(sym);
	} END_FOR_EACH_PTR(sym);
}

// Assembly:
testq %rdi, %rdi
je 0xefb7
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rdi, %r14
movzwl (%r14), %eax
testb %al, %al
jle 0xefa9
xorl %r15d, %r15d
movq 0x18(%r14,%r15,8), %rdi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0xef8e
testq %rdi, %rdi
je 0xef9a
movb $0x6d, 0xd0(%rdi)
callq 0xee68
incq %r15
movl (%r14), %eax
movsbq %al, %rcx
cmpq %rcx, %r15
jl 0xef7a
movq 0x10(%r14), %r14
cmpq %rbx, %r14
jne 0xef6f
popq %rbx
popq %r14
popq %r15
retq