LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/choldc.c
// Function: Cholevsky_inversion
double **Cholevsky_inversion(double **L, int N){
  double **L_inv=Allocate_mat2_d(N, N), X[N];
  int i, j, k;
  for(k=0; k<N; k++){
  // Solve the matrix equation L(i,j)X(j,k)=delta(i,k),
  // with L=lower diagonal (only i>=j)
  // X_jk = (delta_ik - sum_j<i L_ij X_jk)/L_ii
    for(i=0; i<N; i++){
      double *LL=L[i], *XY=X, sum=0; if(i==k)sum=1;
      for(j=0; j<i; j++){sum-=(*LL)*(*XY); XY++; LL++;}
      X[i]=sum/(*LL); L_inv[i][k]=X[i];
    }
  }
  return(L_inv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movl %esi, %edi
callq 0x49798
movl %r14d, %ecx
movq %rsp, %rdx
leaq 0xf(,%rcx,8), %rsi
andq $-0x10, %rsi
subq %rsi, %rdx
movq %rdx, %rsp
testl %r14d, %r14d
jle 0x49bea
xorl %esi, %esi
movsd 0x74b9(%rip), %xmm0     # 0x51040
xorl %edi, %edi
xorl %r8d, %r8d
movapd %xmm0, %xmm1
cmpq %rsi, %r8
je 0x49b99
xorpd %xmm1, %xmm1
movq (%rbx,%r8,8), %r9
testq %r8, %r8
je 0x49bc1
xorl %r10d, %r10d
movsd (%r9,%r10), %xmm2
mulsd (%rdx,%r10), %xmm2
subsd %xmm2, %xmm1
addq $0x8, %r10
cmpq %r10, %rdi
jne 0x49ba5
addq %r10, %r9
divsd (%r9), %xmm1
movsd %xmm1, (%rdx,%r8,8)
movq (%rax,%r8,8), %r9
movsd %xmm1, (%r9,%rsi,8)
incq %r8
addq $0x8, %rdi
cmpq %rcx, %r8
jne 0x49b8c
incq %rsi
cmpq %rcx, %rsi
jne 0x49b87
leaq -0x10(%rbp), %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/choldc.c
// Function: choldc_f
int choldc_f(float **L, float **a, int N)
{
  int i, j, k, ik, jk;
  double sum, diag[N];
  for(i=0; i<N; i++){
    for(j=i; j<N; j++){
      sum=a[i][j];
      for(k=i-1; k>=0; k--)sum-=L[i][k]*L[j][k];
      if(j==i){
	if(sum<EPS){
	  printf("WARNING, Choldc failed L_ii^2= %.2g i=%d\n", sum, i);
	  if(a==L){
	    // Ugo: Restore lower diagonal 
	    for(ik=0; ik<i; ik++){
	      a[ik][ik]=diag[ik];
	      for(jk=ik+1; jk<N; jk++)a[jk][ik]=a[ik][jk];
	    }
	  }
	  return(-1);
	}
	diag[i]=a[i][i]; L[i][i]=sqrt(sum);
      }else{
	L[j][i]=sum/L[i][i]; // j<=i 
      }
    }
  }
  return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r12d
movq %rsp, %rcx
leaq 0xf(,%r12,8), %rax
andq $-0x10, %rax
subq %rax, %rcx
movq %rcx, -0x38(%rbp)
movq %rcx, %rsp
testl %edx, %edx
jle 0x49cff
movq %rdi, %r14
movl $0x1, %r13d
xorl %ebx, %ebx
movsd 0x143ad(%rip), %xmm2    # 0x5dfe8
xorpd %xmm3, %xmm3
movq %rsi, -0x30(%rbp)
movq %rbx, %r15
movq (%rsi,%rbx,8), %rax
xorps %xmm0, %xmm0
cvtss2sd (%rax,%r15,4), %xmm0
testq %rbx, %rbx
je 0x49c82
movq (%r14,%rbx,8), %rcx
movq (%r14,%r15,8), %rdx
movq %r13, %r8
leal -0x2(%r8), %edi
movss (%rcx,%rdi,4), %xmm1
mulss (%rdx,%rdi,4), %xmm1
cvtss2sd %xmm1, %xmm1
subsd %xmm1, %xmm0
decq %r8
cmpq $0x1, %r8
jg 0x49c63
cmpq %rbx, %r15
jne 0x49caa
ucomisd %xmm0, %xmm2
ja 0x49d06
xorps %xmm1, %xmm1
cvtss2sd (%rax,%rbx,4), %xmm1
movq -0x38(%rbp), %rax
movsd %xmm1, (%rax,%rbx,8)
ucomisd %xmm3, %xmm0
jb 0x49cbf
sqrtsd %xmm0, %xmm0
jmp 0x49cd4
movq (%r14,%rbx,8), %rax
xorps %xmm1, %xmm1
cvtss2sd (%rax,%rbx,4), %xmm1
divsd %xmm1, %xmm0
movq %r15, %rax
jmp 0x49cd7
callq 0x2290
xorpd %xmm3, %xmm3
movsd 0x14318(%rip), %xmm2    # 0x5dfe8
movq -0x30(%rbp), %rsi
movq %rbx, %rax
cvtsd2ss %xmm0, %xmm0
movq (%r14,%rax,8), %rax
movss %xmm0, (%rax,%rbx,4)
incq %r15
cmpq %r12, %r15
jne 0x49c46
incq %rbx
incq %r13
cmpq %r12, %rbx
jne 0x49c43
xorl %eax, %eax
jmp 0x49d94
leaq 0x142e3(%rip), %rdi     # 0x5dff0
movl %ebx, %esi
movb $0x1, %al
callq 0x20f0
movq -0x30(%rbp), %r10
cmpq %r14, %r10
setne %cl
testq %rbx, %rbx
sete %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
orb %cl, %dl
jne 0x49d94
movl %ebx, %ecx
xorl %edx, %edx
movq %r12, %rsi
movq %r10, %rdi
xorl %r8d, %r8d
movq %r8, %r9
movq -0x38(%rbp), %r8
xorps %xmm0, %xmm0
cvtsd2ss (%r8,%r9,8), %xmm0
movq (%r10,%r9,8), %r10
movss %xmm0, (%r10,%r9,4)
leaq 0x1(%r9), %r8
cmpq %r12, %r8
jae 0x49d80
addq %rdx, %r10
movl $0x1, %r11d
movss (%r10,%r11,4), %xmm0
movq (%rdi,%r11,8), %rbx
movss %xmm0, (%rbx,%r9,4)
incq %r11
cmpq %r11, %rsi
jne 0x49d68
addq $0x8, %rdi
addq $0x4, %rdx
decq %rsi
cmpq %rcx, %r8
movq -0x30(%rbp), %r10
jne 0x49d3c
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/choldc.c
// Function: Forward_substitution_f
void Forward_substitution_f(double *X, float **L, double *Y, int N){
  // Solve the matrix equation LX=Y, with L=lower diagonal (only i>=j)
  // X_i = (Y_i - sum_j<i L_ij X_j)/L_ii
  int i, j; double *XX=X;
  for(i=0; i<N; i++){
    double *XY=X; float *LL=L[i];
    *XX=Y[i]; for(j=0; j<i; j++){(*XX)-=(*LL)*(*XY); XY++; LL++;}
    (*XX)/=(*LL);
    XX++;
  }
}

// Assembly:
testl %ecx, %ecx
jle 0x49e0e
movl %ecx, %eax
xorl %ecx, %ecx
movq %rdi, %r8
movq (%rsi,%rcx,8), %r9
movsd (%rdx,%rcx,8), %xmm0
movsd %xmm0, (%r8)
testq %rcx, %rcx
je 0x49dec
movsd (%r8), %xmm0
xorl %r10d, %r10d
xorps %xmm1, %xmm1
cvtss2sd (%r9), %xmm1
mulsd (%rdi,%r10,8), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%r8)
addq $0x4, %r9
incq %r10
cmpq %r10, %rcx
jne 0x49dc9
xorps %xmm0, %xmm0
cvtss2sd (%r9), %xmm0
movsd (%r8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%r8)
addq $0x8, %r8
incq %rcx
cmpq %rax, %rcx
jne 0x49dae
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/lubksb.c
// Function: lubksb
void lubksb(double **a, int n, int *indx, double *b)
{
  int i,ii=0,ip,j;
  double sum;
  
  for(i=0;i<n;i++) {
    ip=indx[i];
    sum=b[ip];
    b[ip]=b[i];
    if (ii){
      for (j=ii;j<=i-1;j++) sum -= a[i][j]*b[j];
    }else if (sum){
      ii=i;
    }
    b[i]=sum;
  }
  for (i=n-1;i>=0;i--) {
    sum=b[i];
    for (j=i+1;j<n;j++) sum -= a[i][j]*b[j];
    b[i]=sum/a[i][i];
  }
}

// Assembly:
pushq %rbp
pushq %rbx
movl %esi, %eax
testl %esi, %esi
jle 0x4a0d9
xorl %r8d, %r8d
xorpd %xmm0, %xmm0
xorl %r9d, %r9d
movslq (%rdx,%r8,4), %r10
movsd (%rcx,%r10,8), %xmm1
movsd (%rcx,%r8,8), %xmm2
movsd %xmm2, (%rcx,%r10,8)
testl %r9d, %r9d
je 0x4a0bb
movslq %r9d, %r10
cmpq %r10, %r8
jle 0x4a0cb
movq (%rdi,%r8,8), %r11
movsd (%r11,%r10,8), %xmm2
mulsd (%rcx,%r10,8), %xmm2
subsd %xmm2, %xmm1
incq %r10
cmpq %r10, %r8
jne 0x4a0a1
jmp 0x4a0cb
ucomisd %xmm0, %xmm1
jne 0x4a0c3
jnp 0x4a0c8
movl %r8d, %r9d
jmp 0x4a0cb
xorl %r9d, %r9d
movsd %xmm1, (%rcx,%r8,8)
incq %r8
cmpq %rax, %r8
jne 0x4a07a
testl %esi, %esi
jle 0x4a141
leaq (,%rax,8), %rdx
leaq (%rcx,%rax,8), %r8
movq %rax, %r9
leaq -0x1(%r9), %r10
movsd -0x8(%rcx,%r9,8), %xmm0
cmpq %rax, %r9
jge 0x4a120
movq (%rdi,%r10,8), %r11
addq %rdx, %r11
xorl %ebx, %ebx
movsd (%r11,%rbx,8), %xmm1
mulsd (%r8,%rbx,8), %xmm1
subsd %xmm1, %xmm0
incq %rbx
leal (%r9,%rbx), %ebp
cmpl %esi, %ebp
jl 0x4a105
movq (%rdi,%r10,8), %r11
divsd (%r11,%r10,8), %xmm0
movsd %xmm0, (%rcx,%r10,8)
addq $-0x8, %r8
addq $-0x8, %rdx
cmpq $0x1, %r9
movq %r10, %r9
jg 0x4a0ec
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/d_diagonalize.c
// Function: eigsrt
void eigsrt(double d[], double **v, int n)
{
  int k,j,i;
  double p;
  
  for (i=1;i<n;i++) {
    p=d[k=i];
    for (j=i+1;j<=n;j++)
      if (d[j] >= p) p=d[k=j];
    if (k != i) {
      d[k]=d[i];
      d[i]=p;
      for (j=1;j<=n;j++) {
	p=v[j][i];
	v[j][i]=v[j][k];
	v[j][k]=p;
      }
    }
  }
}

// Assembly:
cmpl $0x2, %edx
jl 0x4aba6
pushq %rbx
movl %edx, %eax
incl %edx
movl $0x2, %ecx
movl $0x1, %r8d
movq %r8, %r9
movsd (%rdi,%r8,8), %xmm0
incq %r8
movq %rcx, %r11
movapd %xmm0, %xmm1
movl %r9d, %r10d
movapd %xmm0, %xmm2
movsd (%rdi,%r11,8), %xmm3
ucomisd %xmm1, %xmm3
cmovael %r11d, %r10d
cmpnlesd %xmm3, %xmm2
movapd %xmm2, %xmm4
andnpd %xmm3, %xmm4
andpd %xmm1, %xmm2
orpd %xmm4, %xmm2
movapd %xmm2, %xmm1
incq %r11
cmpq %r11, %rdx
jne 0x4ab29
movl %r10d, %r11d
cmpq %r11, %r9
je 0x4ab99
movslq %r10d, %r10
movsd %xmm0, (%rdi,%r10,8)
movsd %xmm1, (%rdi,%r9,8)
movl $0x1, %r11d
movq (%rsi,%r11,8), %rbx
movsd (%rbx,%r9,8), %xmm0
movsd (%rbx,%r10,8), %xmm1
movsd %xmm1, (%rbx,%r9,8)
movsd %xmm0, (%rbx,%r10,8)
incq %r11
cmpq %r11, %rdx
jne 0x4ab75
incq %rcx
cmpq %rax, %r8
jne 0x4ab0f
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/d_diagonalize.c
// Function: Select_modes
void Select_modes(int *selected, double *eigen_va, float E_MIN, int N)
{
  /* printf("Discarding modes with e_val/<e_val> < %.2g ", E_MIN*0.001);
     printf(" or e_val/<e_val> < %.2g, coll < %.f\n",E_MIN, COLL_THR);
     int n=0; */
  float E_THR=E_MIN; int i;
  double e=0; for(i=1; i<=N; i++)e+=eigen_va[i];
  if(e<0){e=-e;} E_THR*=(e/N);
  for(i=1; i<=N; i++){
    if(eigen_va[i]<E_THR){
      selected[i]=0;
    }else{
      selected[i]=1;
    }
  }
}

// Assembly:
testl %edx, %edx
jle 0x4abc6
leal 0x1(%rdx), %eax
xorpd %xmm1, %xmm1
movl $0x1, %ecx
addsd (%rsi,%rcx,8), %xmm1
incq %rcx
cmpq %rcx, %rax
jne 0x4abb7
jmp 0x4abca
xorpd %xmm1, %xmm1
testl %edx, %edx
jle 0x4ac15
movapd 0x64ba(%rip), %xmm2     # 0x51090
xorpd %xmm1, %xmm2
maxsd %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
incl %edx
movl $0x1, %eax
xorl %ecx, %ecx
ucomisd (%rsi,%rax,8), %xmm0
setbe %cl
movl %ecx, (%rdi,%rax,4)
incq %rax
cmpq %rax, %rdx
jne 0x4ac00
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/d_diagonalize.c
// Function: Select_modes_coll
void Select_modes_coll(int *selected, double *eigen_va, double **eigen_vt,
		       float E_MIN, float COLL_THR, int N)
{
  /* printf("Discarding modes with e_val/<e_val> < %.2g ", E_MIN*0.001);
     printf(" or e_val/<e_val> < %.2g, coll < %.f\n",E_MIN, COLL_THR);
     int n=0; */
  float E_THR=E_MIN; int i, j;
  double e=0; for(j=1; j<=N; j++)e+=eigen_va[j];
  if(e<0){e=-e;} E_THR*=(e/N);
  float E_THR2=E_THR*0.001;
  for(i=1; i<=N; i++){
    selected[i]=1;
    if(eigen_va[i]<E_THR){
      if(eigen_va[i]<E_THR2){
	selected[i]=0;
      }else{
	double sum=0, Entropy=0;
	for(j=1; j<=N; j++){
	  float v=eigen_vt[j][i];
	  if(v){v*=v; sum+=v; Entropy-=v*log(v);}
	}
	float c=sum*exp(Entropy/sum);
	if(c<COLL_THR){
	  selected[i]=0;
	  //printf("%.1f %f\n", c, eigen_va[i]); n++;
	}
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebx
movss %xmm1, 0x14(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
testl %ecx, %ecx
jle 0x4ac55
leal 0x1(%rbx), %eax
xorpd %xmm1, %xmm1
movl $0x1, %ecx
addsd (%r15,%rcx,8), %xmm1
incq %rcx
cmpq %rcx, %rax
jne 0x4ac45
jmp 0x4ac59
xorpd %xmm1, %xmm1
testl %ebx, %ebx
jle 0x4ad8a
movapd 0x6427(%rip), %xmm2     # 0x51090
xorpd %xmm1, %xmm2
maxsd %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtsi2sd %ebx, %xmm1
divsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
cvtsd2ss %xmm0, %xmm0
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
movsd 0xc709(%rip), %xmm0     # 0x573a0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
xorps %xmm2, %xmm2
cvtss2sd %xmm0, %xmm2
incl %ebx
movl $0x1, %r13d
movsd %xmm1, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movl $0x1, (%r12,%r13,4)
movsd (%r15,%r13,8), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x4ad7e
ucomisd %xmm0, %xmm2
ja 0x4ad76
xorpd %xmm2, %xmm2
movl $0x1, %ebp
xorpd %xmm1, %xmm1
movq (%r14,%rbp,8), %rax
xorps %xmm0, %xmm0
cvtsd2ss (%rax,%r13,8), %xmm0
ucomiss 0x630f(%rip), %xmm0     # 0x5100c
jne 0x4ad01
jnp 0x4ad3a
mulss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd %xmm2, 0x30(%rsp)
callq 0x2120
movsd 0x30(%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
mulsd 0x28(%rsp), %xmm0
subsd %xmm0, %xmm2
incq %rbp
cmpq %rbp, %rbx
jne 0x4ace9
divsd %xmm1, %xmm2
movapd %xmm2, %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0x22a0
mulsd 0x8(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss 0x14(%rsp), %xmm1
ucomiss %xmm0, %xmm1
movsd 0x20(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
jbe 0x4ad7e
movl $0x0, (%r12,%r13,4)
incq %r13
cmpq %rbx, %r13
jne 0x4acba
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/nrutil.c
// Function: nrerror
void nrerror(char error_text[])
/* Numerical Recipes standard error handler */
{
  fprintf(stderr,"Numerical Recipes run-time error...\n");
  fprintf(stderr,"%s\n",error_text);
  fprintf(stderr,"...now exiting to system...\n");
  exit(1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1c24e(%rip), %r14     # 0x66ff8
movq (%r14), %rcx
leaq 0x132b6(%rip), %rdi     # 0x5e06a
movl $0x24, %esi
movl $0x1, %edx
callq 0x2280
movq (%r14), %rdi
leaq 0x128c8(%rip), %rsi     # 0x5d695
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2190
movq (%r14), %rcx
leaq 0x132ae(%rip), %rdi     # 0x5e08f
movl $0x1c, %esi
movl $0x1, %edx
callq 0x2280
movl $0x1, %edi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/nrutil.c
// Function: vector
float *vector(long nl, long nh)
/* allocate a float vector with subscript range v[nl..nh] */
{
  float *v;
  
  v=(float *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(float)));
  if (!v) nrerror("allocation failure in vector()");
  return v-nl+NR_END;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
subq %rdi, %rsi
leaq 0x8(,%rsi,4), %rdi
callq 0x21d0
testq %rax, %rax
je 0x4ae20
shlq $0x2, %rbx
subq %rbx, %rax
addq $0x4, %rax
popq %rbx
retq
leaq 0x13285(%rip), %rdi     # 0x5e0ac
callq 0x4ad9c
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/nrutil.c
// Function: ivector
int *ivector(long nl, long nh)
/* allocate an int vector with subscript range v[nl..nh] */
{
  int *v;

  v=(int *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(int)));
  if (!v) nrerror("allocation failure in ivector()");
  return v-nl+NR_END;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
subq %rdi, %rsi
leaq 0x8(,%rsi,4), %rdi
callq 0x21d0
testq %rax, %rax
je 0x4ae52
shlq $0x2, %rbx
subq %rbx, %rax
addq $0x4, %rax
popq %rbx
retq
leaq 0x13272(%rip), %rdi     # 0x5e0cb
callq 0x4ad9c
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/nrutil.c
// Function: cvector
unsigned char *cvector(long nl, long nh)
     /* allocate an unsigned char vector with subscript range v[nl..nh] */
{
  unsigned char *v;
  
  v=(unsigned char *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(unsigned char)));
  if (!v) nrerror("allocation failure in cvector()");
  return v-nl+NR_END;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
subq %rdi, %rsi
leaq 0x2(%rsi), %rdi
callq 0x21d0
testq %rax, %rax
je 0x4ae7b
subq %rbx, %rax
incq %rax
popq %rbx
retq
leaq 0x13269(%rip), %rdi     # 0x5e0eb
callq 0x4ad9c
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/nrutil.c
// Function: lvector
unsigned long *lvector(long nl, long nh)
     /* allocate an unsigned long vector with subscript range v[nl..nh] */
{
  unsigned long *v;
  
  v=(unsigned long *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(long)));
  if (!v) nrerror("allocation failure in lvector()");
  return v-nl+NR_END;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
subq %rdi, %rsi
leaq 0x10(,%rsi,8), %rdi
callq 0x21d0
testq %rax, %rax
je 0x4aead
shlq $0x3, %rbx
subq %rbx, %rax
addq $0x8, %rax
popq %rbx
retq
leaq 0x13257(%rip), %rdi     # 0x5e10b
callq 0x4ad9c
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/nrutil.c
// Function: dvector
double *dvector(long nl, long nh)
     /* allocate a double vector with subscript range v[nl..nh] */
{
  double *v;
  
  v=(double *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(double)));
  if (!v) nrerror("allocation failure in dvector()");
  return v-nl+NR_END;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
subq %rdi, %rsi
leaq 0x10(,%rsi,8), %rdi
callq 0x21d0
testq %rax, %rax
je 0x4aedf
shlq $0x3, %rbx
subq %rbx, %rax
addq $0x8, %rax
popq %rbx
retq
leaq 0x13245(%rip), %rdi     # 0x5e12b
callq 0x4ad9c
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/nrutil.c
// Function: matrix
float **matrix(long nrl, long nrh, long ncl, long nch)
     /* allocate a float matrix with subscript range m[nrl..nrh][ncl..nch] */
{
  long i, nrow=nrh-nrl+1,ncol=nch-ncl+1;
  float **m;

  /* allocate pointers to rows */
  m=(float **) malloc((size_t)((nrow+NR_END)*sizeof(float*)));
  if (!m) nrerror("allocation failure 1 in matrix()");
  m += NR_END;
  m -= nrl;

  /* allocate rows and set pointers to them */
  m[nrl]=(float *) malloc((size_t)((nrow*ncol+NR_END)*sizeof(float)));
  if (!m[nrl]) nrerror("allocation failure 2 in matrix()");
  m[nrl] += NR_END;
  m[nrl] -= ncl;

  for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;

  /* return pointer to array of pointers to rows */
  return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
movq %rsi, %rbp
subq %rdi, %rbp
leaq 0x10(,%rbp,8), %rdi
callq 0x21d0
testq %rax, %rax
je 0x4afaa
movq %rax, %r15
movq %rbx, %rax
subq %r12, %rax
incq %rax
leaq 0x4(,%rbp,4), %rdi
imulq %rax, %rdi
addq $0x4, %rdi
callq 0x21d0
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0x4afb6
movq %rax, %rcx
leaq (,%r13,8), %rax
negq %rax
addq %r15, %rax
addq $0x8, %rax
movq %r15, %rdx
addq $0x8, %rdx
shlq $0x2, %r12
subq %r12, %rcx
addq $0x4, %rcx
movq %rcx, (%rdx)
subq %r13, %r14
jle 0x4af9b
shlq $0x2, %rbx
subq %r12, %rbx
addq $0x4, %rbx
movq 0x8(%r15), %rcx
addq %rbx, %rcx
xorl %edx, %edx
movq %rcx, 0x10(%r15,%rdx,8)
addq %rbx, %rcx
incq %rdx
cmpq %rdx, %r14
jne 0x4af8b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1319a(%rip), %rdi     # 0x5e14b
callq 0x4ad9c
leaq 0x131af(%rip), %rdi     # 0x5e16c
callq 0x4ad9c
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/nrutil.c
// Function: dmatrix
double **dmatrix(long nrl, long nrh, long ncl, long nch)
/* allocate a double matrix with subscript range m[nrl..nrh][ncl..nch] */
{
  long i, nrow=nrh-nrl+1,ncol=nch-ncl+1;
  double **m;
  
  /* allocate pointers to rows */
  m=(double **) malloc((size_t)((nrow+NR_END)*sizeof(double*)));
  if (!m) nrerror("allocation failure 1 in matrix()");
  m += NR_END;
  m -= nrl;

  /* allocate rows and set pointers to them */
  m[nrl]=(double *) malloc((size_t)((nrow*ncol+NR_END)*sizeof(double)));
  if (!m[nrl]) nrerror("allocation failure 2 in matrix()");
  m[nrl] += NR_END;
  m[nrl] -= ncl;
  
  for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;
  
  /* return pointer to array of pointers to rows */
  return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
movq %rsi, %rbp
subq %rdi, %rbp
leaq 0x10(,%rbp,8), %rdi
callq 0x21d0
testq %rax, %rax
je 0x4b081
movq %rax, %r15
movq %rbx, %rax
subq %r12, %rax
incq %rax
leaq 0x8(,%rbp,8), %rdi
imulq %rax, %rdi
addq $0x8, %rdi
callq 0x21d0
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0x4b08d
movq %rax, %rcx
leaq (,%r13,8), %rax
negq %rax
addq %r15, %rax
addq $0x8, %rax
movq %r15, %rdx
addq $0x8, %rdx
shlq $0x3, %r12
subq %r12, %rcx
addq $0x8, %rcx
movq %rcx, (%rdx)
subq %r13, %r14
jle 0x4b072
shlq $0x3, %rbx
subq %r12, %rbx
addq $0x8, %rbx
movq 0x8(%r15), %rcx
addq %rbx, %rcx
xorl %edx, %edx
movq %rcx, 0x10(%r15,%rdx,8)
addq %rbx, %rcx
incq %rdx
cmpq %rdx, %r14
jne 0x4b062
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x130c3(%rip), %rdi     # 0x5e14b
callq 0x4ad9c
leaq 0x130d8(%rip), %rdi     # 0x5e16c
callq 0x4ad9c
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/nrutil.c
// Function: imatrix
int **imatrix(long nrl, long nrh, long ncl, long nch)
/* allocate a int matrix with subscript range m[nrl..nrh][ncl..nch] */
{
  long i, nrow=nrh-nrl+1,ncol=nch-ncl+1;
  int **m;

  /* allocate pointers to rows */
  m=(int **) malloc((size_t)((nrow+NR_END)*sizeof(int*)));
  if (!m) nrerror("allocation failure 1 in matrix()");
  m += NR_END;
  m -= nrl;
  

  /* allocate rows and set pointers to them */
  m[nrl]=(int *) malloc((size_t)((nrow*ncol+NR_END)*sizeof(int)));
  if (!m[nrl]) nrerror("allocation failure 2 in matrix()");
  m[nrl] += NR_END;
  m[nrl] -= ncl;
  
  for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;
  
  /* return pointer to array of pointers to rows */
  return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
movq %rsi, %rbp
subq %rdi, %rbp
leaq 0x10(,%rbp,8), %rdi
callq 0x21d0
testq %rax, %rax
je 0x4b158
movq %rax, %r15
movq %rbx, %rax
subq %r12, %rax
incq %rax
leaq 0x4(,%rbp,4), %rdi
imulq %rax, %rdi
addq $0x4, %rdi
callq 0x21d0
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0x4b164
movq %rax, %rcx
leaq (,%r13,8), %rax
negq %rax
addq %r15, %rax
addq $0x8, %rax
movq %r15, %rdx
addq $0x8, %rdx
shlq $0x2, %r12
subq %r12, %rcx
addq $0x4, %rcx
movq %rcx, (%rdx)
subq %r13, %r14
jle 0x4b149
shlq $0x2, %rbx
subq %r12, %rbx
addq $0x4, %rbx
movq 0x8(%r15), %rcx
addq %rbx, %rcx
xorl %edx, %edx
movq %rcx, 0x10(%r15,%rdx,8)
addq %rbx, %rcx
incq %rdx
cmpq %rdx, %r14
jne 0x4b139
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12fec(%rip), %rdi     # 0x5e14b
callq 0x4ad9c
leaq 0x13001(%rip), %rdi     # 0x5e16c
callq 0x4ad9c
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/nrutil.c
// Function: submatrix
float **submatrix(float **a, long oldrl, long oldrh, long oldcl, long oldch,
		  long newrl, long newcl)
/* point a submatrix [newrl..][newcl..] to a[oldrl..oldrh][oldcl..oldch] */
{
  long i,j,nrow=oldrh-oldrl+1,ncol=oldcl-newcl;
  float **m;

  /* allocate array of pointers to rows */
  m=(float **) malloc((size_t) ((nrow+NR_END)*sizeof(float*)));
  if (!m) nrerror("allocation failure in submatrix()");
  m += NR_END;
  m -= newrl;

  /* set pointers to rows */
  for(i=oldrl,j=newrl;i<=oldrh;i++,j++) m[j]=a[i]+ncol;

  /* return pointer to array of pointers to rows */
  return m;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %r13
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rax
subq %rsi, %rax
leaq 0x10(,%rax,8), %rdi
callq 0x21d0
testq %rax, %rax
je 0x4b1e5
addq $0x8, %rax
shlq $0x3, %r13
movq %rax, %rcx
subq %r13, %rcx
subq %r15, %r14
jl 0x4b1d8
subq 0x30(%rsp), %rbx
incq %r14
leaq (%r12,%r15,8), %rdx
xorl %esi, %esi
shlq $0x2, %rbx
movq (%rdx,%rsi,8), %rdi
addq %rbx, %rdi
movq %rdi, (%rax,%rsi,8)
incq %rsi
cmpq %rsi, %r14
jne 0x4b1c5
movq %rcx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x12fa1(%rip), %rdi     # 0x5e18d
callq 0x4ad9c
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/nrutil.c
// Function: convert_matrix
float **convert_matrix(float *a, long nrl, long nrh, long ncl, long nch)
/* allocate a float matrix m[nrl..nrh][ncl..nch] that points to the matrix
declared in the standard C manner as a[nrow][ncol], where nrow=nrh-nrl+1
and ncol=nch-ncl+1. The routine should be called with the address
&a[0][0] as the first argument. */
{
  long i,j,nrow=nrh-nrl+1,ncol=nch-ncl+1;
  float **m;

  /* allocate pointers to rows */
  m=(float **) malloc((size_t) ((nrow+NR_END)*sizeof(float*)));
  if (!m) nrerror("allocation failure in convert_matrix()");
  m += NR_END;
  m -= nrl;

  /* set pointers to rows */
  m[nrl]=a-ncl;
  for(i=1,j=nrl+1;i<nrow;i++,j++) m[j]=m[j-1]+ncol;
  /* return pointer to array of pointers to rows */
  return m;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
subq %rsi, %r14
leaq 0x10(,%r14,8), %rdi
callq 0x21d0
testq %rax, %rax
je 0x4b26e
shlq $0x3, %r13
negq %r13
leaq (%rax,%r13), %rcx
addq $0x8, %rcx
shlq $0x2, %r15
subq %r15, %r12
movq %r12, 0x8(%rax)
testq %r14, %r14
jle 0x4b261
shlq $0x2, %rbx
subq %r15, %rbx
addq $0x4, %rbx
movq 0x8(%rax), %rdx
addq %rbx, %rdx
xorl %esi, %esi
movq %rdx, 0x10(%rax,%rsi,8)
addq %rbx, %rdx
incq %rsi
cmpq %rsi, %r14
jne 0x4b251
movq %rcx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x12f3a(%rip), %rdi     # 0x5e1af
callq 0x4ad9c
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/pythag.c
// Function: pythag
double pythag(double a, double b)
{
  double absa,absb;
  absa=fabs(a);
  absb=fabs(b);
  if (absa > absb) return absa*sqrt(1.0+SQR(absb/absa));
  else return (absb == 0.0 ? 0.0 : absb*sqrt(1.0+SQR(absa/absb)));
}

// Assembly:
movapd 0xbdd4(%rip), %xmm2     # 0x57330
andpd %xmm2, %xmm0
andpd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x4b574
divsd %xmm0, %xmm2
movapd %xmm0, %xmm3
jmp 0x4b58c
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm1
jne 0x4b580
jnp 0x4b5e9
movapd %xmm2, %xmm3
divsd %xmm2, %xmm0
movapd %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm0
leaq 0x1db76(%rip), %rax     # 0x69110
movss %xmm0, (%rax)
xorpd %xmm1, %xmm1
ucomiss %xmm1, %xmm0
mulss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x5a8b(%rip), %xmm1     # 0x51040
addsd %xmm1, %xmm0
jne 0x4b5c1
jp 0x4b5c1
movapd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4b5d1
sqrtsd %xmm0, %xmm0
jmp 0x4b5e5
pushq %rax
movsd %xmm3, (%rsp)
callq 0x2290
movsd (%rsp), %xmm3
addq $0x8, %rsp
mulsd %xmm0, %xmm3
movapd %xmm3, %xmm0
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/Profit_aux.c
// Function: OpenFile
FILE *OpenFile(char *filename, char *envvar, char *mode, int *noenv)
{
   char *datadir,
        buffer[160];
   FILE *fp;

   if(filename == NULL || filename[0] == '\0')
      return(NULL);

   if(noenv != NULL) *noenv = 0;

   /* Try to open the filename as specified                             */
   if((fp=fopen(filename,mode)) == NULL)
   {
      /* Failed, so build alternative directory/filename                */
#if (unix || __unix__ || MS_WINDOWS || __unix || __MACH__ || __APPLE__)
      if((datadir = getenv(envvar)) != NULL)
      {
         if(datadir[strlen(datadir)-1] == '/')
            sprintf(buffer,"%s%s",datadir,filename);
         else
            sprintf(buffer,"%s/%s",datadir,filename);
         fp = fopen(buffer,mode);
      }
      else
      {
         if(noenv != NULL) *noenv = 1;
         return(NULL);
      }
#else
      sprintf(buffer,"%s:%s",envvar,filename);
      fp = fopen(buffer,mode);
#endif
   }

   return(fp);
}

// Assembly:
testq %rdi, %rdi
je 0x4c627
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x4c636
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
testq %rcx, %rcx
je 0x4c5c7
movl $0x0, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2210
testq %rax, %rax
jne 0x4c638
movq %r12, %rdi
callq 0x2040
testq %rax, %rax
je 0x4c62a
movq %rax, %r12
movq %rax, %rdi
callq 0x20d0
cmpb $0x2f, -0x1(%r12,%rax)
leaq 0x9728(%rip), %rax      # 0x55d24
leaq 0x1091b(%rip), %rsi     # 0x5cf1e
cmoveq %rax, %rsi
movq %rsp, %r15
movq %r15, %rdi
movq %r12, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x2260
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2210
jmp 0x4c638
xorl %eax, %eax
retq
testq %r15, %r15
je 0x4c636
movl $0x1, (%r15)
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/Profit_aux.c
// Function: Array2D
char **Array2D(int size,
               int dim1,
               int dim2)
{
   char  **array  = NULL;
   int   i;

   /* Allocate memory for the outer dimension array                     */
   if((array = (char **)malloc(dim1 * sizeof(char *))) == NULL)
      return(NULL);

   /* Set all positions to NULL                                         */
   for(i=0; i<dim1; i++)   array[i] = NULL;

   /* Allocate memory for each array in the second dimension            */
   for(i=0; i<dim1; i++)
   {
      /* If allocation fails, jump to badexit                           */
      if((array[i] = (char *)malloc(dim2 * size)) == NULL)
         goto badexit;
   }

   return(array);

badexit:
   for(i=0; i<dim1; i++)   if(array[i]) free(array[i]);
   free(array);
   return(NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movl %esi, %r15d
movl %edi, %r14d
movslq %esi, %rdi
shlq $0x3, %rdi
callq 0x21d0
testq %rax, %rax
je 0x4c6d0
movq %rax, %rbx
movl %r15d, %r12d
testl %r15d, %r15d
jle 0x4c685
leaq (,%r12,8), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2110
testl %r15d, %r15d
jle 0x4c6d2
imull %r14d, %ebp
movslq %ebp, %r14
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x21d0
movq %rax, (%rbx,%r15,8)
testq %rax, %rax
je 0x4c6af
incq %r15
cmpq %r15, %r12
jne 0x4c694
jmp 0x4c6d2
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x4c6c0
callq 0x2050
incq %r14
cmpq %r14, %r12
jne 0x4c6b2
movq %rbx, %rdi
callq 0x2050
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/Profit_aux.c
// Function: FreeArray2D
void FreeArray2D(char   **array,
                 int    dim1,
                 int    dim2)
{
   int   i;

   if(array)
   {
      for(i=0; i<dim1; i++)   if(array[i]) free(array[i]);
      free(array);
   }
}

// Assembly:
testq %rdi, %rdi
je 0x4c718
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x4c70b
movl %esi, %r14d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
testq %rdi, %rdi
je 0x4c703
callq 0x2050
incq %r15
cmpq %r15, %r14
jne 0x4c6f5
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2050
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/NeedlemanWunsch.c
// Function: CalcMDMScore
int CalcMDMScore(char resa, char resb)
{
   int        i,j;
   static int NWarn = 0;
   int       Warned = 0;

   for(i=0;i<sMDMSize;i++)
   {
      if(resa==sMDM_AAList[i]) break;
   }
   if(i==sMDMSize)
   {
      if(NWarn < 10)
         printf("Residue %c not found in matrix\n",resa);
      else if(NWarn == 10)
         printf("More residues not found in matrix...\n");
      Warned = 1;
   }
   for(j=0;j<sMDMSize;j++)
   {
      if(resb==sMDM_AAList[j]) break;
   }
   if(j==sMDMSize)
   {
      if(NWarn < 10)
         printf("Residue %c not found in matrix\n",resb);
      else if(NWarn == 10)
         printf("More residues not found in matrix...\n");
      Warned = 1;
   }

   if(Warned)
   {
      NWarn++;
      return(0);
   }

   return(sMDMScore[i][j]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl 0x2db81(%rip), %eax     # 0x7aa98
xorl %ebp, %ebp
movl $0x0, %r14d
testl %eax, %eax
jle 0x4cf3e
movq 0x2db7e(%rip), %rcx     # 0x7aaa8
xorl %r14d, %r14d
cmpb %dil, (%rcx,%r14)
je 0x4cf3e
incq %r14
cmpq %r14, %rax
jne 0x4cf2d
movl %eax, %r14d
cmpl %eax, %r14d
jne 0x4cf7d
movl 0x2db67(%rip), %eax     # 0x7aab0
cmpl $0x9, %eax
jg 0x4cf67
movsbl %dil, %esi
leaq 0x11325(%rip), %rdi     # 0x5e27e
xorl %eax, %eax
callq 0x20f0
movl $0x1, %ebp
jmp 0x4cf7d
movl $0x1, %ebp
cmpl $0xa, %eax
jne 0x4cf7d
leaq 0x11366(%rip), %rdi     # 0x5e2de
callq 0x2090
movl 0x2db15(%rip), %eax     # 0x7aa98
testl %eax, %eax
jle 0x4cfa4
movq 0x2db1a(%rip), %rcx     # 0x7aaa8
xorl %r15d, %r15d
cmpb %bl, (%rcx,%r15)
je 0x4cfa7
incq %r15
cmpq %r15, %rax
jne 0x4cf91
movl %eax, %r15d
jmp 0x4cfa7
xorl %r15d, %r15d
cmpl %eax, %r15d
jne 0x4cfe5
movl 0x2dafe(%rip), %eax     # 0x7aab0
cmpl $0x9, %eax
jg 0x4cfcf
movsbl %bl, %esi
leaq 0x112bd(%rip), %rdi     # 0x5e27e
xorl %eax, %eax
callq 0x20f0
movl $0x1, %ebp
jmp 0x4cfe5
movl $0x1, %ebp
cmpl $0xa, %eax
jne 0x4cfe5
leaq 0x112fe(%rip), %rdi     # 0x5e2de
callq 0x2090
testl %ebp, %ebp
je 0x4cff3
incl 0x2dac1(%rip)           # 0x7aab0
xorl %eax, %eax
jmp 0x4d007
movq 0x2daa6(%rip), %rax     # 0x7aaa0
movl %r14d, %ecx
movq (%rax,%rcx,8), %rax
movl %r15d, %ecx
movl (%rax,%rcx,4), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/NeedlemanWunsch.c
// Function: CalcMDMScoreUC
int CalcMDMScoreUC(char resa, char resb)
{
   int        i,j;
   static int NWarn = 0;
   int       Warned = 0;

   resa = (islower(resa)?toupper(resa):resa);
   resb = (islower(resb)?toupper(resb):resb);

   for(i=0;i<sMDMSize;i++)
   {
      if(resa==sMDM_AAList[i]) break;
   }
   if(i==sMDMSize)
   {
      if(NWarn < 10)
         printf("Residue %c not found in matrix\n",resa);
      else if(NWarn == 10)
         printf("More residues not found in matrix...\n");
      Warned = 1;
   }
   for(j=0;j<sMDMSize;j++)
   {
      if(resb==sMDM_AAList[j]) break;
   }
   if(j==sMDMSize)
   {
      if(NWarn < 10)
         printf("Residue %c not found in matrix\n",resb);
      else if(NWarn == 10)
         printf("More residues not found in matrix...\n");
      Warned = 1;
   }

   if(Warned)
   {
      NWarn++;
      return(0);
   }

   return(sMDMScore[i][j]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
callq 0x22c0
movq (%rax), %r14
movslq %ebp, %r15
testb $0x2, 0x1(%r14,%r15,2)
je 0x4dba3
callq 0x2030
movq (%rax), %rax
movb (%rax,%r15,4), %bpl
movsbq %bl, %r15
testb $0x2, 0x1(%r14,%r15,2)
je 0x4dbbb
callq 0x2030
movq (%rax), %rax
movb (%rax,%r15,4), %bl
movl 0x2ced7(%rip), %eax     # 0x7aa98
xorl %r15d, %r15d
movl $0x0, %r14d
testl %eax, %eax
jle 0x4dbe9
movq 0x2ced3(%rip), %rcx     # 0x7aaa8
xorl %r14d, %r14d
cmpb (%rcx,%r14), %bpl
je 0x4dbe9
incq %r14
cmpq %r14, %rax
jne 0x4dbd8
movl %eax, %r14d
cmpl %eax, %r14d
jne 0x4dc2a
movl 0x2cec0(%rip), %eax     # 0x7aab4
cmpl $0x9, %eax
jg 0x4dc13
movsbl %bpl, %esi
leaq 0x1067a(%rip), %rdi     # 0x5e27e
xorl %eax, %eax
callq 0x20f0
movl $0x1, %r15d
jmp 0x4dc2a
movl $0x1, %r15d
cmpl $0xa, %eax
jne 0x4dc2a
leaq 0x106b9(%rip), %rdi     # 0x5e2de
callq 0x2090
movl 0x2ce68(%rip), %eax     # 0x7aa98
testl %eax, %eax
jle 0x4dc51
movq 0x2ce6d(%rip), %rcx     # 0x7aaa8
xorl %r12d, %r12d
cmpb (%rcx,%r12), %bl
je 0x4dc54
incq %r12
cmpq %r12, %rax
jne 0x4dc3e
movl %eax, %r12d
jmp 0x4dc54
xorl %r12d, %r12d
cmpl %eax, %r12d
jne 0x4dc94
movl 0x2ce55(%rip), %eax     # 0x7aab4
cmpl $0x9, %eax
jg 0x4dc7d
movsbl %bl, %esi
leaq 0x10610(%rip), %rdi     # 0x5e27e
xorl %eax, %eax
callq 0x20f0
movl $0x1, %r15d
jmp 0x4dc94
movl $0x1, %r15d
cmpl $0xa, %eax
jne 0x4dc94
leaq 0x1064f(%rip), %rdi     # 0x5e2de
callq 0x2090
testl %r15d, %r15d
je 0x4dca3
incl 0x2ce15(%rip)           # 0x7aab4
xorl %eax, %eax
jmp 0x4dcb7
movq 0x2cdf6(%rip), %rax     # 0x7aaa0
movl %r14d, %ecx
movq (%rax,%rcx,8), %rax
movl %r12d, %ecx
movl (%rax,%rcx,4), %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/NeedlemanWunsch.c
// Function: ZeroMDM
int ZeroMDM(void)
{
   int MinVal = sMDMScore[0][0],
       MaxVal = sMDMScore[0][0],
       i, j;

   /* Find the minimum and maximum values on the matrix                 */
   for(i=0; i<sMDMSize; i++)
   {
      for(j=0; j<sMDMSize; j++)
      {
         if(sMDMScore[i][j] < MinVal)
         {
            MinVal = sMDMScore[i][j];
         }
         else if(sMDMScore[i][j] > MaxVal)
         {
            MaxVal = sMDMScore[i][j];
         }
      }
   }

   /* Now subtract the MinVal from all cells in the matrix so it starts
      at zero.
   */
   for(i=0; i<sMDMSize; i++)
   {
      for(j=0; j<sMDMSize; j++)
      {
         sMDMScore[i][j] -= MinVal;
      }
   }

   /* Return maximum value in modified matrix                           */
   return(MaxVal-MinVal);
}

// Assembly:
movq 0x2cb00(%rip), %rcx     # 0x7aaa0
movq (%rcx), %rax
movl (%rax), %eax
movslq 0x2caec(%rip), %rdx     # 0x7aa98
testq %rdx, %rdx
jle 0x4dfe7
xorl %edi, %edi
movl %eax, %esi
movq (%rcx,%rdi,8), %r8
xorl %r9d, %r9d
movl %eax, %r10d
movl (%r8,%r9,4), %r11d
cmpl %eax, %r11d
cmovgl %r11d, %eax
cmpl %esi, %r11d
cmovll %r11d, %esi
cmovll %r10d, %eax
incq %r9
cmpq %r9, %rdx
jne 0x4dfbc
incq %rdi
cmpq %rdx, %rdi
jne 0x4dfb5
jmp 0x4dfe9
movl %eax, %esi
testl %edx, %edx
jle 0x4e00a
xorl %edi, %edi
movq (%rcx,%rdi,8), %r8
xorl %r9d, %r9d
subl %esi, (%r8,%r9,4)
incq %r9
cmpq %r9, %rdx
jne 0x4dff6
incq %rdi
cmpq %rdx, %rdi
jne 0x4dfef
subl %esi, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/McLachlan_float.c
// Function: center_of_mass
static void center_of_mass(double *ret, float *v, int N, float *mass)
{
  int i, m=0; double norm=0;

  for(i=0;i<3;i++)ret[i] = 0;
  for(i=0;i<N;i++){
    double w=mass[i];
    ret[0] += w*v[m];
    ret[1] += w*v[m+1];
    ret[2] += w*v[m+2];
    norm+=w; m+=3;
  }
  for(i=0;i<3;i++)ret[i]/= norm;
}

// Assembly:
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testl %edx, %edx
jle 0x4eaca
movsd (%rdi), %xmm3
movsd 0x8(%rdi), %xmm2
movsd 0x10(%rdi), %xmm1
movl %edx, %eax
addq $0x8, %rsi
xorpd %xmm0, %xmm0
xorl %edx, %edx
xorps %xmm4, %xmm4
cvtss2sd (%rcx,%rdx,4), %xmm4
xorps %xmm5, %xmm5
cvtss2sd -0x8(%rsi), %xmm5
mulsd %xmm4, %xmm5
addsd %xmm5, %xmm3
xorps %xmm5, %xmm5
cvtss2sd -0x4(%rsi), %xmm5
mulsd %xmm4, %xmm5
addsd %xmm5, %xmm2
xorps %xmm5, %xmm5
cvtss2sd (%rsi), %xmm5
mulsd %xmm4, %xmm5
addsd %xmm5, %xmm1
addsd %xmm4, %xmm0
incq %rdx
addq $0xc, %rsi
cmpq %rdx, %rax
jne 0x4ea73
movsd %xmm3, (%rdi)
movsd %xmm2, 0x8(%rdi)
movsd %xmm1, 0x10(%rdi)
jmp 0x4eace
xorpd %xmm0, %xmm0
xorl %eax, %eax
movsd (%rdi,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%rax,8)
incq %rax
cmpq $0x3, %rax
jne 0x4ead0
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/McLachlan_float.c
// Function: TranslateVector
static void TranslateVector(float *v, double transl[3], int N)
{
  int i,m=0;
  for (i=0;i<N;i++){
    v[m]+=transl[0];
    v[m+1]+=transl[1];
    v[m+2]+=transl[2];
    m+=3;
  }
}

// Assembly:
testl %edx, %edx
jle 0x4eb43
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm1
movsd 0x10(%rsi), %xmm2
addq $0x8, %rdi
xorps %xmm3, %xmm3
cvtss2sd -0x8(%rdi), %xmm3
addsd %xmm0, %xmm3
cvtsd2ss %xmm3, %xmm3
movss %xmm3, -0x8(%rdi)
xorps %xmm3, %xmm3
cvtss2sd -0x4(%rdi), %xmm3
addsd %xmm1, %xmm3
cvtsd2ss %xmm3, %xmm3
movss %xmm3, -0x4(%rdi)
xorps %xmm3, %xmm3
cvtss2sd (%rdi), %xmm3
addsd %xmm2, %xmm3
cvtsd2ss %xmm3, %xmm3
movss %xmm3, (%rdi)
addq $0xc, %rdi
decl %edx
jne 0x4eafe
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/McLachlan.c
// Function: center_of_mass
static void center_of_mass(double *ret, double *v, int N, double *mass)
{
  int i, m=0; double norm=0;

  for(i=0;i<3;i++)ret[i] = 0;
  for(i=0;i<N;i++){
    double w=mass[i];
    ret[0] += w*v[m];
    ret[1] += w*v[m+1];
    ret[2] += w*v[m+2];
    norm+=w; m+=3;
  }
  for(i=0;i<3;i++)ret[i]/= norm;
}

// Assembly:
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testl %edx, %edx
jle 0x4f5ea
movsd (%rdi), %xmm1
movsd 0x8(%rdi), %xmm2
movsd 0x10(%rdi), %xmm3
movl %edx, %eax
addq $0x10, %rsi
xorpd %xmm0, %xmm0
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm4
movsd -0x10(%rsi), %xmm5
mulsd %xmm4, %xmm5
addsd %xmm5, %xmm1
movsd %xmm1, (%rdi)
movsd -0x8(%rsi), %xmm5
mulsd %xmm4, %xmm5
addsd %xmm5, %xmm2
movsd %xmm2, 0x8(%rdi)
addsd %xmm4, %xmm0
mulsd (%rsi), %xmm4
addsd %xmm4, %xmm3
movsd %xmm3, 0x10(%rdi)
incq %rdx
addq $0x18, %rsi
cmpq %rdx, %rax
jne 0x4f5a3
jmp 0x4f5ee
xorpd %xmm0, %xmm0
xorl %eax, %eax
movsd (%rdi,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%rax,8)
incq %rax
cmpq $0x3, %rax
jne 0x4f5f0
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/EC.c
// Function: CV_profile
float *CV_profile(double **Corr, int N)
{
  float *CV=malloc(N*sizeof(float));
  for(int i=0; i<N; i++){
    double sum=0, *c=Corr[i];
    for(int j=0; j<N; j++)sum+=c[j];
    CV[i]=sum;
  }
  return(CV);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %r14
leaq (,%r14,4), %rdi
callq 0x21d0
testl %r14d, %r14d
jle 0x500f3
movl %ebp, %ecx
xorl %edx, %edx
movq (%rbx,%rdx,8), %rsi
xorpd %xmm0, %xmm0
xorl %edi, %edi
addsd (%rsi,%rdi,8), %xmm0
incq %rdi
cmpq %rdi, %rcx
jne 0x500d5
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rax,%rdx,4)
incq %rdx
cmpq %rcx, %rdx
jne 0x500cb
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/EC.c
// Function: C1sqr_over_C2
float C1sqr_over_C2(double **Corr, int N, int l)
{
  int i, j;
  double *ci=malloc(N*sizeof(double));
  for(i=0; i<N; i++){
    ci[i]=0; double *cc=Corr[i];
    for(j=0; j<=(i-l); j++){
      ci[i]+=cc[j];
      ci[j]+=cc[j];
    }
  }
  double c1=0, c2=0;
  for(i=0; i<N; i++){c1+=ci[i]; c2+=ci[i]*ci[i];}
  free(ci);
  return((c1*c1)/(N*c2));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
movslq %esi, %r15
leaq (,%r15,8), %rdi
callq 0x21d0
movl %ebx, %ecx
testl %r15d, %r15d
jle 0x50174
movl $0x1, %edx
subl %ebp, %edx
movslq %ebp, %rsi
xorl %edi, %edi
movl %edx, %edx
movq $0x0, (%rax,%rdi,8)
cmpq %rsi, %rdi
jl 0x5016a
movq (%r14,%rdi,8), %r8
xorl %r9d, %r9d
movsd (%r8,%r9,8), %xmm0
movsd (%rax,%rdi,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rdi,8)
addsd (%rax,%r9,8), %xmm0
movsd %xmm0, (%rax,%r9,8)
incq %r9
cmpq %r9, %rdx
jne 0x50142
incq %rdi
incl %edx
cmpq %rcx, %rdi
jne 0x5012c
testl %ebx, %ebx
jle 0x5019d
xorpd %xmm2, %xmm2
xorl %edx, %edx
xorpd %xmm1, %xmm1
movsd (%rax,%rdx,8), %xmm0
addsd %xmm0, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm0, %xmm2
incq %rdx
cmpq %rdx, %rcx
jne 0x50182
jmp 0x501a5
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
movsd %xmm1, 0x8(%rsp)
movsd %xmm2, 0x10(%rsp)
movq %rax, %rdi
callq 0x2050
movsd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
mulsd 0x10(%rsp), %xmm0
divsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpb $0x0, 0x2a825(%rip)     # 0x7aae8
je 0x502d5
movb $0x0, 0x2a81c(%rip)     # 0x7aae8
movss 0x2a818(%rip), %xmm0    # 0x7aaec
retq
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rbx, %rdi
callq 0x503a8
cvtss2sd %xmm0, %xmm0
addsd %xmm0, %xmm0
movsd 0x5dfb(%rip), %xmm1     # 0x560f0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x503a8
movss (%rsp), %xmm3
cvtss2sd %xmm0, %xmm0
addsd %xmm0, %xmm0
addsd 0x5dd1(%rip), %xmm0     # 0x560f0
xorps %xmm2, %xmm2
cvtsd2ss %xmm0, %xmm2
movaps %xmm2, %xmm1
mulss %xmm2, %xmm1
movaps %xmm3, %xmm0
mulss %xmm3, %xmm0
addss %xmm1, %xmm0
ucomiss 0xcd1(%rip), %xmm0      # 0x51010
jae 0x502dd
movss %xmm2, 0x4(%rsp)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x2120
mulsd 0x703a(%rip), %xmm0     # 0x57398
divsd 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x50373
sqrtsd %xmm0, %xmm0
jmp 0x50378
callq 0x2290
movss (%rsp), %xmm1
xorps %xmm2, %xmm2
cvtsd2ss %xmm0, %xmm2
mulss %xmm2, %xmm1
movss %xmm1, 0x2a75c(%rip)    # 0x7aaec
movb $0x1, 0x2a751(%rip)     # 0x7aae8
movss 0x4(%rsp), %xmm0
mulss %xmm2, %xmm0
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movabsq $0x5dfc995681872319, %r14 # imm = 0x5DFC995681872319
testq %rax, %rax
js 0x503cf
testb $0x1, 0x2aa47(%rip)     # 0x7ae10
jne 0x50470
movl $0x24d69, %esi          # imm = 0x24D69
subq %rax, %rsi
movq %rsi, %rax
imulq %r14
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rdx
addq %rax, %rdx
imulq $0xae529, %rdx, %rax    # imm = 0xAE529
subq %rax, %rsi
movq %rsi, %rcx
negq %rcx
cmovsq %rsi, %rcx
movb $0x1, 0x2aa0a(%rip)     # 0x7ae10
movq %rcx, (%rbx)
movl $0x1, %esi
leaq 0x2a6eb(%rip), %rdi     # 0x7ab00
imulq $0x556, %rcx, %rcx      # imm = 0x556
addq $0x24d69, %rcx          # imm = 0x24D69
movq %rcx, %rax
mulq %r14
shrq $0x12, %rdx
imulq $0xae529, %rdx, %rax    # imm = 0xAE529
subq %rax, %rcx
movq %rcx, (%rdi,%rsi,8)
incq %rsi
cmpq $0x62, %rsi
jne 0x50415
imulq $0x556, %rcx, %rcx      # imm = 0x556
addq $0x24d69, %rcx          # imm = 0x24D69
movq %rcx, %rax
mulq %r14
shrq $0x12, %rdx
imulq $0xae529, %rdx, %rax    # imm = 0xAE529
subq %rax, %rcx
movq %rcx, (%rbx)
movq %rcx, 0x2a680(%rip)     # 0x7aaf0
cvtsi2sdq 0x2a677(%rip), %xmm0 # 0x7aaf0
mulsd 0xdfa7(%rip), %xmm0     # 0x5e428
divsd 0xdfa7(%rip), %xmm0     # 0x5e430
addsd 0xbaf(%rip), %xmm0      # 0x51040
cvttsd2si %xmm0, %r15d
leal -0x62(%r15), %eax
cmpl $-0x62, %eax
ja 0x504ad
leaq 0xdf96(%rip), %rdi      # 0x5e43c
xorl %eax, %eax
callq 0x4ad9c
movslq %r15d, %rsi
leaq 0x2a649(%rip), %rdi     # 0x7ab00
movq (%rdi,%rsi,8), %r8
movq %r8, 0x2a62e(%rip)      # 0x7aaf0
imulq $0x556, (%rbx), %rcx    # imm = 0x556
addq $0x24d69, %rcx          # imm = 0x24D69
movq %rcx, %rax
imulq %r14
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rdx
addq %rax, %rdx
imulq $0xae529, %rdx, %rax    # imm = 0xAE529
subq %rax, %rcx
movq %rcx, (%rbx)
xorps %xmm0, %xmm0
cvtsi2ss %r8, %xmm0
movq %rcx, (%rdi,%rsi,8)
divss 0xdf33(%rip), %xmm0     # 0x5e438
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x4a86d(%rip), %rcx     # 0x9ae20
addq $0x8, %rcx
movq 0x4a88a(%rip), %rax     # 0x9ae48
cmpq %rax, %rcx
leaq 0x2a858(%rip), %rdx     # 0x7ae20
cmoveq %rdx, %rcx
movq %rcx, 0x4a84d(%rip)     # 0x9ae20
movq 0x4a84e(%rip), %rsi     # 0x9ae28
addq $0x8, %rsi
cmpq %rax, %rsi
cmoveq %rdx, %rsi
movq %rsi, 0x4a83c(%rip)     # 0x9ae28
movq 0x4a83d(%rip), %rdi     # 0x9ae30
addq $0x8, %rdi
cmpq %rax, %rdi
cmoveq %rdx, %rdi
movq %rdi, 0x4a82b(%rip)     # 0x9ae30
movq 0x4a82c(%rip), %r8      # 0x9ae38
addq $0x8, %r8
cmpq %rax, %r8
cmoveq %rdx, %r8
movq %r8, 0x4a81a(%rip)      # 0x9ae38
movq 0x4a81b(%rip), %r9      # 0x9ae40
addq $0x8, %r9
cmpq %rax, %r9
cmoveq %rdx, %r9
movq %r9, 0x4a809(%rip)      # 0x9ae40
movq (%rdi), %rax
xorq (%rsi), %rax
xorq (%r8), %rax
xorq (%r9), %rax
movq %rax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x4a7d2(%rip), %rax     # 0x9ae20
addq $0x8, %rax
movq 0x4a7ef(%rip), %rcx     # 0x9ae48
cmpq %rcx, %rax
leaq 0x2a7bd(%rip), %rdx     # 0x7ae20
cmoveq %rdx, %rax
movq %rax, 0x4a7b2(%rip)     # 0x9ae20
movq 0x4a7b3(%rip), %rsi     # 0x9ae28
addq $0x8, %rsi
cmpq %rcx, %rsi
cmoveq %rdx, %rsi
movq %rsi, 0x4a7a1(%rip)     # 0x9ae28
movq 0x4a7a2(%rip), %rdi     # 0x9ae30
addq $0x8, %rdi
cmpq %rcx, %rdi
cmoveq %rdx, %rdi
movq %rdi, 0x4a790(%rip)     # 0x9ae30
movq 0x4a791(%rip), %r8      # 0x9ae38
addq $0x8, %r8
cmpq %rcx, %r8
cmoveq %rdx, %r8
movq %r8, 0x4a77f(%rip)      # 0x9ae38
movq 0x4a780(%rip), %r9      # 0x9ae40
addq $0x8, %r9
cmpq %rcx, %r9
cmoveq %rdx, %r9
movq %r9, 0x4a76e(%rip)      # 0x9ae40
movq (%rdi), %rcx
xorq (%rsi), %rcx
xorq (%r8), %rcx
xorq (%r9), %rcx
movq %rcx, (%rax)
movq %rcx, %xmm1
punpckldq 0xdd72(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0xdd7a(%rip), %xmm1     # 0x5e470
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0xdd76(%rip), %xmm0     # 0x5e480
retq