LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x11515(%rip), %xmm6    # 0xee260
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 0xdcdc9
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 0x4e70f(%rip), %xmm0    # 0x12b4e0
mulsd 0x4e70f(%rip), %xmm3    # 0x12b4e8
mulsd 0x4e70f(%rip), %xmm2    # 0x12b4f0
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 0x4e6e5(%rip), %xmm0    # 0x12b4f8
divsd %xmm5, %xmm0
ucomisd %xmm7, %xmm4
jae 0xdce4e
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 0x4e68a(%rip), %xmm1    # 0x12b4e0
divsd %xmm1, %xmm3
divsd %xmm1, %xmm3
divsd %xmm1, %xmm3
mulsd %xmm2, %xmm3
mulsd %xmm3, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x15ce0(%rip), %xmm1    # 0xf2b58
movapd 0x10(%rsp), %xmm0
callq 0x8620
addsd 0x127f5(%rip), %xmm0    # 0xef680
movsd 0x3571d(%rip), %xmm1    # 0x1125b0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x8670
movapd 0x10(%rsp), %xmm1
addsd 0x113b2(%rip), %xmm1    # 0xee260
movsd %xmm0, 0x10(%rsp)
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
movapd %xmm1, %xmm0
jb 0xdcec8
sqrtsd %xmm0, %xmm0
jmp 0xdcecd
callq 0x82b0
addsd 0x1138b(%rip), %xmm0    # 0xee260
callq 0xd3754
movsd 0x10(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd %xmm0, %xmm0
movsd 0x4b794(%rip), %xmm1    # 0x128690
addsd %xmm0, %xmm1
divsd %xmm1, %xmm0
movsd 0x4b78c(%rip), %xmm1    # 0x128698
callq 0x8620
mulsd 0x4b787(%rip), %xmm0    # 0x1286a0
addsd 0x4b787(%rip), %xmm0    # 0x1286a8
mulsd 0x10(%rsp), %xmm0
divsd 0x4b781(%rip), %xmm0    # 0x1286b0
addq $0x68, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1126c(%rip), %xmm5    # 0xee260
movapd %xmm2, %xmm0
addsd %xmm5, %xmm0
movsd 0x4e4f4(%rip), %xmm4    # 0x12b4f8
divsd %xmm0, %xmm4
addsd %xmm5, %xmm1
divsd %xmm1, %xmm5
movsd %xmm0, (%rsp)
mulsd %xmm0, %xmm3
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm3
jb 0xdd02c
xorps %xmm0, %xmm0
sqrtsd %xmm3, %xmm0
jmp 0xdd065
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 0x4e473(%rip), %xmm0    # 0x12b4e0
mulsd 0x4e473(%rip), %xmm6    # 0x12b4e8
mulsd 0x4e473(%rip), %xmm2    # 0x12b4f0
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 0x14443(%rip), %xmm1    # 0xf14f0
movapd %xmm4, %xmm0
callq 0x8620
addsd 0x111b2(%rip), %xmm0    # 0xee270
movsd 0x13f02(%rip), %xmm1    # 0xf0fc8
divsd %xmm0, %xmm1
movsd 0x2d9ae(%rip), %xmm0    # 0x10aa80
movsd %xmm1, 0x10(%rsp)
mulsd %xmm1, %xmm0
addsd 0x11c1c(%rip), %xmm0    # 0xeed00
ucomisd 0x1116c(%rip), %xmm0    # 0xee258
jb 0xdd0f4
sqrtsd %xmm0, %xmm0
jmp 0xdd0f9
callq 0x82b0
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
mulsd 0x11bc4(%rip), %xmm0    # 0xeecd0
movsd 0x12654(%rip), %xmm1    # 0xef768
callq 0x8620
mulsd 0x10(%rsp), %xmm0
mulsd 0x11ba9(%rip), %xmm0    # 0xeecd0
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x14446(%rip), %xmm0    # 0xf1580
movsd 0x143ae(%rip), %xmm1    # 0xf14f0
callq 0x8620
mulsd (%rsp), %xmm0
mulsd 0x4e3b4(%rip), %xmm0    # 0x12b508
movsd %xmm0, (%rsp)
divsd 0x4b577(%rip), %xmm0    # 0x1286d8
addsd 0x110f7(%rip), %xmm0    # 0xee260
movsd 0x142d7(%rip), %xmm1    # 0xf1448
callq 0x8620
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xdcfe4
movapd %xmm0, %xmm2
movsd 0x110c3(%rip), %xmm0    # 0xee260
ucomisd %xmm2, %xmm0
movsd %xmm2, 0x8(%rsp)
jbe 0xdd1c5
movsd 0x4e367(%rip), %xmm0    # 0x12b518
divsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xdd1f4
sqrtsd %xmm0, %xmm0
jmp 0xdd1ff
movapd %xmm2, %xmm0
addsd %xmm2, %xmm0
mulsd 0x4e33b(%rip), %xmm0    # 0x12b510
addsd 0x4b523(%rip), %xmm0    # 0x128700
callq 0x82c0
addsd 0x142d6(%rip), %xmm0    # 0xf14c0
mulsd 0x4b516(%rip), %xmm0    # 0x128708
jmp 0xdd234
callq 0x82b0
movsd 0x8(%rsp), %xmm2
mulsd 0x4e319(%rip), %xmm0    # 0x12b520
movsd %xmm0, 0x10(%rsp)
movsd 0x11aab(%rip), %xmm1    # 0xeecc0
movapd %xmm2, %xmm0
callq 0x8620
mulsd 0x4b4ca(%rip), %xmm0    # 0x1286f0
addsd 0x11032(%rip), %xmm0    # 0xee260
mulsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
divsd 0x4e2c6(%rip), %xmm1    # 0x12b508
divsd 0x4e2de(%rip), %xmm1    # 0x12b528
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xdcf34
movsd %xmm0, 0x18(%rsp)
movsd 0x4e2aa(%rip), %xmm1    # 0x12b530
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 0xdd188
mulsd 0x10(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
mulsd 0x4e26f(%rip), %xmm0    # 0x12b538
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10f40(%rip), %xmm5    # 0xee260
movapd %xmm1, %xmm0
addsd %xmm5, %xmm0
movsd 0x4e210(%rip), %xmm4    # 0x12b540
mulsd %xmm4, %xmm0
movsd 0x158dc(%rip), %xmm3    # 0xf2c18
divsd %xmm3, %xmm0
movsd %xmm1, 0x30(%rsp)
cmpltsd %xmm3, %xmm1
andpd %xmm1, %xmm0
andnpd %xmm4, %xmm1
orpd %xmm0, %xmm1
movapd %xmm1, 0x60(%rsp)
mulsd 0x10f0b(%rip), %xmm1    # 0xee270
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 0x4e199(%rip), %xmm1    # 0x12b548
movapd %xmm1, 0x70(%rsp)
divsd 0x60(%rsp), %xmm1
movapd %xmm1, %xmm0
mulsd 0x14489(%rip), %xmm0    # 0xf1850
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 0x4e146(%rip), %xmm3    # 0x12b550
mulsd %xmm0, %xmm3
divsd 0x20(%rsp), %xmm3
addsd 0x40(%rsp), %xmm3
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movsd 0x38(%rsp), %xmm2
callq 0xdd257
movsd 0x48(%rsp), %xmm2
mulsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
addsd 0x10e05(%rip), %xmm2    # 0xee260
decl %ebx
jne 0xdd391
divsd (%rsp), %xmm0
addq $0x80, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xdd505
subq $0x38, %rsp
movsd 0x10dd1(%rip), %xmm0    # 0xee260
minsd %xmm0, %xmm3
movsd %xmm3, 0x28(%rsp)
movsd 0x4e0b7(%rip), %xmm3    # 0x12b558
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 0xd3759
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 0xdd304
mulsd 0x8(%rsp), %xmm0
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xdc9b4
movsd %xmm0, 0x30(%rsp)
movsd 0x48(%r14), %xmm1
movsd 0x50(%r14), %xmm0
movsd 0x28(%rsp), %xmm2
movsd (%rsp), %xmm3
movsd 0x8(%rsp), %xmm4
callq 0xdd471
addsd 0x30(%rsp), %xmm0
cmpl $0x1, 0x58(%r14)
je 0xdd61b
movsd (%rbx), %xmm1
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movsd 0x13f09(%rip), %xmm0    # 0xf14e0
mulsd 0x10(%rsp), %xmm0
callq 0x8670
movsd 0x10(%rsp), %xmm1
mulsd 0x4df70(%rip), %xmm1    # 0x12b560
mulsd 0x18(%rsp), %xmm1
divsd 0x20(%rsp), %xmm1
movsd (%rsp), %xmm2
mulsd %xmm1, %xmm2
mulsd 0x8(%rsp), %xmm0
addsd %xmm2, %xmm0
addsd 0x10c49(%rip), %xmm1    # 0xee260
divsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe23be
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 0xe237e
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_O3/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 0xe55fe
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 0xb70a(%rip), %xmm1     # 0xf0fc8
mulsd (%r15,%rax,8), %xmm1
movsd 0x8(%rsp), %xmm4
movapd %xmm4, %xmm3
mulsd %xmm4, %xmm3
divsd %xmm3, %xmm1
addsd 0x9422(%rip), %xmm0     # 0xeed00
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_O3/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 0x43789(%rip), %r14     # 0x1308fa
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_O3/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, %ebp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movl $0x23, %edi
movq %rbx, %rsi
callq 0x8440
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x8350
leaq 0x436e9(%rip), %rsi     # 0x1308eb
movq %r12, %rdi
callq 0x8530
testq %rax, %rax
je 0xed31c
movq %rax, %r12
movl %ebp, 0x8(%rsp)
leaq 0x436ca(%rip), %rbp     # 0x1308eb
xorl %r15d, %r15d
xorl %r14d, %r14d
incq %r14
movq %r12, %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
movq %r12, (%rsp)
movq %rbx, %rdi
leaq 0x43691(%rip), %rsi     # 0x1308ed
leaq 0x43689(%rip), %rcx     # 0x1308ec
movl %r14d, %r8d
movl $0x12, %r9d
xorl %eax, %eax
callq 0x84e0
xorl %edi, %edi
movq %rbp, %rsi
callq 0x8530
movq %rax, %r12
addq $0x8, %r15
testq %rax, %rax
jne 0xed227
movl $0xa, %edi
movq %rbx, %rsi
callq 0x8440
movl 0x8(%rsp), %eax
cltd
idivl %r14d
testl %eax, %eax
jle 0xed329
movl %eax, %eax
movq %rax, 0x10(%rsp)
xorl %ebp, %ebp
leaq 0x43644(%rip), %r12     # 0x1308fa
movq %r15, 0x18(%rsp)
movl $0x20, %edi
movq %rbx, %rsi
callq 0x8440
movq %r14, %r15
movq %r13, 0x8(%rsp)
movsd (%r13), %xmm0
movq %rbx, %rdi
movq %r12, %rsi
movl $0x18, %edx
movl $0xc, %ecx
movb $0x1, %al
callq 0x84e0
addq $0x8, %r13
decq %r15
jne 0xed2d0
movl $0xa, %edi
movq %rbx, %rsi
callq 0x8440
incq %rbp
movq 0x8(%rsp), %r13
movq 0x18(%rsp), %r15
addq %r15, %r13
cmpq 0x10(%rsp), %rbp
jne 0xed2bb
jmp 0xed329
movl $0xa, %edi
movq %rbx, %rsi
callq 0x8440
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_O3/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 -0xbf7(%rip), %rsi      # 0x127c
movl $0x40000000, %edi       # imm = 0x40000000
callq 0x1287
leaq 0x310(%rip), %rax       # 0x2194
movl (%rax), %ebp
movl $0x2, %edi
callq 0x1564
movq %rax, %rbx
movq %rax, %rdi
callq 0x15e9
leaq 0x342(%rip), %rsi       # 0x21e4
movq %rbx, %rdi
movl $0x2, %edx
callq 0x1590
movq %rbx, %rdi
callq 0x15e9
leaq 0x329(%rip), %r14       # 0x21e7
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %edx
callq 0x1590
movq %rbx, %rdi
callq 0x15e9
leaq 0x30d(%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 0x2dd(%rip), %rsi       # 0x21ee
movq %rbx, %rdi
movl $0x2, %edx
callq 0x15c4
cmpl %ebp, %eax
jne 0x1f3f
leaq 0x2c8(%rip), %rdi       # 0x21f1
xorl %eax, %eax
callq 0x10c0
leaq 0x261(%rip), %rax       # 0x2198
movl (%rax), %r14d
movl %r14d, %ebp
jmp 0x1f49
leaq 0x252(%rip), %rax       # 0x2198
movl (%rax), %r14d
leaq 0x2e1(%rip), %rdi       # 0x2231
callq 0x1040
leaq 0x28e(%rip), %rsi       # 0x21ea
movq %rbx, %rdi
movl $0x3, %edx
callq 0x15c4
cmpl %r14d, %eax
jne 0x1f7f
leaq 0x28a(%rip), %rdi       # 0x21ff
xorl %eax, %eax
callq 0x10c0
movl %r14d, %ebp
testl %ebp, %ebp
je 0x1f93
leaq 0x283(%rip), %rdi       # 0x220d
xorl %eax, %eax
callq 0x1a69
jmp 0x1fa1
leaq 0x289(%rip), %rdi       # 0x2223
xorl %eax, %eax
callq 0x10c0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xedc4
movq %rdi, %rbx
leaq 0x31354(%rip), %r13     # 0x40004
movq %rdi, %rbp
movzwl (%rbp), %eax
testb %al, %al
jle 0xedb7
xorl %r14d, %r14d
movq 0x18(%rbp,%r14,8), %r15
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0xecda
testq %r15, %r15
je 0xeda4
testb $0x1, 0xd1(%r15)
jne 0xeda4
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0xecfb
testb $0x2, 0x11(%rdi)
jne 0xeda4
movl (%r15), %r12d
shrl $0x8, %r12d
andl $0x1ff, %r12d           # imm = 0x1FF
cmpl $0xf, %r12d
jg 0xed31
leal -0x1(%r12), %eax
cmpl $0x7, %eax
ja 0xedd3
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movb $0x74, 0xd0(%r15)
jmp 0xed48
cmpl $0x7f, %r12d
jg 0xed56
cmpl $0x10, %r12d
je 0xed48
cmpl $0x40, %r12d
je 0xeda4
jmp 0xedd3
movq %r15, %rdi
callq 0xee83
movq 0x18(%r15), %rdi
jmp 0xed7c
cmpl $0x80, %r12d
je 0xed6a
cmpl $0x100, %r12d           # imm = 0x100
je 0xeda4
jmp 0xedd3
movb $0x64, 0xd0(%r15)
jmp 0xed7c
movb $0x6c, 0xd0(%r15)
testq %rdi, %rdi
je 0xeda4
movb 0xd1(%r15), %al
testb $0x1, %al
jne 0xeda4
orb $0x1, %al
movb %al, 0xd1(%r15)
leaq 0x5670c(%rip), %rdi     # 0x654a8
movq %r15, %rsi
callq 0x19dd0
incq %r14
movl (%rbp), %eax
movsbq %al, %rcx
cmpq %rcx, %r14
jl 0xecc2
movq 0x10(%rbp), %rbp
cmpq %rbx, %rbp
jne 0xecb3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1f261
movzbl (%r15), %ecx
leaq 0x31269(%rip), %rdi     # 0x4004c
movl %r12d, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0xf482
// File: /workspace/github_c_makefile_star2_O3/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 0xee78
movq 0x4(%r14), %r14
movq 0x4(%rbx), %r15
movl %r14d, %edi
shrl $0x6, %edi
movl $0x3fff, %ebp           # imm = 0x3FFF
andl %ebp, %edi
callq 0x1f1c0
movq %rax, %rbx
movl %r15d, %edi
shrl $0x6, %edi
andl %ebp, %edi
callq 0x1f1c0
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe1d0
testl %eax, %eax
jne 0xee78
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_O3/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 0xef54
movq %rdi, %rbx
movb 0xd1(%rdi), %al
testb $0x1, %al
jne 0xef54
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0xeeb1
testb $0x2, 0x11(%rcx)
jne 0xef54
movl (%rbx), %edx
cmpb $0x1, %dl
je 0xef54
movzbl %dl, %esi
cmpl $0xf, %esi
je 0xef54
testq %rcx, %rcx
je 0xeee6
orb $0x1, %al
movb %al, 0xd1(%rbx)
leaq 0x565cc(%rip), %rdi     # 0x654a8
movq %rbx, %rsi
callq 0x19dd0
movl (%rbx), %edx
movzbl %dl, %eax
addl $-0x2, %eax
cmpl $0x9, %eax
ja 0xef56
movq 0x60(%rbx), %rdi
leaq 0x31128(%rip), %rcx     # 0x40024
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0xee83
jmp 0xef44
movb $0x65, 0xd0(%rbx)
jmp 0xef05
movb $0x73, 0xd0(%rbx)
jmp 0xef38
testq %rdi, %rdi
je 0xef05
cmpb $0x5, (%rdi)
jne 0xef05
movb $0x66, 0xd0(%rbx)
jmp 0xef05
movb $0x75, 0xd0(%rbx)
movq 0x98(%rbx), %rdi
callq 0xef7e
cmpb $0x0, 0xd0(%rbx)
jne 0xef54
movb $0x76, 0xd0(%rbx)
popq %rbx
retq
movq 0x18(%rbx), %rdi
callq 0x1f261
movl (%rbx), %edx
movzbl %dl, %ecx
shrl $0x8, %edx
andl $0x1ff, %edx            # imm = 0x1FF
leaq 0x31100(%rip), %rdi     # 0x40074
movq %rax, %rsi
xorl %eax, %eax
callq 0xf482
// File: /workspace/github_c_makefile_star2_O3/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 0xefdb
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rdi, %r14
movzwl (%r14), %eax
testb %al, %al
jle 0xefcd
xorl %r15d, %r15d
movq 0x18(%r14,%r15,8), %rdi
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0xefae
testq %rdi, %rdi
je 0xefbe
movb $0x6d, 0xd0(%rdi)
callq 0xee83
movzwl (%r14), %eax
incq %r15
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r15
jl 0xef99
movq 0x10(%r14), %r14
cmpq %rbx, %r14
jne 0xef8e
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x445c(%rip), %xmm0     # 0x69c0
leaq 0xc(%rsp), %r12
movaps %xmm0, 0x14(%r12)
movaps 0x443a(%rip), %xmm0     # 0x69b0
movaps %xmm0, 0x4(%r12)
movaps 0x441d(%rip), %xmm0     # 0x69a0
movaps %xmm0, -0xc(%r12)
leaq 0x1ae0(%rip), %rcx      # 0x4070
leaq 0x1d26(%rip), %r14      # 0x42bd
leaq 0x1adb(%rip), %r15      # 0x4079
leaq 0x1ae3(%rip), %r13      # 0x4088
xorl %ebp, %ebp
movl (%rbx), %esi
incl %esi
movl %esi, (%rbx)
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2050
movl (%r12), %edi
leaq -0x4(%r12), %rsi
xorl %edx, %edx
callq 0x23e0
movl 0x4(%r12), %edx
cmpl %edx, %eax
jne 0x25e1
leaq 0x1abc(%rip), %rdi      # 0x4096
callq 0x2040
jmp 0x25ef
movq %r13, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x2050
incl %ebp
movq 0xc(%r12), %rcx
addq $0x18, %r12
testq %rcx, %rcx
jne 0x25a7
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_O3/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 0x4554(%rip), %xmm0     # 0x6ea0
leaq 0x28(%rsp), %r13
movaps %xmm0, 0x8(%r13)
movaps 0x4533(%rip), %xmm0     # 0x6e90
movaps %xmm0, -0x8(%r13)
movaps 0x4517(%rip), %xmm0     # 0x6e80
movaps %xmm0, -0x18(%r13)
leaq 0x16fb(%rip), %rcx      # 0x4070
leaq 0x1941(%rip), %r14      # 0x42bd
leaq 0x177c(%rip), %r15      # 0x40ff
leaq 0xc(%rsp), %r12
xorl %ebp, %ebp
movl (%rbx), %esi
incl %esi
movl %esi, (%rbx)
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2050
movl -0xc(%r13), %edi
leaq -0x10(%r13), %rsi
xorl %edx, %edx
movq %r12, %rcx
callq 0x2413
movl -0x8(%r13), %edx
cmpl %edx, %eax
jne 0x29d1
movl 0xc(%rsp), %esi
movl -0x4(%r13), %edx
cmpl %edx, %esi
jne 0x29dc
leaq 0x16cc(%rip), %rdi      # 0x4096
callq 0x2040
jmp 0x29ec
leaq 0x16b0(%rip), %rdi      # 0x4088
movl %eax, %esi
jmp 0x29e3
leaq 0x1734(%rip), %rdi      # 0x4117
xorl %eax, %eax
callq 0x2050
incl %ebp
movq (%r13), %rcx
addq $0x18, %r13
testq %rcx, %rcx
jne 0x298a
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x8, %eax
cmovbq %rax, %rsi
movq %rsi, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %rdx, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
shlq $0x4, %rsi
movl $0x1, %edi
callq 0x10a0
movq %rax, 0x28(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/yangtau[P]hedgehog/src/test/../hashset.c
// Function: hg_hashset_put
void hg_hashset_put(struct hg_hashset* set, void* item) {
    hashset_adjust(set);

    struct hg_hashset_bucket* bucket = hashset_find(set, item);

    switch (bucket->state) {
    case HG_HASHSET_BUCKET_EMPTY:
        bucket->state = HG_HASHSET_BUCKET_OCCUPIED;
        bucket->item  = item;
        set->len++;
        break;
    case HG_HASHSET_BUCKET_OCCUPIED:
        bucket->item = item;
        break;
    case HG_HASHSET_BUCKET_TOMBSTONE:
        bucket->state = HG_HASHSET_BUCKET_OCCUPIED;
        bucket->item  = item;
        set->tomb_cnt--;
        break;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r12
movq %r12, %rax
shrq $0x2, %rax
movq %r12, %rcx
subq %rax, %rcx
cmpq 0x8(%rdi), %rcx
jae 0x1960
leaq (%r12,%r12), %rsi
jmp 0x196d
movq %r12, %rsi
cmpq 0x10(%r14), %rax
jae 0x1a0c
testq %rsi, %rsi
je 0x1a0c
cmpq $0x9, %rsi
movl $0x8, %r13d
cmovbq %r13, %rsi
movq %rsi, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movups 0x18(%r14), %xmm0
movups %xmm0, 0x20(%rsp)
shlq $0x4, %rsi
movl $0x1, %edi
callq 0x10a0
movq %rax, 0x30(%rsp)
testq %r12, %r12
je 0x19e1
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
movq 0x28(%r14), %rax
cmpl $0x1, (%rax,%r13)
jne 0x19d5
movq -0x8(%rax,%r13), %rsi
movq %r15, %rdi
callq 0x1930
movq (%r14), %r12
incq %rbp
addq $0x10, %r13
cmpq %r12, %rbp
jb 0x19ba
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x1a5a
callq 0x1030
movups 0x8(%rsp), %xmm0
movups 0x18(%rsp), %xmm1
movups 0x28(%rsp), %xmm2
movups %xmm2, 0x20(%r14)
movups %xmm1, 0x10(%r14)
movups %xmm0, (%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a79
movl 0x8(%rax), %ecx
cmpl $0x2, %ecx
je 0x1a3d
cmpl $0x1, %ecx
je 0x1a38
testl %ecx, %ecx
jne 0x1a4b
movl $0x1, 0x8(%rax)
movq %rbx, (%rax)
incq 0x8(%r14)
jmp 0x1a4b
movq %rbx, (%rax)
jmp 0x1a4b
movl $0x1, 0x8(%rax)
movq %rbx, (%rax)
decq 0x10(%r14)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15ef(%rip), %rdi      # 0x3050
leaq 0x15ea(%rip), %rsi      # 0x3052
leaq 0x15ef(%rip), %rcx      # 0x305e
movl $0xf, %edx
callq 0x1090
// File: /workspace/github_c_makefile_star2_O3/yangtau[P]hedgehog/src/test/../hashset.c
// Function: hashset_find
static struct hg_hashset_bucket* hashset_find(struct hg_hashset* set, void* item) {
    uint32_t hash = set->hash(item) % set->capacity;

    struct hg_hashset_bucket* tombstone = NULL;
    for (size_t i = 0; i < set->capacity; i++) {
        struct hg_hashset_bucket* bucket = &set->buckets[hash];
        switch (bucket->state) {
        case HG_HASHSET_BUCKET_EMPTY:
            // If we found an empty bucket, we can stop searching, because we know the item is not in the set.
            return tombstone ? tombstone : bucket;
        case HG_HASHSET_BUCKET_OCCUPIED:
            if (set->eq(bucket->item, item))
                return bucket;
            break;
        case HG_HASHSET_BUCKET_TOMBSTONE:
            if (!tombstone)
                tombstone = bucket;
            break;
        }

        hash = (hash + 1) % set->capacity;
    }
    unreachable_();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq *0x18(%r14)
movq (%r14), %rcx
testq %rcx, %rcx
je 0x1afc
movl %eax, %eax
xorl %r13d, %r13d
xorl %edx, %edx
divq %rcx
movq %rdx, %r15
xorl %ebp, %ebp
movq 0x28(%r14), %rax
movl %r15d, %edx
shlq $0x4, %rdx
leaq (%rax,%rdx), %r12
movl 0x8(%rax,%rdx), %eax
cmpl $0x1, %eax
je 0x1ad4
cmpl $0x2, %eax
je 0x1acb
testl %eax, %eax
jne 0x1ae6
jmp 0x1b01
testq %rbp, %rbp
cmoveq %r12, %rbp
jmp 0x1ae6
movq (%r12), %rdi
movq %rbx, %rsi
callq *0x20(%r14)
testb %al, %al
jne 0x1b08
movq (%r14), %rcx
incl %r15d
movq %r15, %rax
xorl %edx, %edx
divq %rcx
incq %r13
movq %rdx, %r15
cmpq %rcx, %r13
jb 0x1aa8
callq 0x10f0
testq %rbp, %rbp
cmovneq %rbp, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/yangtau[P]hedgehog/src/test/../hashset.c
// Function: hg_hashset_remove
void* hg_hashset_remove(struct hg_hashset* set, void* item) {
    struct hg_hashset_bucket* bucket = hashset_find(set, item);
    if (bucket->state != HG_HASHSET_BUCKET_OCCUPIED)
        return NULL;

    bucket->state = HG_HASHSET_BUCKET_TOMBSTONE;
    set->tomb_cnt++;
    return bucket->item;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1a79
cmpl $0x1, 0x8(%rax)
jne 0x1b5d
movl $0x2, 0x8(%rax)
incq 0x10(%rbx)
movq (%rax), %rax
jmp 0x1b5f
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/yangtau[P]hedgehog/src/test/../hashset.c
// Function: hg_hashset_clear
void hg_hashset_clear(struct hg_hashset* set) {
    for (size_t i = 0; i < set->capacity; i++) {
        set->buckets[i].state = HG_HASHSET_BUCKET_EMPTY;
    }

    set->len      = 0;
    set->tomb_cnt = 0;
}

// Assembly:
movq (%rdi), %rdx
testq %rdx, %rdx
je 0x1c66
movq 0x28(%rdi), %rax
leaq 0x3(%rdx), %rcx
andq $-0x4, %rcx
decq %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
addq $0x38, %rax
movdqa 0x147e(%rip), %xmm1     # 0x3010
movdqa 0x1486(%rip), %xmm2     # 0x3020
movdqa 0x148e(%rip), %xmm3     # 0x3030
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movdqa 0x148e(%rip), %xmm5     # 0x3040
movdqa %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %edx
notl %edx
testb $0x1, %dl
je 0x1bed
movl $0x0, -0x30(%rax)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %edx
testb $0x1, %dl
je 0x1c02
movl $0x0, -0x20(%rax)
movdqa %xmm1, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
pxor %xmm4, %xmm6
pextrw $0x0, %xmm6, %edx
testb $0x1, %dl
je 0x1c40
movl $0x0, -0x10(%rax)
pextrw $0x4, %xmm6, %edx
testb $0x1, %dl
je 0x1c50
movl $0x0, (%rax)
paddq %xmm5, %xmm2
paddq %xmm5, %xmm1
addq $0x40, %rax
addq $-0x4, %rcx
jne 0x1bb2
pxor %xmm0, %xmm0
movdqu %xmm0, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/yangtau[P]hedgehog/src/test/../hashset.c
// Function: hg_hashset_foreach
void hg_hashset_foreach(struct hg_hashset* set, void (*fn)(void*)) {
    for (size_t i = 0; i < set->capacity; i++) {
        struct hg_hashset_bucket* bucket = &set->buckets[i];
        if (bucket->state == HG_HASHSET_BUCKET_OCCUPIED)
            fn(bucket->item);
    }
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x1cbb
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x8, %r15d
xorl %r12d, %r12d
movq 0x28(%r14), %rcx
cmpl $0x1, (%rcx,%r15)
jne 0x1ca4
movq -0x8(%rcx,%r15), %rdi
callq *%rbx
movq (%r14), %rax
incq %r12
addq $0x10, %r15
cmpq %rax, %r12
jb 0x1c8f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/yangtau[P]hedgehog/src/test/hashset_test.c
// Function: test_hashset_init
void test_hashset_init() {
    struct hg_hashset set;
    size_t Ns[] = {1, 2, 3, 4, 5, 7, 11, 13, 17, 19};

    for (size_t i = 0; i < sizeof(Ns) / sizeof(size_t); i++) {
        size_t N = Ns[i];

        test_println("hashset init %zu items", N);

        hg_hashset_init(&set, N, hash_int, eq_int);
        test_assert(hg_hashset_len(&set) == 0);

        // put N
        for (size_t i = 0; i < N; i++) {
            hg_hashset_put(&set, (void*)(uint64_t)i);
        }
        test_assert(hg_hashset_len(&set) == (size_t)N);

        // continas N?
        test_assert(!hg_hashset_contains(&set, (void*)(uint64_t)N));

        hg_hashset_destroy(&set);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x64d(%rip), %r15      # 0x1cca
leaq 0x8(%rsp), %r12
xorl %ebx, %ebx
leaq 0x114b(%rip), %rax      # 0x3470
movq (%rax,%rbx,8), %r14
leaq 0x106b(%rip), %rdi      # 0x339b
movq %r14, %rsi
xorl %eax, %eax
callq 0x1080
movq %r12, %rdi
movq %r14, %rsi
leaq -0x68b(%rip), %rdx      # 0x1cbc
movq %r15, %rcx
callq 0x18cc
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x23b0
cmpq $0x1, %r14
movq %r14, %r13
adcq $0x0, %r13
xorl %ebp, %ebp
movq %r12, %rdi
movq %rbp, %rsi
callq 0x1930
incq %rbp
cmpq %rbp, %r13
jne 0x2368
movq 0x10(%rsp), %rax
subq 0x18(%rsp), %rax
cmpq %r14, %rax
jne 0x23b7
movq %r12, %rdi
movq %r14, %rsi
callq 0x1b2f
testb %al, %al
jne 0x23be
movq %r12, %rdi
callq 0x1903
incq %rbx
cmpq $0xa, %rbx
jne 0x231e
jmp 0x23c5
callq 0x172a
jmp 0x235b
callq 0x1762
jmp 0x238a
callq 0x179a
jmp 0x2399
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Joy-Division[P]tools-mgs/dar-extract_pc.c
// Function: main
int main( int argc, char **argv ) {
	
	char name[32];
	uint32_t size, len;
	unsigned int remember;
	
	if( argc < 2 ) {
		printf("Not enough args!\nUse: %s PAK-file\n", argv[0]);
		return 1;
	}
	
	uint32_t numFiles, workfiles;
	FILE *f, *o;
	
	if( !(f = fopen( argv[1], "rb" ))) {
		printf("Couldnt open file %s\n", argv[1]);
		return 1;
	}
	
	fread( &numFiles, 4, 1, f );
	
	printf("Number of files: %u\n", numFiles );
	
	for( workfiles = 0; workfiles < numFiles; workfiles++ ) {
		remember = ftell(f);
		len = 0;
		while(fgetc(f)) len++;
		len++;
		fseek(f, remember, SEEK_SET);
		if((remember+len)%4) len+= 4-((remember+len)%4);
		if(len > 32) {
			printf("namelen > 32!\n");
			return 1;
		}
		fread(name, len, 1, f );
		fread( &size, 4, 1, f );
		printf("Current file: %s - Size %08x\n", name, size);
		
		if( !(o = fopen( name, "wb" ))) {
			printf("Couldnt open output %s\n", name);
			return 1;
		}
		
		writeFile( f, size, o );
		fclose(o);
		fseek(f, 1, SEEK_CUR);
	}
	printf("Done.\n");
	fclose(f);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
cmpl $0x1, %edi
jg 0x12ae
movq (%r14), %rsi
leaq 0xda9(%rip), %rdi       # 0x2052
jmp 0x142f
movq 0x8(%r14), %rdi
leaq 0xdbc(%rip), %rsi       # 0x2075
callq 0x10a0
testq %rax, %rax
je 0x1408
movq %rax, %rbx
leaq 0xc(%rsp), %r14
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rcx
callq 0x1040
movl (%r14), %ebp
leaq 0xda0(%rip), %rdi       # 0x208e
movl %ebp, %esi
xorl %eax, %eax
callq 0x1060
movl %ebp, 0x4(%rsp)
testl %ebp, %ebp
je 0x13f0
xorl %r13d, %r13d
movq %rbx, %rdi
callq 0x1080
movq %rax, %r15
xorl %ebp, %ebp
movl $0x4, %r12d
movl %r15d, %r14d
movq %rbx, %rdi
callq 0x1070
incl %ebp
incl %r12d
incb %r14b
testl %eax, %eax
jne 0x131c
movl %r15d, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1090
leal (%r15,%rbp), %eax
movzbl %r14b, %ecx
andl $0x3, %ecx
subl %ecx, %r12d
testb $0x3, %al
cmovel %ebp, %r12d
cmpl $0x21, %r12d
jae 0x1415
movl %r12d, %esi
movl $0x1, %edx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1040
movl $0x4, %esi
movl $0x1, %edx
leaq 0x8(%rsp), %rdi
movq %rbx, %rcx
callq 0x1040
movl 0x8(%rsp), %r15d
leaq 0xd0d(%rip), %rdi       # 0x20a3
movq %r14, %rsi
movl %r15d, %edx
xorl %eax, %eax
callq 0x1060
movq %r14, %rdi
leaq 0xd14(%rip), %rsi       # 0x20c1
callq 0x10a0
testq %rax, %rax
je 0x1423
movq %rax, %r12
movq %rbx, %rdi
movl %r15d, %esi
movq %rax, %rdx
callq 0x11cc
movq %r12, %rdi
callq 0x1050
movl $0x1, %esi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x1090
incl %r13d
cmpl 0x4(%rsp), %r13d
jne 0x1306
leaq 0xce5(%rip), %rdi       # 0x20dc
callq 0x1030
movq %rbx, %rdi
callq 0x1050
xorl %eax, %eax
jmp 0x143b
movq 0x8(%r14), %rsi
leaq 0xc65(%rip), %rdi       # 0x2078
jmp 0x142f
leaq 0xcc6(%rip), %rdi       # 0x20e2
callq 0x1030
jmp 0x1436
leaq 0xc9a(%rip), %rdi       # 0x20c4
leaq 0x10(%rsp), %rsi
xorl %eax, %eax
callq 0x1060
movl $0x1, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sushant8421[P]create_your_own_shell/searchstring.c
// Function: main
int main(int argc, char *argv[]) {
	int result, errno;

	if(argc < 4 || argc > 4) {
		Usage(argv[0]);
		exit(1);
	}

	result = Search_in_File(argv[2], argv[3] , argv[1]);
	if(result == -1) {
		perror("Error");
		printf("Error number = %d\n", errno);
		exit(1);
	}
	return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x4, %edi
jne 0x120f
movq 0x8(%rsi), %rdx
movq 0x10(%rsi), %rdi
movq 0x18(%rsi), %rsi
callq 0x1234
cmpl $-0x1, %eax
je 0x121e
xorl %eax, %eax
popq %rbp
retq
callq 0x1223
movl $0x1, %edi
callq 0x10a0
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O3/veltzer[P]xmeltdown/src/dance.c
// Function: ReadRoutineFile
int*ReadRoutineFile(char* filename)
{
	FILE* infile;
	int okayflag=1;
	int* retval;
	int numread=0;

	infile=fopen(filename, "r");
	if (infile == NULL) {
		fprintf(stderr, "Cannot open file %s\n", filename);
		exit(1);
	}
	retval=(int *) calloc (1, sizeof (int));
	numread=0;
	while (okayflag >= 0) {
		okayflag=fscanf(infile, "%d\n", &(retval[numread]));
		if (okayflag >= 0) {
			numread++;
			retval=(int *) realloc (retval, (numread+1)*sizeof (int));
		}
	}
	retval[numread]=-1;
	return (retval);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x17c8(%rip), %rsi      # 0x30ab
callq 0x10b0
testq %rax, %rax
je 0x1974
movq %rax, %rbx
movl $0x1, %edi
movl $0x4, %esi
callq 0x1170
movq %rax, %r14
leaq 0x1824(%rip), %rsi      # 0x3131
xorl %r13d, %r13d
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1050
testl %eax, %eax
js 0x195f
movl $0x8, %r15d
leaq 0x1803(%rip), %r12      # 0x3131
xorl %r13d, %r13d
movq %r14, %rdi
movq %r15, %rsi
callq 0x11a0
movq %rax, %r14
leaq (%rax,%r15), %rdx
addq $-0x4, %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x1050
addq $0x4, %r15
incq %r13
testl %eax, %eax
jns 0x1931
movl $0xffffffff, (%r14,%r13,4) # imm = 0xFFFFFFFF
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x1234