LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
andl $0x0, 0x38(%rdi)
movl $0x800, %edi            # imm = 0x800
callq 0x8490
movq %rax, %r15
movq %rax, 0x48(%rbx)
movups 0x4e098(%rip), %xmm0    # 0x122125
movups %xmm0, (%rax)
movups 0x4e09e(%rip), %xmm0    # 0x122135
movups %xmm0, 0x10(%rax)
movups 0x4e09d(%rip), %xmm0    # 0x12213f
movups %xmm0, 0x1a(%rax)
movsd 0x8(%rsp), %xmm0
maxsd 0x4d584(%rip), %xmm0    # 0x121638
movsd %xmm0, 0x10(%rbx)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%rbx)
movl $0x3848, %edi           # imm = 0x3848
callq 0x8490
movq %rax, (%rbx)
movq 0x50(%rbx), %rdx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0xcd4a2
pushq $0x28
popq %r15
movq %r15, %rdi
callq 0x8490
movq %rax, 0x60(%rbx)
movq 0x48(%rbx), %rcx
movq 0x50(%rbx), %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0xcd9fd
movl $0xc0, %edi
callq 0x8490
movq %rax, %r12
movq %rax, 0x8(%rbx)
pushq $0x70
popq %rdi
callq 0x8490
movq %rax, 0xb8(%r12)
movsd 0x11131(%rip), %xmm0    # 0xe5260
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd 0x10(%rsp), %xmm2
addsd %xmm0, %xmm2
divsd %xmm2, %xmm1
movapd %xmm1, %xmm0
callq 0x82e0
divsd 0x4d0e0(%rip), %xmm0    # 0x121238
cvttsd2si %xmm0, %r12
addq $0x2, %r12
movq %r12, 0x20(%rbx)
movq %r15, %rdi
callq 0x8490
movq %rax, 0x58(%rbx)
movq 0x48(%rbx), %rdx
movl %r12d, %edi
movq %r14, %rsi
callq 0xcbe5a
movq %rax, 0x28(%rbx)
movl 0x20(%rbx), %edi
movq 0x48(%rbx), %rdx
movq %r14, %rsi
callq 0xcbe5a
movq %rax, 0x30(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xcd9b6
movq 0x8(%rbx), %rax
movq 0xb8(%rax), %rdi
callq 0x8430
movq 0x8(%rbx), %rdi
callq 0x8430
movq (%rbx), %rdi
callq 0x8430
movq 0x28(%rbx), %rdi
callq 0x8430
movq 0x30(%rbx), %rdi
callq 0x8430
movq 0x48(%rbx), %rdi
callq 0x8430
movq 0x58(%rbx), %rdi
callq 0x8430
movq 0x60(%rbx), %rdi
callq 0xcdbca
movq 0x60(%rbx), %rdi
popq %rbx
jmp 0x8430
// File: /workspace/github_c_makefile_star2_O2/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 0xd424a
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 0xd42d4
movq 0x8(%rbx), %rax
movsd 0xa8(%rax), %xmm1
movsd %xmm1, 0x8(%rsp)
addsd 0x10fec(%rip), %xmm0    # 0xe5260
callq 0x82e0
xorpd 0x10faf(%rip), %xmm0    # 0xe5230
movapd %xmm0, 0x10(%rsp)
movq 0x28(%rbx), %r14
movl 0x20(%rbx), %ebp
movsd (%rsp), %xmm0
addsd 0x10fc5(%rip), %xmm0    # 0xe5260
callq 0x82e0
movapd 0x10f88(%rip), %xmm2    # 0xe5230
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 0xcc0a7
movq 0x6ecd5(%rip), %rbx     # 0x142fb0
movq (%rbx), %rdi
leaq 0x4de6a(%rip), %rsi     # 0x12214f
movsd (%rsp), %xmm0
movb $0x1, %al
callq 0x8510
movq (%rbx), %rcx
leaq 0x4de93(%rip), %rdi     # 0x12218e
pushq $0x10
popq %rsi
pushq $0x1
popq %rdx
callq 0x8700
pushq $0x1
popq %rdi
callq 0x8440
// File: /workspace/github_c_makefile_star2_O2/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 0xd4346
addsd 0x10f30(%rip), %xmm2    # 0xe5260
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 0xd43d0
movq 0x8(%rbx), %rax
movsd 0xa8(%rax), %xmm1
movsd %xmm1, 0x8(%rsp)
addsd 0x10ef0(%rip), %xmm0    # 0xe5260
callq 0x82e0
xorpd 0x10eb3(%rip), %xmm0    # 0xe5230
movapd %xmm0, 0x10(%rsp)
movq 0x30(%rbx), %r14
movl 0x20(%rbx), %ebp
movsd (%rsp), %xmm0
addsd 0x10ec9(%rip), %xmm0    # 0xe5260
callq 0x82e0
movapd 0x10e8c(%rip), %xmm2    # 0xe5230
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 0xcc0a7
movq 0x6ebd9(%rip), %rbx     # 0x142fb0
movq (%rbx), %rdi
leaq 0x4ddbe(%rip), %rsi     # 0x12219f
movsd (%rsp), %xmm0
movb $0x1, %al
callq 0x8510
movq (%rbx), %rcx
leaq 0x4dd97(%rip), %rdi     # 0x12218e
pushq $0x10
popq %rsi
pushq $0x1
popq %rdx
callq 0x8700
pushq $0x1
popq %rdi
callq 0x8440
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xd41a3
movq (%rbx), %rdi
callq 0x8430
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x106d3(%rip), %xmm4    # 0xe5260
addsd %xmm4, %xmm1
movapd %xmm2, %xmm0
addsd %xmm4, %xmm0
divsd %xmm1, %xmm4
mulsd %xmm3, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xd4bb1
sqrtsd %xmm0, %xmm0
jmp 0xd4bd8
movapd %xmm2, 0x20(%rsp)
movapd %xmm4, 0x10(%rsp)
movapd %xmm5, (%rsp)
callq 0x82d0
movapd (%rsp), %xmm5
movapd 0x10(%rsp), %xmm4
movapd 0x20(%rsp), %xmm2
mulsd 0x4d770(%rip), %xmm0    # 0x122350
mulsd 0x4d770(%rip), %xmm5    # 0x122358
mulsd 0x4d770(%rip), %xmm2    # 0x122360
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_O2/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 $0x28, %rsp
movsd %xmm3, 0x8(%rsp)
movsd %xmm2, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
callq 0xd4b7d
movsd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
movsd 0x8(%rsp), %xmm3
callq 0xd4c19
movsd %xmm0, 0x8(%rsp)
movsd 0x14d84(%rip), %xmm1    # 0xe9a18
movsd (%rsp), %xmm0
callq 0x8650
addsd 0x11aa2(%rip), %xmm0    # 0xe6748
movsd 0x347a2(%rip), %xmm1    # 0x109450
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x86a0
movsd (%rsp), %xmm1
addsd 0x10598(%rip), %xmm1    # 0xe5260
movsd %xmm0, (%rsp)
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
movapd %xmm1, %xmm0
jb 0xd4ce1
sqrtsd %xmm0, %xmm0
jmp 0xd4ce6
callq 0x82d0
addsd 0x10572(%rip), %xmm0    # 0xe5260
callq 0xcbe48
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd 0x8(%rsp), %xmm0
mulsd %xmm0, %xmm0
movsd 0x4a82d(%rip), %xmm1    # 0x11f540
addsd %xmm0, %xmm1
divsd %xmm1, %xmm0
movsd 0x4a825(%rip), %xmm1    # 0x11f548
callq 0x8650
mulsd 0x4a820(%rip), %xmm0    # 0x11f550
addsd 0x4a820(%rip), %xmm0    # 0x11f558
mulsd (%rsp), %xmm0
divsd 0x4a81b(%rip), %xmm0    # 0x11f560
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x18, %rsp
movsd %xmm2, (%rsp)
callq 0xd4c19
movsd 0x136a0(%rip), %xmm1    # 0xe84b0
callq 0x8650
addsd 0x10453(%rip), %xmm0    # 0xe5270
movsd 0x13163(%rip), %xmm1    # 0xe7f88
divsd %xmm0, %xmm1
movsd 0x2cb17(%rip), %xmm0    # 0x101948
movsd %xmm1, 0x10(%rsp)
mulsd %xmm1, %xmm0
addsd 0x10e9d(%rip), %xmm0    # 0xe5ce0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xd4e53
sqrtsd %xmm0, %xmm0
jmp 0xd4e58
callq 0x82d0
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
addsd 0x103f5(%rip), %xmm0    # 0xe5260
mulsd 0x10e3d(%rip), %xmm0    # 0xe5cb0
movsd 0x118c5(%rip), %xmm1    # 0xe6740
callq 0x8650
mulsd 0x10(%rsp), %xmm0
mulsd 0x10e22(%rip), %xmm0    # 0xe5cb0
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x1365f(%rip), %xmm0    # 0xe8500
movsd 0x13607(%rip), %xmm1    # 0xe84b0
callq 0x8650
mulsd (%rsp), %xmm0
mulsd 0x4d4bd(%rip), %xmm0    # 0x122378
movsd %xmm0, (%rsp)
divsd 0x4a6c0(%rip), %xmm0    # 0x11f588
addsd 0x10390(%rip), %xmm0    # 0xe5260
movsd 0x13530(%rip), %xmm1    # 0xe8408
callq 0x8650
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd4dfa
movapd %xmm0, %xmm2
movsd 0x1035c(%rip), %xmm0    # 0xe5260
ucomisd %xmm2, %xmm0
movsd %xmm2, 0x8(%rsp)
jbe 0xd4f2c
movsd 0x4d470(%rip), %xmm0    # 0x122388
divsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xd4f5b
sqrtsd %xmm0, %xmm0
jmp 0xd4f66
movapd %xmm2, %xmm0
addsd %xmm2, %xmm0
mulsd 0x4d444(%rip), %xmm0    # 0x122380
addsd 0x4a66c(%rip), %xmm0    # 0x11f5b0
callq 0x82e0
addsd 0x1352f(%rip), %xmm0    # 0xe8480
mulsd 0x4a65f(%rip), %xmm0    # 0x11f5b8
jmp 0xd4f9b
callq 0x82d0
movsd 0x8(%rsp), %xmm2
mulsd 0x4d422(%rip), %xmm0    # 0x122390
movsd %xmm0, 0x10(%rsp)
movsd 0x10d1c(%rip), %xmm1    # 0xe5c98
movapd %xmm2, %xmm0
callq 0x8650
mulsd 0x4a613(%rip), %xmm0    # 0x11f5a0
addsd 0x102cb(%rip), %xmm0    # 0xe5260
mulsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
divsd 0x4d3cf(%rip), %xmm1    # 0x122378
divsd 0x4d3e7(%rip), %xmm1    # 0x122398
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd4d4a
movsd %xmm0, 0x18(%rsp)
movsd 0x4d3b3(%rip), %xmm1    # 0x1223a0
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 0xd4eef
mulsd 0x10(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
mulsd 0x4d378(%rip), %xmm0    # 0x1223a8
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x101d9(%rip), %xmm5    # 0xe5260
movapd %xmm1, %xmm0
addsd %xmm5, %xmm0
movsd 0x4d319(%rip), %xmm4    # 0x1223b0
mulsd %xmm4, %xmm0
movsd 0x14a35(%rip), %xmm3    # 0xe9ad8
divsd %xmm3, %xmm0
movsd %xmm1, 0x30(%rsp)
cmpltsd %xmm3, %xmm1
andpd %xmm1, %xmm0
andnpd %xmm4, %xmm1
orpd %xmm0, %xmm1
movapd %xmm1, 0x60(%rsp)
mulsd 0x101a4(%rip), %xmm1    # 0xe5270
movapd %xmm1, 0x50(%rsp)
movsd %xmm2, 0x38(%rsp)
addsd %xmm5, %xmm2
movsd %xmm2, 0x20(%rsp)
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
pushq $0x32
popq %rbx
xorpd %xmm1, %xmm1
subl $0x1, %ebx
jb 0xd51ce
movapd 0x50(%rsp), %xmm2
mulsd %xmm1, %xmm2
divsd 0x4d2ab(%rip), %xmm2    # 0x1223b8
movapd %xmm2, 0x70(%rsp)
movsd %xmm1, 0x48(%rsp)
movapd %xmm2, %xmm1
divsd 0x60(%rsp), %xmm1
movsd %xmm0, 0x8(%rsp)
movapd %xmm1, %xmm0
mulsd 0x1369b(%rip), %xmm0    # 0xe87d0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm1
movapd %xmm1, 0x10(%rsp)
callq 0x86a0
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 0x4d248(%rip), %xmm3    # 0x1223c0
mulsd %xmm0, %xmm3
divsd 0x20(%rsp), %xmm3
addsd 0x40(%rsp), %xmm3
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movsd 0x38(%rsp), %xmm2
callq 0xd4fbe
mulsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x48(%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
addsd 0x10097(%rip), %xmm1    # 0xe5260
jmp 0xd50f2
divsd (%rsp), %xmm0
addq $0x80, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd5270
subq $0x38, %rsp
movsd 0x10066(%rip), %xmm0    # 0xe5260
minsd %xmm0, %xmm3
movsd %xmm3, 0x28(%rsp)
movsd 0x4d1bc(%rip), %xmm3    # 0x1223c8
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 0xcbe4d
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 0xd506b
mulsd 0x8(%rsp), %xmm0
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd %xmm5, 0x20(%rsp)
movsd %xmm4, 0x18(%rsp)
movsd %xmm1, (%rsp)
movapd %xmm2, %xmm1
movapd %xmm3, %xmm2
callq 0xd5271
cmpl $0x1, 0x58(%r14)
je 0xd534e
movsd (%rbx), %xmm1
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movsd 0x13195(%rip), %xmm0    # 0xe84a0
mulsd (%rsp), %xmm0
callq 0x86a0
movsd (%rsp), %xmm1
mulsd 0x4d0ae(%rip), %xmm1    # 0x1223d0
mulsd 0x18(%rsp), %xmm1
divsd 0x20(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
mulsd %xmm1, %xmm2
mulsd 0x10(%rsp), %xmm0
addsd %xmm2, %xmm0
addsd 0xff16(%rip), %xmm1     # 0xe5260
divsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8430
movq 0x8(%rbx), %rdi
callq 0x8430
movq 0x10(%rbx), %rdi
callq 0x8430
movq 0x18(%rbx), %rdi
callq 0x8430
movq 0x20(%rbx), %rdi
callq 0x8430
movq 0x28(%rbx), %rdi
callq 0x8430
xorl %r15d, %r15d
movslq 0x64(%r14), %rax
movq 0x30(%rbx), %rdi
cmpq %rax, %r15
jge 0xda050
movq (%rdi,%r15,8), %rdi
callq 0x8430
movq 0x38(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x8430
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x8430
movq 0x48(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x8430
incq %r15
jmp 0xda00e
callq 0x8430
movq 0x38(%rbx), %rdi
callq 0x8430
movq 0x40(%rbx), %rdi
callq 0x8430
movq 0x48(%rbx), %rdi
callq 0x8430
movq 0x60(%rbx), %rdi
callq 0x8430
movq 0x68(%rbx), %rdi
callq 0x8430
movq 0x58(%rbx), %rdi
callq 0x8430
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8430
movq 0x10(%rbx), %rdi
callq 0x8430
movq 0x18(%rbx), %rdi
callq 0x8430
movq 0x20(%rbx), %rdi
callq 0x8430
movq 0x28(%rbx), %rdi
callq 0x8430
movq 0xe8(%rbx), %rdi
callq 0x8430
movq %rbx, %rdi
callq 0x8430
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xdd154
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
divsd (%rax,%rcx,8), %xmm0
movslq 0xc8(%r14), %rax
movsd %xmm2, (%rbx,%rax,8)
mulsd 0xab74(%rip), %xmm1     # 0xe7f88
mulsd (%r15,%rax,8), %xmm1
movsd 0x8(%rsp), %xmm4
movapd %xmm4, %xmm3
mulsd %xmm4, %xmm3
divsd %xmm3, %xmm1
addsd 0x88ac(%rip), %xmm0     # 0xe5ce0
mulsd %xmm2, %xmm0
divsd %xmm4, %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_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
pushq $0x20
popq %rdi
movq %rbx, %rsi
callq 0x8460
leaq 0x42e28(%rip), %r14     # 0x12776a
pushq $0x18
popq %rbp
pushq $0xc
popq %r15
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %r15d, %ecx
movsd 0x8(%rsp), %xmm0
movb $0x1, %al
callq 0x8510
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %r15d, %ecx
movsd 0x10(%rsp), %xmm0
movb $0x1, %al
callq 0x8510
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x8460
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x1f78, %rsp           # imm = 0x1F78
movl %ecx, 0x10(%rsp)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
pushq $0x23
popq %rdi
movq %r14, %rsi
callq 0x8460
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x8370
leaq 0x42d8a(%rip), %rsi     # 0x12775b
movq %r12, %rdi
callq 0x8560
movq %rax, %r13
leaq 0x42d79(%rip), %rbp     # 0x12775c
pushq $0x12
popq %r12
movq $0x0, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
testq %r13, %r13
je 0xe4a62
movq 0x8(%rsp), %r15
incq %r15
movq %r13, %rdi
callq 0x8190
pushq $0x15
popq %rdx
subl %eax, %edx
cmpl $0x3, %edx
pushq $0x3
popq %rax
cmovgel %eax, %edx
testl %edx, %edx
movl $0x0, %eax
cmovlel %eax, %edx
movq %r13, (%rsp)
movq %r14, %rdi
leaq 0x42d29(%rip), %rsi     # 0x12775d
movq %rbp, %rcx
movq %r15, 0x8(%rsp)
movl %r15d, %r8d
movl %r12d, %r9d
xorl %eax, %eax
callq 0x8510
xorl %edi, %edi
leaq 0x42d09(%rip), %rsi     # 0x12775b
callq 0x8560
movq %rax, %r13
addq $0x8, 0x18(%rsp)
jmp 0xe49f9
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x8460
movq 0x8(%rsp), %rax
incl %eax
cmpl $0x2, %eax
jb 0xe4b04
movl 0x10(%rsp), %eax
cltd
idivl 0x8(%rsp)
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
movq %rax, 0x20(%rsp)
leaq 0x42cd1(%rip), %rbp     # 0x12776a
pushq $0x18
popq %r13
pushq $0xc
popq %r12
cmpq 0x20(%rsp), %rcx
je 0xe4b04
movq %rcx, 0x28(%rsp)
pushq $0x20
popq %rdi
movq %r14, %rsi
callq 0x8460
movq 0x8(%rsp), %r15
movq %rbx, 0x10(%rsp)
subq $0x1, %r15
jb 0xe4ae5
movsd (%rbx), %xmm0
movq %r14, %rdi
movq %rbp, %rsi
movl %r13d, %edx
movl %r12d, %ecx
movb $0x1, %al
callq 0x8510
addq $0x8, %rbx
jmp 0xe4ac2
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x8460
movq 0x28(%rsp), %rcx
incq %rcx
movq 0x10(%rsp), %rbx
addq 0x18(%rsp), %rbx
jmp 0xe4aa1
xorl %eax, %eax
addq $0x1f78, %rsp           # imm = 0x1F78
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
leaq -0xb7e(%rip), %rsi      # 0x11ac
movl $0x40000000, %edi       # imm = 0x40000000
callq 0x11b5
leaq 0x459(%rip), %rax       # 0x2194
movl (%rax), %r15d
pushq $0x2
popq %rbp
movl %ebp, %edi
callq 0x1428
movq %rax, %rbx
movq %rax, %rdi
callq 0x14a5
leaq 0x48a(%rip), %rsi       # 0x21e4
movq %rbx, %rdi
movl %ebp, %edx
callq 0x1452
movq %rbx, %rdi
callq 0x14a5
leaq 0x474(%rip), %r14       # 0x21e7
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x1452
movq %rbx, %rdi
callq 0x14a5
leaq 0x45b(%rip), %rsi       # 0x21ea
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x1452
movq %rbx, %rdi
callq 0x14a5
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x1452
movq %rbx, %rdi
callq 0x14a5
leaq 0x430(%rip), %rsi       # 0x21ee
movq %rbx, %rdi
movl %ebp, %edx
callq 0x1483
cmpl %r15d, %eax
jne 0x1de9
leaq 0x41d(%rip), %rdi       # 0x21f1
xorl %eax, %eax
callq 0x1900
leaq 0x3b6(%rip), %rax       # 0x2198
movl (%rax), %ebp
movl %ebp, %r15d
jmp 0x1df2
leaq 0x3a8(%rip), %rax       # 0x2198
movl (%rax), %ebp
leaq 0x438(%rip), %rdi       # 0x2231
callq 0x1040
leaq 0x3e5(%rip), %rsi       # 0x21ea
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x1483
cmpl %ebp, %eax
jne 0x1e25
leaq 0x3e4(%rip), %rdi       # 0x21ff
xorl %eax, %eax
callq 0x1900
movl %ebp, %r15d
testl %r15d, %r15d
je 0x1e3a
leaq 0x3dc(%rip), %rdi       # 0x220d
xorl %eax, %eax
callq 0x19b8
jmp 0x1e48
leaq 0x3e2(%rip), %rdi       # 0x2223
xorl %eax, %eax
callq 0x1900
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x11ef
leaq 0xeba(%rip), %rdi       # 0x208c
callq 0x1030
movq (%r14), %rsi
leaq 0xe23(%rip), %rdi       # 0x2004
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1050
jmp 0x129b
movl %edi, %ebp
movq 0x8(%r14), %rdi
leaq 0xe2d(%rip), %rsi       # 0x2029
callq 0x10a0
testq %rax, %rax
je 0x12a8
movq %rax, %rbx
cmpl $0x2, %ebp
jne 0x1217
xorl %r14d, %r14d
jmp 0x1227
movq 0x10(%r14), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10b0
movq %rax, %r14
pushq $0x2
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1090
movq %rbx, %rdi
callq 0x1080
movq %rax, %r15
leaq 0xdfa(%rip), %rdi       # 0x2040
movl %r15d, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1050
pushq $0x1
popq %rax
addq %rax, %rax
cmpq %r15, %rax
jb 0x1256
cmpq %r14, %rax
cmovaq %rax, %r14
leaq 0xdfb(%rip), %rdi       # 0x2067
movl %r14d, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1050
subq %r15, %r14
subq $0x1, %r14
jb 0x1291
movl $0xff, %edi
movq %rbx, %rsi
callq 0x1060
jmp 0x127c
movq %rbx, %rdi
callq 0x1040
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x2d49(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x8(%r14), %rdx
leaq 0xd6f(%rip), %rsi       # 0x202c
xorl %eax, %eax
callq 0x1070
pushq $-0x1
popq %rbx
jmp 0x129b
// File: /workspace/github_c_makefile_star2_O2/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 0x122a
movl %edi, %ebp
movq 0x8(%rbx), %rdi
callq 0x1080
testl %eax, %eax
jle 0x122a
movl %eax, %r14d
movq %rsp, %rsi
xorl %edi, %edi
callq 0x1030
testl %eax, %eax
jne 0x1232
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 0x121f
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 0x1246
leaq 0xdcb(%rip), %rdi       # 0x2004
callq 0x1060
pushq $0x1
popq %rdi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O2/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 0xe7b2
movq %rdi, %rbx
leaq 0x2a916(%rip), %r12     # 0x39004
movq %rdi, %r13
xorl %ebp, %ebp
movl (%r13), %eax
movsbq %al, %rcx
cmpq %rcx, %rbp
jge 0xe7a5
movq 0x18(%r13,%rbp,8), %r14
cmpw $0x100, %ax             # imm = 0x100
jb 0xe718
testq %r14, %r14
je 0xe79d
testb $0x1, 0xd1(%r14)
jne 0xe79d
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xe731
testb $0x2, 0x11(%rdi)
jne 0xe79d
movl (%r14), %r15d
shrl $0x8, %r15d
andl $0x1ff, %r15d           # imm = 0x1FF
leal -0x1(%r15), %eax
cmpl $0x7, %eax
jbe 0xe768
cmpl $0x10, %r15d
je 0xe783
cmpl $0x40, %r15d
je 0xe79d
cmpl $0x80, %r15d
je 0xe771
cmpl $0x100, %r15d           # imm = 0x100
je 0xe79d
jmp 0xe7c1
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movb $0x64, 0xd0(%r14)
jmp 0xe795
movb $0x74, 0xd0(%r14)
movq %r14, %rdi
callq 0xe871
jmp 0xe795
movb $0x6c, 0xd0(%r14)
movq %r14, %rdi
callq 0xe94b
incq %rbp
jmp 0xe6f3
movq 0x10(%r13), %r13
cmpq %rbx, %r13
jne 0xe6f1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1de25
movzbl (%r14), %ecx
leaq 0x2a87b(%rip), %rdi     # 0x3904c
movl %r15d, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0xefa6
// File: /workspace/github_c_makefile_star2_O2/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 0xe866
movq 0x4(%r14), %r14
movq 0x4(%rbx), %r15
movl %r14d, %edi
shrl $0x6, %edi
movl $0x3fff, %ebp           # imm = 0x3FFF
andl %ebp, %edi
callq 0x1dd90
movq %rax, %rbx
movl %r15d, %edi
shrl $0x6, %edi
andl %ebp, %edi
callq 0x1dd90
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe1d0
testl %eax, %eax
jne 0xe866
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_O2/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 0xe921
movq %rdi, %rbx
testb $0x1, 0xd1(%rdi)
jne 0xe921
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0xe89e
testb $0x2, 0x11(%rax)
jne 0xe921
movzbl (%rbx), %eax
cmpl $0x1, %eax
je 0xe921
cmpl $0xf, %eax
je 0xe921
movq %rbx, %rdi
callq 0xe94b
movzbl (%rbx), %eax
addl $-0x2, %eax
cmpl $0x9, %eax
ja 0xe923
movq 0x60(%rbx), %rdi
leaq 0x2a75b(%rip), %rcx     # 0x39024
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0xe871
jmp 0xe911
movb $0x65, 0xd0(%rbx)
jmp 0xe8d2
movb $0x73, 0xd0(%rbx)
jmp 0xe905
testq %rdi, %rdi
je 0xe8d2
cmpb $0x5, (%rdi)
jne 0xe8d2
movb $0x66, 0xd0(%rbx)
jmp 0xe8d2
movb $0x75, 0xd0(%rbx)
movq 0x98(%rbx), %rdi
callq 0xe974
cmpb $0x0, 0xd0(%rbx)
jne 0xe921
movb $0x76, 0xd0(%rbx)
popq %rbx
retq
movq 0x18(%rbx), %rdi
callq 0x1de25
movl (%rbx), %edx
movzbl %dl, %ecx
shrl $0x8, %edx
andl $0x1ff, %edx            # imm = 0x1FF
leaq 0x2a733(%rip), %rdi     # 0x39074
movq %rax, %rsi
xorl %eax, %eax
callq 0xefa6
// File: /workspace/github_c_makefile_star2_O2/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 0xe9c2
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movl (%r14), %eax
movsbq %al, %rcx
cmpq %rcx, %r15
jge 0xe9b4
movq 0x18(%r14,%r15,8), %rdi
cmpw $0x100, %ax             # imm = 0x100
jb 0xe9a3
testq %rdi, %rdi
je 0xe9af
movb $0x6d, 0xd0(%rdi)
callq 0xe871
incq %r15
jmp 0xe987
movq 0x10(%r14), %r14
cmpq %rbx, %r14
jne 0xe984
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/keithnoguchi[P]pearls-in-action/0x4/bsearch.c
// Function: _bsearch
static int __bsearch(int v, const int a[], int n, int *try)
{
	int l, h;

	l = 0, h = n-1;
	while (l <= h) {
		int m = (l+h)/2;

		if (try)
			(*try)++;
		if (v < a[m])
			h = m-1;
		else if (v > a[m])
			l = m+1;
		else
			return m;
	}
	return -1;
}

// Assembly:
decl %edx
xorl %r8d, %r8d
pushq $-0x1
popq %rax
cmpl %edx, %r8d
jg 0x2419
testq %rcx, %rcx
je 0x23f4
incl (%rcx)
leal (%rdx,%r8), %r9d
shrl %r9d
movl %r9d, %r10d
cmpl %edi, (%rsi,%r10,4)
jle 0x240c
decl %r9d
movl %r9d, %edx
jmp 0x23e8
jge 0x2416
incl %r9d
movl %r9d, %r8d
jmp 0x23e8
movl %r9d, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/keithnoguchi[P]pearls-in-action/0x4/bsearch.c
// Function: _bsearch_recursive
static int __bsearch_recursive(int v, const int a[], int l, int h, int *try)
{
	int m;

	if (l > h)
		return -1; /* base case */

	if (try)
		(*try)++;

	m = (l+h)/2;
	if (v < a[m])
		return __bsearch_recursive(v, a, l, m-1, try);
	else if (v > a[m])
		return __bsearch_recursive(v, a, m+1, h, try);
	else
		return m;
}

// Assembly:
pushq $-0x1
popq %rax
cmpl %ecx, %edx
jg 0x245f
testq %r8, %r8
je 0x243d
incl (%r8)
leal (%rcx,%rdx), %r9d
shrl %r9d
cmpl %edi, (%rsi,%r9,4)
jle 0x2452
decl %r9d
movl %r9d, %ecx
jmp 0x2431
jge 0x245c
incl %r9d
movl %r9d, %edx
jmp 0x2431
movl %r9d, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/keithnoguchi[P]pearls-in-action/0x4/bsearch_test.c
// Function: test_bsearch_0
int test_bsearch_0(int *i)
{
	const struct test {
		const char	*name;
		const int	array[1];
		int		value;
		int		want;
	} tests[] = {
		{
			.name	= "no entry",
			.array	= {},
			.value	= 10,
			.want	= -1,
		},
		{ /* sentry */ },
	};
	const struct test *t;
	int fail = 0;

	for (t = tests; t->name; t++) {
		int got;

		print_title(i, "test_bsearch_0", t->name);
		got = bsearch(t->value, t->array, 0);
		if (got != t->want) {
			printf("FAIL: %d!=%d\n", got, t->want);
			fail++;
		} else
			puts("PASS");
	}
	return fail;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movaps 0x4534(%rip), %xmm0     # 0x69c0
leaq 0xc(%rsp), %r13
movaps %xmm0, 0x14(%r13)
movaps 0x4513(%rip), %xmm0     # 0x69b0
movaps %xmm0, 0x4(%r13)
movaps 0x44f7(%rip), %xmm0     # 0x69a0
movaps %xmm0, -0xc(%r13)
leaq 0x1b8f(%rip), %rdx      # 0x4044
leaq 0x1b91(%rip), %r14      # 0x404d
leaq 0x1ba7(%rip), %r15      # 0x406a
leaq 0x1b92(%rip), %r12      # 0x405c
xorl %ebp, %ebp
testq %rdx, %rdx
je 0x2515
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2526
movl (%r13), %edi
leaq -0x4(%r13), %rsi
xorl %edx, %edx
callq 0x23dc
movl 0x4(%r13), %edx
cmpl %edx, %eax
jne 0x24fd
movq %r15, %rdi
callq 0x2040
jmp 0x250b
movq %r12, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x2050
incl %ebp
movq 0xc(%r13), %rdx
addq $0x18, %r13
jmp 0x24cc
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/keithnoguchi[P]pearls-in-action/0x4/bsearch_test.c
// Function: test_bsearch_with_try_0
int test_bsearch_with_try_0(int *i)
{
	const struct test {
		const char	*name;
		const int	array[1];
		int		value;
		int		want;
		int		try;
	} tests[] = {
		{
			.name	= "no entry",
			.array	= {},
			.value	= 10,
			.want	= -1,
			.try	= 0,
		},
		{ /* sentry */ },
	};
	const struct test *t;
	int fail = 0;

	for (t = tests; t->name; t++) {
		int got;
		int try;

		print_title(i, "test_bsearch_with_try_0", t->name);
		got = bsearch_with_try(t->value, t->array, 0, &try);
		if (got != t->want) {
			printf("FAIL: %d!=%d\n", got, t->want);
			fail++;
		} else if (try != t->try) {
			printf("FAIL: try(%d)!=%d\n", try, t->try);
			fail++;
		} else
			puts("PASS");
	}
	return fail;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movaps 0x4695(%rip), %xmm0     # 0x6ea0
leaq 0x28(%rsp), %r13
movaps %xmm0, 0x8(%r13)
movaps 0x4674(%rip), %xmm0     # 0x6e90
movaps %xmm0, -0x8(%r13)
movaps 0x4658(%rip), %xmm0     # 0x6e80
movaps %xmm0, -0x18(%r13)
leaq 0x1810(%rip), %rdx      # 0x4044
leaq 0x1898(%rip), %r14      # 0x40d3
leaq 0xc(%rsp), %r15
leaq 0x1815(%rip), %rbp      # 0x405c
xorl %r12d, %r12d
testq %rdx, %rdx
je 0x28b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2526
movl -0xc(%r13), %edi
leaq -0x10(%r13), %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x241a
movl -0x8(%r13), %edx
cmpl %edx, %eax
jne 0x288e
movl 0xc(%rsp), %esi
movl -0x4(%r13), %edx
cmpl %edx, %esi
jne 0x2895
leaq 0x17e3(%rip), %rdi      # 0x406a
callq 0x2040
jmp 0x28a6
movq %rbp, %rdi
movl %eax, %esi
jmp 0x289c
leaq 0x184f(%rip), %rdi      # 0x40eb
xorl %eax, %eax
callq 0x2050
incl %r12d
movq (%r13), %rdx
addq $0x18, %r13
jmp 0x284a
movl %r12d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/yangtau[P]hedgehog/src/test/../hashset.c
// Function: hg_hashset_init
void hg_hashset_init(struct hg_hashset* set, size_t capacity, hg_hash_hashfunc hash, hg_hash_eqfunc eq) {
    if (capacity < HG_HASHSET_MIN_CAPACITY) {
        capacity = HG_HASHSET_MIN_CAPACITY;
    }

    set->capacity = capacity;
    set->len      = 0;
    set->tomb_cnt = 0;
    set->hash     = hash;
    set->eq       = eq;
    set->buckets  = hg_alloc(capacity * sizeof(struct hg_hashset_bucket));

    // TODO: use calloc
    memset(set->buckets, 0, capacity * sizeof(struct hg_hashset_bucket));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x9, %rsi
pushq $0x8
popq %rax
cmovbq %rax, %rsi
movq %rsi, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %rdx, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
shlq $0x4, %rsi
pushq $0x1
popq %rdi
callq 0x10a0
movq %rax, 0x28(%rbx)
popq %rbx
retq