LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/EC.c
// Function: Derivative_c1c2
float Derivative_c1c2(float *f0, float Lambda, float c1c2, int N,
		      float *eval, float **evec, float *w_ev)
{
  // Derivative of -N<c>^2/<c^2> with respect to Lambda 
  double S1=0, S2=0, S3=0, eps=0.000001;
  int j;
  for(j=0; j< N; j++){
    if(w_ev[j] < W_MIN)continue;
    float diff=Lambda-eval[j];
    if(fabs(diff)<eps){if(diff>0){diff=eps;}else{diff=-eps;}}
    double w=w_ev[j]/diff; S1+=w;
    w/=diff; S2+=w;
    w/=diff; S3+=w;
  }
  (*f0)=c1c2 - (S1*S1)/S2;
  double f=2*S1*(1-(S1*S3)/(S2*S2));
  return(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd 0xe5f7(%rip), %xmm0     # 0x836e8
movsd %xmm0, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x7522b
movq -0x30(%rbp), %rax
movslq -0x54(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0xe5c6(%rip), %xmm0     # 0x836e8
ucomisd %xmm1, %xmm0
jbe 0x7512d
jmp 0x7521d
movss -0xc(%rbp), %xmm0
movq -0x20(%rbp), %rax
movslq -0x54(%rbp), %rcx
subss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x58(%rbp)
movss -0x58(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movaps 0x733c(%rip), %xmm0     # 0x7c490
pand %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x751a7
movss -0x58(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x75180
movsd -0x50(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x58(%rbp)
jmp 0x751a5
movsd -0x50(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x58(%rbp)
jmp 0x751a7
movq -0x30(%rbp), %rax
movslq -0x54(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
divss -0x58(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x60(%rbp), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movss -0x58(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x60(%rbp), %xmm0
addsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movss -0x58(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x60(%rbp), %xmm0
addsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x750fd
movss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd -0x38(%rbp), %xmm1
mulsd -0x38(%rbp), %xmm1
divsd -0x40(%rbp), %xmm1
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
movsd 0xdfd(%rip), %xmm0      # 0x76058
mulsd -0x38(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
mulsd -0x48(%rbp), %xmm2
movsd -0x40(%rbp), %xmm1
mulsd -0x40(%rbp), %xmm1
divsd %xmm1, %xmm2
movsd 0xdc8(%rip), %xmm1      # 0x76048
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x68(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/EC.c
// Function: Score_c1c2
float Score_c1c2(float Lambda, float c1c2, int N,
		 float *eval, float **evec, float *w_ev)
{
  double S1=0, S2=0, eps=0.000001;
  int j;
  for(j=0; j< N; j++){
    if(w_ev[j] < W_MIN)continue;
    float diff=Lambda-eval[j];
    if(fabs(diff)<eps){if(diff>0){diff=eps;}else{diff=-eps;}}
    double w=w_ev[j]/diff; S1+=w;
    w/=diff; S2+=w;
  }
  return(c1c2 - (S1*S1)/S2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0xe413(%rip), %xmm0     # 0x836e8
movsd %xmm0, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x753e9
movq -0x28(%rbp), %rax
movslq -0x44(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0xe3e2(%rip), %xmm0     # 0x836e8
ucomisd %xmm1, %xmm0
jbe 0x75311
jmp 0x753db
movss -0x4(%rbp), %xmm0
movq -0x18(%rbp), %rax
movslq -0x44(%rbp), %rcx
subss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x48(%rbp)
movss -0x48(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movaps 0x7158(%rip), %xmm0     # 0x7c490
pand %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x7538b
movss -0x48(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x75364
movsd -0x40(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x48(%rbp)
jmp 0x75389
movsd -0x40(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x48(%rbp)
jmp 0x7538b
movq -0x28(%rbp), %rax
movslq -0x44(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
divss -0x48(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movss -0x48(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x752e1
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd -0x30(%rbp), %xmm1
mulsd -0x30(%rbp), %xmm1
divsd -0x38(%rbp), %xmm1
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/gasdev.c
// Function: gasdev
float gasdev(long *idum)
{
  float ran2(long *idum);
  static int iset=0;
  static float gset;
  float fac,r,v1,v2;
  float ran1();
  
  if  (iset == 0) {
    do {
      v1=2.0*ran2(idum)-1.0;
      v2=2.0*ran2(idum)-1.0;
      r=v1*v1+v2*v2;
    } while (r >= 1.0);
    fac=sqrt(-2.0*log(r)/r);
    gset=v1*fac;
    iset=1;
    return v2*fac;
  } else {
    iset=0;
    return gset;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpl $0x0, 0x28685(%rip)     # 0x9daa8
jne 0x75518
jmp 0x7542b
movq -0x10(%rbp), %rdi
callq 0x75540
cvtss2sd %xmm0, %xmm0
addsd %xmm0, %xmm0
movsd 0xbec(%rip), %xmm1      # 0x76030
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x75540
cvtss2sd %xmm0, %xmm0
addsd %xmm0, %xmm0
movsd 0xbc6(%rip), %xmm1      # 0x76030
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x1c(%rbp), %xmm0
movss -0x1c(%rbp), %xmm2
movss -0x20(%rbp), %xmm1
mulss -0x20(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xb9f(%rip), %xmm1      # 0x76048
ucomisd %xmm1, %xmm0
jae 0x7542b
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x10f0
movaps %xmm0, %xmm1
movsd 0x6f8c(%rip), %xmm0     # 0x7c458
mulsd %xmm1, %xmm0
movss -0x18(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
callq 0x1220
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x1c(%rbp), %xmm0
mulss -0x14(%rbp), %xmm0
movss %xmm0, 0x285af(%rip)    # 0x9daac
movl $0x1, 0x285a1(%rip)     # 0x9daa8
movss -0x20(%rbp), %xmm0
mulss -0x14(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x7552f
movl $0x0, 0x28586(%rip)     # 0x9daa8
movss 0x28582(%rip), %xmm0    # 0x9daac
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/ran2.c
// Function: ran2
float ran2(long *idum)
{
  static long iy,ir[98];
  static int iff=0;
  int j;
  void nrerror();
  
  if (*idum < 0 || iff == 0) {
    iff=1;
    if ((*idum=(IC-(*idum)) % M) < 0) *idum = -(*idum);
    for (j=1;j<=97;j++) {
      *idum=(IA*(*idum)+IC) % M;
      ir[j]=(*idum);
    }
    *idum=(IA*(*idum)+IC) % M;
    iy=(*idum);
  }
  j=1 + 97.0*iy/M;
  if (j > 97 || j < 1) nrerror("RAN2: This cannot happen.");
  iy=ir[j];
  *idum=(IA*(*idum)+IC) % M;
  ir[j]=(*idum);
  return (float) iy/M;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jl 0x75563
cmpl $0x0, 0x28873(%rip)     # 0x9ddd0
jne 0x75620
movl $0x1, 0x28863(%rip)     # 0x9ddd0
movq -0x8(%rbp), %rcx
movl $0x24d69, %eax          # imm = 0x24D69
subq (%rcx), %rax
movl $0xae529, %ecx          # imm = 0xAE529
cqto
idivq %rcx
movq -0x8(%rbp), %rax
movq %rdx, (%rax)
cmpq $0x0, %rdx
jge 0x755a0
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
subq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0xc(%rbp)
cmpl $0x61, -0xc(%rbp)
jg 0x755f0
movq -0x8(%rbp), %rax
imulq $0x556, (%rax), %rax    # imm = 0x556
addq $0x24d69, %rax          # imm = 0x24D69
movl $0xae529, %ecx          # imm = 0xAE529
cqto
idivq %rcx
movq -0x8(%rbp), %rax
movq %rdx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movslq -0xc(%rbp), %rcx
leaq 0x284df(%rip), %rax     # 0x9dac0
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x755a7
movq -0x8(%rbp), %rax
imulq $0x556, (%rax), %rax    # imm = 0x556
addq $0x24d69, %rax          # imm = 0x24D69
movl $0xae529, %ecx          # imm = 0xAE529
cqto
idivq %rcx
movq -0x8(%rbp), %rax
movq %rdx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x28490(%rip)     # 0x9dab0
cvtsi2sdq 0x28487(%rip), %xmm0 # 0x9dab0
movsd 0xe1a7(%rip), %xmm1     # 0x837d8
mulsd %xmm0, %xmm1
movsd 0xe193(%rip), %xmm0     # 0x837d0
divsd %xmm0, %xmm1
movsd 0x9ff(%rip), %xmm0      # 0x76048
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0xc(%rbp)
cmpl $0x61, -0xc(%rbp)
jg 0x75660
cmpl $0x1, -0xc(%rbp)
jge 0x7566e
leaq 0xe17d(%rip), %rdi      # 0x837e4
movb $0x0, %al
callq 0x6ba20
movslq -0xc(%rbp), %rcx
leaq 0x28447(%rip), %rax     # 0x9dac0
movq (%rax,%rcx,8), %rax
movq %rax, 0x2842c(%rip)     # 0x9dab0
movq -0x8(%rbp), %rax
imulq $0x556, (%rax), %rax    # imm = 0x556
addq $0x24d69, %rax          # imm = 0x24D69
movl $0xae529, %ecx          # imm = 0xAE529
cqto
idivq %rcx
movq -0x8(%rbp), %rax
movq %rdx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movslq -0xc(%rbp), %rcx
leaq 0x28408(%rip), %rax     # 0x9dac0
movq %rdx, (%rax,%rcx,8)
cvtsi2ssq 0x283eb(%rip), %xmm0 # 0x9dab0
movss 0xe113(%rip), %xmm1     # 0x837e0
divss %xmm1, %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/random3.c
// Function: InitRandom
void InitRandom( RANDOMTYPE seed)
{
  int i, j;
  RANDOMTYPE random, composite;
  
  /* check size of RANDOMTYPE */
  if( sizeof( RANDOMTYPE) != 8)
    {
      fprintf( stderr, "Wrong size for RANDOMTYPE.\n");
    }
  
  /* create array of random numbers */
  random= seed;
  for( i= 0; i < 16384; i++)
    {
      composite= (RANDOMTYPE)0;
      for( j= 0; j < 31; j++)
	{
	  /* overflow ? */
	  if( (random *= MULTIPLIER) > RANDOMLIMIT){
	    random -= (RANDOMLIMIT+1);
	  }	  
	  /* use only most significant bit */
	  composite= (composite << 1) | ((random >> 30) & 1);
	}
      random_array[i]= composite;
    }
  
  /* initialize the pointer */
  random_which1= random_array+10000;
  random_which2= random_array+10000-471;
  random_which3= random_array+10000-1586;
  random_which4= random_array+10000-6988;
  random_which5= random_array+10000-9689;
  random_end= random_array+16384;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x4000, -0xc(%rbp)     # imm = 0x4000
jge 0x75788
movq $0x0, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x1f, -0x10(%rbp)
jge 0x75767
imulq $0x41a7, -0x18(%rbp), %rax # imm = 0x41A7
movq %rax, -0x18(%rbp)
cmpq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
jbe 0x75742
movq -0x18(%rbp), %rax
movabsq $0x80000000, %rcx       # imm = 0x80000000
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
shlq %rax
movq -0x18(%rbp), %rcx
shrq $0x1e, %rcx
andq $0x1, %rcx
orq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x75713
movq -0x20(%rbp), %rdx
movslq -0xc(%rbp), %rcx
leaq 0x2866a(%rip), %rax     # 0x9dde0
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x756f7
leaq 0x28651(%rip), %rax     # 0x9dde0
addq $0x13880, %rax          # imm = 0x13880
movq %rax, 0x48644(%rip)     # 0xbdde0
leaq 0x2863d(%rip), %rax     # 0x9dde0
addq $0x13880, %rax          # imm = 0x13880
addq $-0xeb8, %rax           # imm = 0xF148
movq %rax, 0x48632(%rip)     # 0xbdde8
leaq 0x28623(%rip), %rax     # 0x9dde0
addq $0x13880, %rax          # imm = 0x13880
addq $-0x3190, %rax          # imm = 0xCE70
movq %rax, 0x48620(%rip)     # 0xbddf0
leaq 0x28609(%rip), %rax     # 0x9dde0
addq $0x13880, %rax          # imm = 0x13880
addq $-0xda60, %rax          # imm = 0xFFFF25A0
movq %rax, 0x4860e(%rip)     # 0xbddf8
leaq 0x285ef(%rip), %rax     # 0x9dde0
addq $0x13880, %rax          # imm = 0x13880
addq $-0x12ec8, %rax         # imm = 0xFFFED138
movq %rax, 0x485fc(%rip)     # 0xbde00
leaq 0x285d5(%rip), %rax     # 0x9dde0
addq $0x20000, %rax          # imm = 0x20000
movq %rax, 0x485f0(%rip)     # 0xbde08
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/random3.c
// Function: Random
RANDOMTYPE Random()
{
  /* create random number */
  if( ++random_which1 == random_end)
    {
      random_which1= random_array;
    }
  if( ++random_which2 == random_end)
    {
      random_which2= random_array;
    }
  if( ++random_which3 == random_end)
    {
      random_which3= random_array;
    }
  if( ++random_which4 == random_end)
    {
      random_which4= random_array;
    }
  if( ++random_which5 == random_end)
    {
      random_which5= random_array;
    }
  
  return( *random_which1=
	  *random_which2 ^ *random_which3 ^ *random_which4 ^ *random_which5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x485b5(%rip), %rax     # 0xbdde0
addq $0x8, %rax
movq %rax, 0x485aa(%rip)     # 0xbdde0
cmpq 0x485cb(%rip), %rax     # 0xbde08
jne 0x7584d
leaq 0x2859a(%rip), %rax     # 0x9dde0
movq %rax, 0x48593(%rip)     # 0xbdde0
movq 0x48594(%rip), %rax     # 0xbdde8
addq $0x8, %rax
movq %rax, 0x48589(%rip)     # 0xbdde8
cmpq 0x485a2(%rip), %rax     # 0xbde08
jne 0x75876
leaq 0x28571(%rip), %rax     # 0x9dde0
movq %rax, 0x48572(%rip)     # 0xbdde8
movq 0x48573(%rip), %rax     # 0xbddf0
addq $0x8, %rax
movq %rax, 0x48568(%rip)     # 0xbddf0
cmpq 0x48579(%rip), %rax     # 0xbde08
jne 0x7589f
leaq 0x28548(%rip), %rax     # 0x9dde0
movq %rax, 0x48551(%rip)     # 0xbddf0
movq 0x48552(%rip), %rax     # 0xbddf8
addq $0x8, %rax
movq %rax, 0x48547(%rip)     # 0xbddf8
cmpq 0x48550(%rip), %rax     # 0xbde08
jne 0x758c8
leaq 0x2851f(%rip), %rax     # 0x9dde0
movq %rax, 0x48530(%rip)     # 0xbddf8
movq 0x48531(%rip), %rax     # 0xbde00
addq $0x8, %rax
movq %rax, 0x48526(%rip)     # 0xbde00
cmpq 0x48527(%rip), %rax     # 0xbde08
jne 0x758f1
leaq 0x284f6(%rip), %rax     # 0x9dde0
movq %rax, 0x4850f(%rip)     # 0xbde00
movq 0x484f0(%rip), %rax     # 0xbdde8
movq (%rax), %rax
movq 0x484ee(%rip), %rcx     # 0xbddf0
xorq (%rcx), %rax
movq 0x484ec(%rip), %rcx     # 0xbddf8
xorq (%rcx), %rax
movq 0x484ea(%rip), %rcx     # 0xbde00
xorq (%rcx), %rax
movq 0x484c0(%rip), %rcx     # 0xbdde0
movq %rax, (%rcx)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/random3.c
// Function: RandomFloating
double RandomFloating()
{
  /* create random number */
  if( ++random_which1 == random_end)
    {
      random_which1= random_array;
    }
  if( ++random_which2 == random_end)
    {
      random_which2= random_array;
    }
  if( ++random_which3 == random_end)
    {
      random_which3= random_array;
    }
  if( ++random_which4 == random_end)
    {
      random_which4= random_array;
    }
  if( ++random_which5 == random_end)
    {
      random_which5= random_array;
    }
  
  return( INVRANDOMLIMITFLOATING*
	  (double)(*random_which1=
		   *random_which2 ^ *random_which3 ^ 
		   *random_which4 ^ *random_which5));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x484a5(%rip), %rax     # 0xbdde0
addq $0x8, %rax
movq %rax, 0x4849a(%rip)     # 0xbdde0
cmpq 0x484bb(%rip), %rax     # 0xbde08
jne 0x7595d
leaq 0x2848a(%rip), %rax     # 0x9dde0
movq %rax, 0x48483(%rip)     # 0xbdde0
movq 0x48484(%rip), %rax     # 0xbdde8
addq $0x8, %rax
movq %rax, 0x48479(%rip)     # 0xbdde8
cmpq 0x48492(%rip), %rax     # 0xbde08
jne 0x75986
leaq 0x28461(%rip), %rax     # 0x9dde0
movq %rax, 0x48462(%rip)     # 0xbdde8
movq 0x48463(%rip), %rax     # 0xbddf0
addq $0x8, %rax
movq %rax, 0x48458(%rip)     # 0xbddf0
cmpq 0x48469(%rip), %rax     # 0xbde08
jne 0x759af
leaq 0x28438(%rip), %rax     # 0x9dde0
movq %rax, 0x48441(%rip)     # 0xbddf0
movq 0x48442(%rip), %rax     # 0xbddf8
addq $0x8, %rax
movq %rax, 0x48437(%rip)     # 0xbddf8
cmpq 0x48440(%rip), %rax     # 0xbde08
jne 0x759d8
leaq 0x2840f(%rip), %rax     # 0x9dde0
movq %rax, 0x48420(%rip)     # 0xbddf8
movq 0x48421(%rip), %rax     # 0xbde00
addq $0x8, %rax
movq %rax, 0x48416(%rip)     # 0xbde00
cmpq 0x48417(%rip), %rax     # 0xbde08
jne 0x75a01
leaq 0x283e6(%rip), %rax     # 0x9dde0
movq %rax, 0x483ff(%rip)     # 0xbde00
movq 0x483e0(%rip), %rax     # 0xbdde8
movq (%rax), %rax
movq 0x483de(%rip), %rcx     # 0xbddf0
movq (%rcx), %rcx
xorq %rcx, %rax
movq 0x483d9(%rip), %rcx     # 0xbddf8
movq (%rcx), %rcx
xorq %rcx, %rax
movq 0x483d4(%rip), %rcx     # 0xbde00
movq (%rcx), %rcx
xorq %rcx, %rax
movq 0x483a7(%rip), %rcx     # 0xbdde0
movq %rax, (%rcx)
movq %rax, %xmm1
movaps 0xddc8(%rip), %xmm0     # 0x83810
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movapd 0xddcc(%rip), %xmm0     # 0x83820
subpd %xmm0, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movsd 0xdd95(%rip), %xmm0     # 0x83800
mulsd %xmm1, %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/random3.c
// Function: Norm_var_2
float Norm_var_2(){
  // Draws squared Gaussian variable z^2 with Box-Muller transform method
  float U1=RandomFloating();
  float U2=RandomFloating();
  float c=cos(TWOPI*U2);
  return(-2*log(U1)*c*c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x75930
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
callq 0x75930
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0xdd53(%rip), %xmm0     # 0x83808
mulsd %xmm1, %xmm0
callq 0x1100
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x10f0
movaps %xmm0, %xmm1
movsd 0x6978(%rip), %xmm0     # 0x7c458
mulsd %xmm1, %xmm0
movss -0xc(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
movss -0xc(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/CarlosLunaMota[P]BinaryTrees/main.c
// Function: MyComp
int MyComp(const void *ptr1, const void *ptr2) {
    MyData *d1 = (MyData *) ptr1;
    MyData *d2 = (MyData *) ptr2; 
    if      (d1->key < d2->key) { return -1; }
    else if (d1->key > d2->key) { return +1; }
    else                        { return  0; }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x1213
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1231
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x122a
movl $0x1, -0x4(%rbp)
jmp 0x1231
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CarlosLunaMota[P]BinaryTrees/BinaryTrees.c
// Function: new_bs_tree
bs_tree *new_bs_tree(int (* comp) (const void *, const void *)) {

    // Sanity check:
    assert(comp != NULL);

    // Allocate memory:
    bs_tree *tree = (bs_tree *) malloc(sizeof(bs_tree));
    if (tree == NULL) {
        fprintf(stderr, "ERROR: Unable to allocate memory for bs_tree\n");
    }

    // Initialize the empty tree:
    else {
        tree->root = NULL;
        tree->comp = comp;
    }

    return tree;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc5d5
jmp 0xc5f4
leaq 0x9c13(%rip), %rdi      # 0x161ef
leaq 0x9c19(%rip), %rsi      # 0x161fc
movl $0x52, %edx
leaq 0x9c1b(%rip), %rcx      # 0x1620a
callq 0x1060
movl $0x10, %edi
callq 0x10a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc623
movq 0xd9e8(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
leaq 0x9c2a(%rip), %rsi      # 0x16244
movb $0x0, %al
callq 0x1080
jmp 0xc63a
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CarlosLunaMota[P]BinaryTrees/BinaryTrees.c
// Function: bs_tree_insert_min
void *bs_tree_insert_min(bs_tree *tree, void *data) {

    bs_node *node;
    bs_node *new_node;
    void    *old_data;

    // Sanity Checks:
    assert(tree != NULL);
    assert(data != NULL);

    // Trivial case:
    if (tree->root == NULL) { node = NULL; }

    // General case:
    else {
        node = tree->root;
        while (node->left != NULL) { node = node->left; }

        // If "data" is already there: overwrite it & return!
        if ((tree->comp)(data, node->data) == 0) {
            old_data   = node->data;
            node->data = data;
            return old_data;
        }
    }

    // Finally: Insert the new node here
    new_node = (bs_node *) malloc(sizeof(bs_node));
    if (new_node == NULL) {
        fprintf(stderr, "ERROR: Unable to allocate bs_node\n");
    } else {
        new_node->data  = data;
        new_node->left  = NULL;
        new_node->right = NULL;
    }
    if (node == NULL) { tree->root = new_node; }
    else              { node->left = new_node; }

    // Data was not here!
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xca49
jmp 0xca68
leaq 0x9822(%rip), %rdi      # 0x16272
leaq 0x97a5(%rip), %rsi      # 0x161fc
movl $0x109, %edx            # imm = 0x109
leaq 0x989b(%rip), %rcx      # 0x162fe
callq 0x1060
cmpq $0x0, -0x18(%rbp)
je 0xca71
jmp 0xca90
leaq 0x9879(%rip), %rdi      # 0x162f1
leaq 0x977d(%rip), %rsi      # 0x161fc
movl $0x10a, %edx            # imm = 0x10A
leaq 0x9873(%rip), %rcx      # 0x162fe
callq 0x1060
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xcaa4
movq $0x0, -0x20(%rbp)
jmp 0xcb04
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xcac8
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xcaaf
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0xcb02
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcb7e
jmp 0xcb04
movl $0x18, %edi
callq 0x10a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xcb33
movq 0xd4d8(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
leaq 0x977c(%rip), %rsi      # 0x162a6
movb $0x0, %al
callq 0x1080
jmp 0xcb56
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x10(%rax)
cmpq $0x0, -0x20(%rbp)
jne 0xcb6a
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0xcb76
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CarlosLunaMota[P]BinaryTrees/BinaryTrees.c
// Function: bs_tree_insert_max
void *bs_tree_insert_max(bs_tree *tree, void *data) {

    bs_node *node;
    bs_node *new_node;
    void    *old_data;

    // Sanity Checks:
    assert(tree != NULL);
    assert(data != NULL);

    // Trivial case:
    if (tree->root == NULL) { node = NULL; }

    // General case:
    else {
        node = tree->root;
        while (node->right != NULL) { node = node->right; }

        // If "data" is already there: overwrite it & return!
        if ((tree->comp)(data, node->data) == 0) {
            old_data   = node->data;
            node->data = data;
            return old_data;
        }
    }

    // Finally: Insert the new node here
    new_node = (bs_node *) malloc(sizeof(bs_node));
    if (new_node == NULL) {
        fprintf(stderr, "ERROR: Unable to allocate bs_node\n");
    } else {
        new_node->data  = data;
        new_node->left  = NULL;
        new_node->right = NULL;
    }
    if (node == NULL) { tree->root  = new_node; }
    else              { node->right = new_node; }

    // Data was not here!
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xcba9
jmp 0xcbc8
leaq 0x96c2(%rip), %rdi      # 0x16272
leaq 0x9645(%rip), %rsi      # 0x161fc
movl $0x13e, %edx            # imm = 0x13E
leaq 0x9767(%rip), %rcx      # 0x1632a
callq 0x1060
cmpq $0x0, -0x18(%rbp)
je 0xcbd1
jmp 0xcbf0
leaq 0x9719(%rip), %rdi      # 0x162f1
leaq 0x961d(%rip), %rsi      # 0x161fc
movl $0x13f, %edx            # imm = 0x13F
leaq 0x973f(%rip), %rcx      # 0x1632a
callq 0x1060
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xcc04
movq $0x0, -0x20(%rbp)
jmp 0xcc64
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xcc28
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xcc0f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0xcc62
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xccde
jmp 0xcc64
movl $0x18, %edi
callq 0x10a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xcc93
movq 0xd378(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
leaq 0x961c(%rip), %rsi      # 0x162a6
movb $0x0, %al
callq 0x1080
jmp 0xccb6
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x10(%rax)
cmpq $0x0, -0x20(%rbp)
jne 0xccca
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0xccd6
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CarlosLunaMota[P]BinaryTrees/BinaryTrees.c
// Function: bs_tree_is_empty
int bs_tree_is_empty(const bs_tree *tree) {

    // Sanity check:
    assert(tree != NULL);

    // Check if there is at least 1 node in the tree:
    if (tree->root == NULL) { return YES; }
    else                    { return NO;  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xcd05
jmp 0xcd24
leaq 0x9566(%rip), %rdi      # 0x16272
leaq 0x94e9(%rip), %rsi      # 0x161fc
movl $0x16a, %edx            # imm = 0x16A
leaq 0x9637(%rip), %rcx      # 0x16356
callq 0x1060
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xcd37
movl $0x1, -0x4(%rbp)
jmp 0xcd3e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CarlosLunaMota[P]BinaryTrees/BinaryTrees.c
// Function: bs_tree_search
void *bs_tree_search(const bs_tree *tree, const void *data) {

    bs_node *node;
    int      comp;

    // Sanity Checks:
    assert(tree != NULL);
    assert(data != NULL);

    // Search:
    node = tree->root;
    while (node != NULL) {
        comp = (tree->comp)(data, node->data);      // compare data
        if      (comp < 0) { node = node->left;  }  // data is smaller
        else if (comp > 0) { node = node->right; }  // data is bigger
        else               { return node->data;  }  // found!
    }

    // Not found:
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xcd69
jmp 0xcd88
leaq 0x9502(%rip), %rdi      # 0x16272
leaq 0x9485(%rip), %rsi      # 0x161fc
movl $0x179, %edx            # imm = 0x179
leaq 0x95f9(%rip), %rcx      # 0x1637c
callq 0x1060
cmpq $0x0, -0x18(%rbp)
je 0xcd91
jmp 0xcdb0
leaq 0x9559(%rip), %rdi      # 0x162f1
leaq 0x945d(%rip), %rsi      # 0x161fc
movl $0x17a, %edx            # imm = 0x17A
leaq 0x95d1(%rip), %rcx      # 0x1637c
callq 0x1060
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xce13
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0xcdee
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xce11
cmpl $0x0, -0x24(%rbp)
jle 0xce02
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xce0f
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xce1b
jmp 0xce11
jmp 0xcdbb
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CarlosLunaMota[P]BinaryTrees/BinaryTrees.c
// Function: bs_tree_min
void *bs_tree_min(const bs_tree *tree) {

    bs_node *node;

    // Sanity check:
    assert(tree != NULL);

    // Trivial case: empty tree
    if (tree->root == NULL) { return NULL; }

    // General case: Find the smallest node
    node = tree->root;
    while (node->left != NULL) { node = node->left; }

    // Return a pointer to the data:
    return node->data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xce45
jmp 0xce64
leaq 0x9426(%rip), %rdi      # 0x16272
leaq 0x93a9(%rip), %rsi      # 0x161fc
movl $0x191, %edx            # imm = 0x191
leaq 0x9551(%rip), %rcx      # 0x163b0
callq 0x1060
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xce78
movq $0x0, -0x8(%rbp)
jmp 0xcea7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xce9c
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xce83
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CarlosLunaMota[P]BinaryTrees/BinaryTrees.c
// Function: bs_tree_max
void *bs_tree_max(const bs_tree *tree) {

    bs_node *node;

    // Sanity check:
    assert(tree != NULL);

    // Trivial case: empty tree
    if (tree->root == NULL) { return NULL; }

    // General case: Find the biggest node
    node = tree->root;
    while (node->right != NULL) { node = node->right; }

    // Return a pointer to the data:
    return node->data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xced5
jmp 0xcef4
leaq 0x9396(%rip), %rdi      # 0x16272
leaq 0x9319(%rip), %rsi      # 0x161fc
movl $0x1a6, %edx            # imm = 0x1A6
leaq 0x94e4(%rip), %rcx      # 0x163d3
callq 0x1060
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xcf08
movq $0x0, -0x8(%rbp)
jmp 0xcf37
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xcf2c
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xcf13
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CarlosLunaMota[P]BinaryTrees/BinaryTrees.c
// Function: bs_tree_prev
void *bs_tree_prev(const bs_tree *tree, const void *data) {

    bs_node *node;
    bs_node *pred;
    int      comp;

    // Sanity Checks:
    assert(tree != NULL);
    assert(data != NULL);

    // Search:
    pred = NULL;
    node = tree->root;
    while (node != NULL) {

        // Compare data:
        comp = (tree->comp)(data, node->data);

        // Data is smaller:
        if (comp < 0) { node = node->left; }

        // Data is bigger:
        else if (comp > 0) {
            pred = node;
            node = node->right;
        }

        // We have found the node:
        else if (node->left != NULL) {
            pred = node->left;
            while (pred->right != NULL) { pred = pred->right; }
            break;
        } else { break; }
    }

    // Return predecesor:
    if (pred == NULL) { return NULL; }
    return pred->data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xcf69
jmp 0xcf88
leaq 0x9302(%rip), %rdi      # 0x16272
leaq 0x9285(%rip), %rsi      # 0x161fc
movl $0x1bf, %edx            # imm = 0x1BF
leaq 0x9473(%rip), %rcx      # 0x163f6
callq 0x1060
cmpq $0x0, -0x18(%rbp)
je 0xcf91
jmp 0xcfb0
leaq 0x9359(%rip), %rdi      # 0x162f1
leaq 0x925d(%rip), %rsi      # 0x161fc
movl $0x1c0, %edx            # imm = 0x1C0
leaq 0x944b(%rip), %rcx      # 0x163f6
callq 0x1060
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xd051
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0xcffa
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xd04c
cmpl $0x0, -0x2c(%rbp)
jle 0xd016
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xd04a
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd048
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xd046
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xd02d
jmp 0xd051
jmp 0xd051
jmp 0xd04c
jmp 0xcfc3
cmpq $0x0, -0x28(%rbp)
jne 0xd062
movq $0x0, -0x8(%rbp)
jmp 0xd06d
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CarlosLunaMota[P]BinaryTrees/BinaryTrees.c
// Function: bs_tree_next
void *bs_tree_next(const bs_tree *tree, const void *data) {

    bs_node *node;
    bs_node *succ;
    int      comp;

    // Sanity Checks:
    assert(tree != NULL);
    assert(data != NULL);

    // Search:
    succ = NULL;
    node = tree->root;
    while (node != NULL) {

        // Compare data:
        comp = (tree->comp)(data, node->data);

        // Data is smaller:
        if (comp < 0) {
            succ = node;
            node = node->left;
        }

        // Data is bigger:
        else if (comp > 0) { node = node->right; }

        // We have found the node:
        else if (node->right != NULL) {
            succ = node->right;
            while (succ->left != NULL) { succ = succ->left; }
            break;
        } else { break; }
    }

    // Return succesor:
    if (succ == NULL) { return NULL; }
    return succ->data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xd099
jmp 0xd0b8
leaq 0x91d2(%rip), %rdi      # 0x16272
leaq 0x9155(%rip), %rsi      # 0x161fc
movl $0x1ec, %edx            # imm = 0x1EC
leaq 0x9375(%rip), %rcx      # 0x16428
callq 0x1060
cmpq $0x0, -0x18(%rbp)
je 0xd0c1
jmp 0xd0e0
leaq 0x9229(%rip), %rdi      # 0x162f1
leaq 0x912d(%rip), %rsi      # 0x161fc
movl $0x1ed, %edx            # imm = 0x1ED
leaq 0x934d(%rip), %rcx      # 0x16428
callq 0x1060
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xd181
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0xd132
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xd17c
cmpl $0x0, -0x2c(%rbp)
jle 0xd146
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xd17a
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xd178
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd176
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xd15d
jmp 0xd181
jmp 0xd181
jmp 0xd17c
jmp 0xd0f3
cmpq $0x0, -0x28(%rbp)
jne 0xd192
movq $0x0, -0x8(%rbp)
jmp 0xd19d
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CarlosLunaMota[P]BinaryTrees/BinaryTrees.c
// Function: bs_tree_remove_min
void *bs_tree_remove_min(bs_tree *tree) {

    bs_node *node;
    bs_node *parent;
    void    *old_data;

    // Sanity check:
    assert(tree != NULL);

    // Avoid trivial case: empty tree
    old_data = NULL;
    if (tree->root != NULL) {

        // General case: Find the smallest node
        parent = NULL;
        node   = tree->root;
        while (node->left != NULL) {
            parent = node;
            node   = node->left;
        }
        old_data = node->data;

        // Remove Node:
        if (parent != NULL) { parent->left = node->right; }
        else                { tree->root   = node->right; }
        free(node);
    }
    return old_data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xd3e5
jmp 0xd404
leaq 0x8e86(%rip), %rdi      # 0x16272
leaq 0x8e09(%rip), %rsi      # 0x161fc
movl $0x277, %edx            # imm = 0x277
leaq 0x9089(%rip), %rcx      # 0x16488
callq 0x1060
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xd486
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd44a
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xd429
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xd46e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xd47d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x10e0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/CarlosLunaMota[P]BinaryTrees/BinaryTrees.c
// Function: bs_tree_remove_max
void *bs_tree_remove_max(bs_tree *tree) {

    bs_node *node;
    bs_node *parent;
    void        *old_data;

    // Sanity check:
    assert(tree != NULL);

    // Avoid trivial case: empty tree
    old_data = NULL;
    if (tree->root != NULL) {

        // General case: Find the biggest node
        parent = NULL;
        node   = tree->root;
        while (node->right != NULL) {
            parent = node;
            node   = node->right;
        }
        old_data = node->data;

        // Remove Node:
        if (parent != NULL) { parent->right = node->left; }
        else                { tree->root    = node->left; }
        free(node);
    }
    return old_data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xd4a5
jmp 0xd4c4
leaq 0x8dc6(%rip), %rdi      # 0x16272
leaq 0x8d49(%rip), %rsi      # 0x161fc
movl $0x29b, %edx            # imm = 0x29B
leaq 0x8fed(%rip), %rcx      # 0x164ac
callq 0x1060
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xd546
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xd50a
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xd4e9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xd52e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xd53d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x10e0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/CarlosLunaMota[P]BinaryTrees/BinaryTrees.c
// Function: bs_tree_remove_all
void bs_tree_remove_all(bs_tree *tree, void (* free_data) (void *)) {

    bs_node *root;
    bs_node *left;
    bs_node *right;

    // Sanity check:
    assert(tree != NULL);

    // Initialize:
    root = tree->root;
    tree->root = NULL;

    // While the tree is not empty:
    while (root != NULL) {

        // Unravel the tree: Rotate right "root" & "left"
        if (root->left != NULL) {
            left        = root->left;
            right       = left->right;
            left->right = root;
            root->left  = right;
            root        = left;

        // Erase the current "root" node:
        } else {
            right = root->right;
            if (free_data != NULL) { free_data(root->data); }
            free(root);
            root = right;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xd569
jmp 0xd588
leaq 0x8d02(%rip), %rdi      # 0x16272
leaq 0x8c85(%rip), %rsi      # 0x161fc
movl $0x2cc, %edx            # imm = 0x2CC
leaq 0x8f4d(%rip), %rcx      # 0x164d0
callq 0x1060
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0xd61d
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd5ea
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xd61b
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xd60a
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x18(%rbp), %rdi
callq 0x10e0
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xd59e
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CarlosLunaMota[P]BinaryTrees/BinaryTrees.c
// Function: bs_tree_to_list
void bs_tree_to_list(bs_tree *tree) {

    bs_node *node;
    bs_node *left;
    bs_node *right;
    bs_node *parent;

    // Sanity check:
    assert(tree != NULL);

    // Avoid trivial case: empty tree
    if (tree->root != NULL) {

        node = tree->root;

        // Unravel the left side of root:
        while (node->left != NULL) {

            // Rotate right:
            left        = node->left;
            right       = left->right;
            left->right = node;
            node->left  = right;

            // Move to the new root:
            node = left;
        }

        // Fix the root:
        tree->root = node;
        parent     = NULL;

        // Unravel the rest of the tree:
        while (node != NULL) {

            if (node->left != NULL) {

                // Rotate right:
                left          = node->left;
                right         = left->right;
                left->right   = node;
                node->left    = right;
                parent->right = left;

                // Move up:
                node = left;

            } else {

                // Move down:
                parent = node;
                node   = node->right;
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf575
jmp 0xf594
leaq 0x6cf6(%rip), %rdi      # 0x16272
leaq 0x6c79(%rip), %rsi      # 0x161fc
movl $0x6f1, %edx            # imm = 0x6F1
leaq 0x7081(%rip), %rcx      # 0x16610
callq 0x1060
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xf675
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xf5f2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xf5ad
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xf673
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xf65d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xf671
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xf605
jmp 0xf675
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CarlosLunaMota[P]BinaryTrees/BinaryTrees.c
// Function: bs_tree_to_reversed_list
void bs_tree_to_reversed_list(bs_tree *tree) {

    bs_node *node;
    bs_node *left;
    bs_node *right;
    bs_node *parent;

    // Sanity check:
    assert(tree != NULL);

    // Avoid trivial case: empty tree
    if (tree->root != NULL) {

        node = tree->root;

        // Unravel the right side of root:
        while (node->right != NULL) {

            // Rotate left:
            right       = node->right;
            left        = right->left;
            right->left = node;
            node->right = left;

            // Move to the new root:
            node = right;
        }

        // Fix the root:
        tree->root = node;
        parent     = NULL;

        // Unravel the rest of the tree:
        while (node != NULL) {

            if (node->right != NULL) {

                // Rotate left:
                right        = node->right;
                left         = right->left;
                right->left  = node;
                node->right  = left;
                parent->left = right;

                // Move up:
                node = right;

            } else {

                // Move down:
                parent = node;
                node   = node->left;
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf695
jmp 0xf6b4
leaq 0x6bd6(%rip), %rdi      # 0x16272
leaq 0x6b59(%rip), %rsi      # 0x161fc
movl $0x730, %edx            # imm = 0x730
leaq 0x6f81(%rip), %rcx      # 0x16630
callq 0x1060
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xf795
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xf712
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xf6cd
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xf793
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xf77d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xf791
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xf725
jmp 0xf795
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)