LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/site_dynamics.c
// Function: Site_overlap
int Site_overlap(int *isite, int n1, int *jsite, int n2){
  int nc=0;
  for(int i=0; i<n1; i++){
    int i1=isite[i];
    for(int j=0; j<n2; j++){
      if(i1==jsite[j]){nc++; break;}
    }
  }
  return(nc);
}

// Assembly:
testl %esi, %esi
jle 0x49675
movl %esi, %esi
movl %ecx, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
testl %ecx, %ecx
jle 0x4966c
movl (%rdi,%r9,4), %r10d
xorl %r11d, %r11d
cmpl (%rdx,%r11,4), %r10d
je 0x4966a
incq %r11
cmpq %r11, %r8
jne 0x4965a
jmp 0x4966c
incl %eax
incq %r9
cmpq %rsi, %r9
jne 0x4964f
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/allocate.c
// Function: Empty_matrix_d
void Empty_matrix_d(double **matrix, int N){
  int i;
  if(matrix==NULL)return;
  for(i=0; i<N; i++)free(matrix[i]);
  free(matrix);
}

// Assembly:
testq %rdi, %rdi
je 0x496e3
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x496d6
movl %esi, %r14d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x2050
incq %r15
cmpq %r15, %r14
jne 0x496c5
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2050
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/allocate.c
// Function: Empty_matrix_i
void Empty_matrix_i(int **matrix, int N){
  int i;
  if(matrix==NULL)return;
  for(i=0; i<N; i++)free(matrix[i]);
  free(matrix);
}

// Assembly:
testq %rdi, %rdi
je 0x49719
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x4970c
movl %esi, %r14d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x2050
incq %r15
cmpq %r15, %r14
jne 0x496fb
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2050
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/allocate.c
// Function: Allocate_mat2_f
float **Allocate_mat2_f(int n1, int n2){
  int i, j;
  float **matrix=malloc(n1*sizeof(float *));
  for(i=0; i<n1; i++){
    matrix[i]=malloc(n2*sizeof(float));
    for(j=0; j<n2; j++)matrix[i][j]=0;
  }
  return(matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movslq %edi, %r15
leaq (,%r15,8), %rdi
callq 0x21e0
movq %rax, %r14
testl %r15d, %r15d
jle 0x4977d
movslq %ebx, %rax
leaq (,%rax,4), %r15
movl %eax, %r12d
shlq $0x2, %r12
movl %ebp, %r13d
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x21e0
movq %rax, (%r14,%rbp,8)
testl %ebx, %ebx
jle 0x49775
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2110
incq %rbp
cmpq %rbp, %r13
jne 0x49758
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/allocate.c
// Function: Allocate_mat2_i
int ** Allocate_mat2_i(int n1, int n2){
  int i, j;
  int **matrix=malloc(n1*sizeof(int *));
  for(i=0; i<n1; i++){
    matrix[i]=malloc(n2*sizeof(int));
    for(j=0; j<n2; j++)matrix[i][j]=0;
  }
  return(matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movslq %edi, %r15
leaq (,%r15,8), %rdi
callq 0x21e0
movq %rax, %r14
testl %r15d, %r15d
jle 0x497f2
movslq %ebx, %rax
leaq (,%rax,4), %r15
movl %eax, %r12d
shlq $0x2, %r12
movl %ebp, %r13d
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x21e0
movq %rax, (%r14,%rbp,8)
testl %ebx, %ebx
jle 0x497ea
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2110
incq %rbp
cmpq %rbp, %r13
jne 0x497cd
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/allocate.c
// Function: Allocate_mat2_d
double **Allocate_mat2_d(int n1, int n2){
  int i, j;
  double **matrix=malloc(n1*sizeof(double *));
  for(i=0; i<n1; i++){
    matrix[i]=malloc(n2*sizeof(double));
    for(j=0; j<n2; j++)matrix[i][j]=(double)0;
  }
  return(matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movslq %edi, %r15
leaq (,%r15,8), %rdi
callq 0x21e0
movq %rax, %r14
testl %r15d, %r15d
jle 0x49867
movslq %ebx, %rax
leaq (,%rax,8), %r15
movl %eax, %r12d
shlq $0x3, %r12
movl %ebp, %r13d
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x21e0
movq %rax, (%r14,%rbp,8)
testl %ebx, %ebx
jle 0x4985f
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2110
incq %rbp
cmpq %rbp, %r13
jne 0x49842
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/choldc.c
// Function: choldc
int choldc(double **L, double **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(L==a){
	    // Ugo: Same matrix, 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];
	    }
	  }
	  //exit(8);
	  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, %r9d
movq %rsp, %rcx
leaq 0xf(,%r9,8), %rax
andq $-0x10, %rax
subq %rax, %rcx
movq %rcx, -0x40(%rbp)
movq %rcx, %rsp
testl %edx, %edx
jle 0x49983
movq %rdi, %r14
movl $0x1, %r13d
xorl %r12d, %r12d
movsd 0x146f3(%rip), %xmm2    # 0x5dfb8
xorpd %xmm3, %xmm3
movq %rsi, -0x38(%rbp)
movq %r9, -0x30(%rbp)
leaq (%r14,%r12,8), %rbx
movq %r12, %r15
movq (%rsi,%r12,8), %rax
movsd (%rax,%r15,8), %xmm0
testq %r12, %r12
je 0x4990c
movq (%rbx), %rcx
movq (%r14,%r15,8), %rdx
movq %r13, %r8
leal -0x2(%r8), %edi
movsd (%rcx,%rdi,8), %xmm1
mulsd (%rdx,%rdi,8), %xmm1
subsd %xmm1, %xmm0
decq %r8
cmpq $0x1, %r8
jg 0x498f1
cmpq %r12, %r15
jne 0x49933
ucomisd %xmm0, %xmm2
ja 0x4998a
movsd (%rax,%r12,8), %xmm1
movq -0x40(%rbp), %rax
movsd %xmm1, (%rax,%r12,8)
ucomisd %xmm3, %xmm0
jb 0x49943
sqrtsd %xmm0, %xmm0
jmp 0x4995c
movq (%r14,%r12,8), %rax
divsd (%rax,%r12,8), %xmm0
leaq (%r14,%r15,8), %rax
jmp 0x4995f
callq 0x22a0
xorpd %xmm3, %xmm3
movsd 0x14664(%rip), %xmm2    # 0x5dfb8
movq -0x30(%rbp), %r9
movq -0x38(%rbp), %rsi
movq %rbx, %rax
movq (%rax), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r15
cmpq %r9, %r15
jne 0x498d8
incq %r12
incq %r13
cmpq %r9, %r12
jne 0x498d1
xorl %eax, %eax
jmp 0x49a1f
leaq 0x1462f(%rip), %rdi     # 0x5dfc0
movl %r12d, %esi
movb $0x1, %al
callq 0x20f0
movq -0x38(%rbp), %r10
cmpq %r10, %r14
setne %cl
testq %r12, %r12
sete %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
orb %cl, %dl
jne 0x49a1f
movl %r12d, %ecx
xorl %edx, %edx
movq -0x30(%rbp), %r11
movq %r11, %rsi
movq %r10, %rdi
xorl %r8d, %r8d
movq %r8, %r9
movq -0x40(%rbp), %r8
movsd (%r8,%r9,8), %xmm0
movq (%r10,%r9,8), %r10
movsd %xmm0, (%r10,%r9,8)
leaq 0x1(%r9), %r8
cmpq %r11, %r8
jae 0x49a07
addq %rdx, %r10
movl $0x1, %r11d
movsd (%r10,%r11,8), %xmm0
movq (%rdi,%r11,8), %rbx
movsd %xmm0, (%rbx,%r9,8)
incq %r11
cmpq %r11, %rsi
jne 0x499ef
addq $0x8, %rdi
addq $0x8, %rdx
decq %rsi
cmpq %rcx, %r8
movq -0x38(%rbp), %r10
movq -0x30(%rbp), %r11
jne 0x499c6
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/choldc.c
// Function: Forward_substitution
void Forward_substitution(double *X, double **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, *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 0x49a85
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 0x49a6f
xorl %r10d, %r10d
movsd (%r9), %xmm1
mulsd (%rdi,%r10,8), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%r8)
addq $0x8, %r9
incq %r10
cmpq %r10, %rcx
jne 0x49a4f
divsd (%r9), %xmm0
movsd %xmm0, (%r8)
addq $0x8, %r8
incq %rcx
cmpq %rax, %rcx
jne 0x49a39
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/choldc.c
// Function: Backward_substitution
void Backward_substitution(double *X, double **L, double *Y, int N)
{
  // Solve the matrix equation L^tX=Y, with L=lower diagonal (only i>=j)
  // X_i =(Y_i - sum_j>i L_ji X_j)/L_ii
  int i, j;
  for(i=N-1; i>=0; i--){
    X[i]=Y[i];
    for(j=i+1; j<N; j++)X[i]-= X[j]*L[j][i];
    X[i]/=L[i][i];
  }
}

// Assembly:
testl %ecx, %ecx
jle 0x49afe
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %eax
leaq (%rsi,%rax,8), %r8
leaq (%rdi,%rax,8), %r9
movq %rax, %r10
leaq -0x1(%r10), %r11
movsd -0x8(%rdx,%r10,8), %xmm0
movsd %xmm0, -0x8(%rdi,%r10,8)
cmpq %rax, %r10
jge 0x49ad9
xorl %ebx, %ebx
movsd (%r9,%rbx,8), %xmm1
movq (%r8,%rbx,8), %r14
mulsd (%r14,%r11,8), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%rdi,%r11,8)
incq %rbx
leal (%r10,%rbx), %ebp
cmpl %ecx, %ebp
jl 0x49ab4
movq (%rsi,%r11,8), %rbx
divsd (%rbx,%r11,8), %xmm0
movsd %xmm0, (%rdi,%r11,8)
addq $-0x8, %r8
addq $-0x8, %r9
cmpq $0x1, %r10
movq %r11, %r10
jg 0x49a9b
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/choldc.c
// Function: Cholevsky_inversion_d2f
float **Cholevsky_inversion_d2f(double **L, int N){
  float **L_inv=Allocate_mat2_f(N, N);
  double 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);
    }
    for(i=0; i<N; i++)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 0x4971a
movl %r14d, %ecx
movq %rsp, %rdx
leaq 0xf(,%rcx,8), %rsi
andq $-0x10, %rsi
subq %rsi, %rdx
movq %rdx, %rsp
testl %r14d, %r14d
jle 0x49baf
xorl %esi, %esi
movsd 0x760e(%rip), %xmm0     # 0x51148
xorl %edi, %edi
xorl %r8d, %r8d
movapd %xmm0, %xmm1
cmpq %rsi, %r8
je 0x49b4c
xorpd %xmm1, %xmm1
movq (%rbx,%r8,8), %r9
testq %r8, %r8
je 0x49b74
xorl %r10d, %r10d
movsd (%r9,%r10), %xmm2
mulsd (%rdx,%r10), %xmm2
subsd %xmm2, %xmm1
addq $0x8, %r10
cmpq %r10, %rdi
jne 0x49b58
addq %r10, %r9
divsd (%r9), %xmm1
movsd %xmm1, (%rdx,%r8,8)
incq %r8
addq $0x8, %rdi
cmpq %rcx, %r8
jne 0x49b3f
xorl %edi, %edi
xorps %xmm1, %xmm1
cvtsd2ss (%rdx,%rdi,8), %xmm1
movq (%rax,%rdi,8), %r8
movss %xmm1, (%r8,%rsi,4)
incq %rdi
cmpq %rdi, %rcx
jne 0x49b8d
incq %rsi
cmpq %rcx, %rsi
jne 0x49b3a
leaq -0x10(%rbp), %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x49804
movl %r14d, %ecx
movq %rsp, %rdx
leaq 0xf(,%rcx,8), %rsi
andq $-0x10, %rsi
subq %rsi, %rdx
movq %rdx, %rsp
testl %r14d, %r14d
jle 0x49c56
xorl %esi, %esi
movsd 0x7555(%rip), %xmm0     # 0x51148
xorl %edi, %edi
xorl %r8d, %r8d
movapd %xmm0, %xmm1
cmpq %rsi, %r8
je 0x49c05
xorpd %xmm1, %xmm1
movq (%rbx,%r8,8), %r9
testq %r8, %r8
je 0x49c2d
xorl %r10d, %r10d
movsd (%r9,%r10), %xmm2
mulsd (%rdx,%r10), %xmm2
subsd %xmm2, %xmm1
addq $0x8, %r10
cmpq %r10, %rdi
jne 0x49c11
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 0x49bf8
incq %rsi
cmpq %rcx, %rsi
jne 0x49bf3
leaq -0x10(%rbp), %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r9d
movq %rsp, %rcx
leaq 0xf(,%r9,8), %rax
andq $-0x10, %rax
subq %rax, %rcx
movq %rcx, -0x40(%rbp)
movq %rcx, %rsp
testl %edx, %edx
jle 0x49d7f
movq %rdi, %r14
movl $0x1, %r13d
xorl %r12d, %r12d
movsd 0x14310(%rip), %xmm2    # 0x5dfb8
xorpd %xmm3, %xmm3
movq %rsi, -0x38(%rbp)
movq %r9, -0x30(%rbp)
leaq (%r14,%r12,8), %rbx
movq %r12, %r15
movq (%rsi,%r12,8), %rax
xorps %xmm0, %xmm0
cvtss2sd (%rax,%r15,4), %xmm0
testq %r12, %r12
je 0x49cf6
movq (%rbx), %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 0x49cd7
cmpq %r12, %r15
jne 0x49d24
ucomisd %xmm0, %xmm2
ja 0x49d86
xorps %xmm1, %xmm1
cvtss2sd (%rax,%r12,4), %xmm1
movq -0x40(%rbp), %rax
movsd %xmm1, (%rax,%r12,8)
ucomisd %xmm3, %xmm0
jb 0x49d3b
sqrtsd %xmm0, %xmm0
jmp 0x49d54
movq (%r14,%r12,8), %rax
xorps %xmm1, %xmm1
cvtss2sd (%rax,%r12,4), %xmm1
divsd %xmm1, %xmm0
leaq (%r14,%r15,8), %rax
jmp 0x49d57
callq 0x22a0
xorpd %xmm3, %xmm3
movsd 0x1426c(%rip), %xmm2    # 0x5dfb8
movq -0x30(%rbp), %r9
movq -0x38(%rbp), %rsi
movq %rbx, %rax
cvtsd2ss %xmm0, %xmm0
movq (%rax), %rax
movss %xmm0, (%rax,%r12,4)
incq %r15
cmpq %r9, %r15
jne 0x49cbb
incq %r12
incq %r13
cmpq %r9, %r12
jne 0x49cb4
xorl %eax, %eax
jmp 0x49e1e
leaq 0x14233(%rip), %rdi     # 0x5dfc0
movl %r12d, %esi
movb $0x1, %al
callq 0x20f0
movq -0x38(%rbp), %r10
cmpq %r14, %r10
setne %cl
testq %r12, %r12
sete %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
orb %cl, %dl
jne 0x49e1e
movl %r12d, %ecx
xorl %edx, %edx
movq -0x30(%rbp), %r11
movq %r11, %rsi
movq %r10, %rdi
xorl %r8d, %r8d
movq %r8, %r9
movq -0x40(%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 %r11, %r8
jae 0x49e06
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 0x49dee
addq $0x8, %rdi
addq $0x4, %rdx
decq %rsi
cmpq %rcx, %r8
movq -0x38(%rbp), %r10
movq -0x30(%rbp), %r11
jne 0x49dc2
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x49e8e
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 0x49e71
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 0x49e4e
xorps %xmm1, %xmm1
cvtss2sd (%r9), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%r8)
addq $0x8, %r8
incq %rcx
cmpq %rax, %rcx
jne 0x49e38
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
jle 0x4a1c5
pushq %rbp
pushq %rbx
movl %esi, %eax
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 0x4a13f
movslq %r9d, %r10
cmpq %r10, %r8
jle 0x4a14f
movq (%rdi,%r8,8), %r11
movsd (%r11,%r10,8), %xmm2
mulsd (%rcx,%r10,8), %xmm2
subsd %xmm2, %xmm1
incq %r10
cmpq %r10, %r8
jne 0x4a125
jmp 0x4a14f
ucomisd %xmm0, %xmm1
jne 0x4a147
jnp 0x4a14c
movl %r8d, %r9d
jmp 0x4a14f
xorl %r9d, %r9d
movsd %xmm1, (%rcx,%r8,8)
incq %r8
cmpq %rax, %r8
jne 0x4a0fe
testl %esi, %esi
jle 0x4a1c3
leaq (,%rax,8), %rdx
leaq (%rcx,%rax,8), %r8
movq %rax, %r9
movsd -0x8(%rcx,%r9,8), %xmm0
movq -0x8(%rdi,%r9,8), %r10
cmpq %rax, %r9
jge 0x4a1a2
leaq (%r10,%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 0x4a187
leaq -0x1(%r9), %r11
divsd (%r10,%r11,8), %xmm0
movsd %xmm0, (%rcx,%r11,8)
addq $-0x8, %r8
addq $-0x8, %rdx
cmpq $0x1, %r9
movq %r11, %r9
jg 0x4a170
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x4ac4d
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 0x4abd0
movl %r10d, %r11d
cmpq %r11, %r9
je 0x4ac40
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 0x4ac1c
incq %rcx
cmpq %rax, %r8
jne 0x4abb6
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4acb1
leal 0x1(%rdx), %eax
xorpd %xmm1, %xmm1
movl $0x1, %ecx
addsd (%rsi,%rcx,8), %xmm1
incq %rcx
cmpq %rcx, %rax
jne 0x4ac5e
testl %edx, %edx
jle 0x4acb1
movapd 0x6419(%rip), %xmm2     # 0x51090
xorpd %xmm1, %xmm2
cvtsi2sd %edx, %xmm3
maxsd %xmm1, %xmm2
divsd %xmm3, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
movl $0x1, %ecx
xorl %edx, %edx
ucomisd (%rsi,%rcx,8), %xmm0
setbe %dl
movl %edx, (%rdi,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x4ac9c
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4acf1
leal 0x1(%rbx), %eax
xorpd %xmm1, %xmm1
movl $0x1, %ecx
addsd (%r15,%rcx,8), %xmm1
incq %rcx
cmpq %rcx, %rax
jne 0x4ace1
jmp 0x4acf5
xorpd %xmm1, %xmm1
testl %ebx, %ebx
jle 0x4ae26
movapd 0x638b(%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 0xc63d(%rip), %xmm0     # 0x57370
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 0x4ae1a
ucomisd %xmm0, %xmm2
ja 0x4ae12
xorpd %xmm2, %xmm2
movl $0x1, %ebp
xorpd %xmm1, %xmm1
movq (%r14,%rbp,8), %rax
xorps %xmm0, %xmm0
cvtsd2ss (%rax,%r13,8), %xmm0
ucomiss 0x637f(%rip), %xmm0     # 0x51118
jne 0x4ad9d
jnp 0x4add6
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 0x4ad85
divsd %xmm1, %xmm2
movapd %xmm2, %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0x22b0
mulsd 0x8(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss 0x14(%rsp), %xmm1
ucomiss %xmm0, %xmm1
movsd 0x20(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
jbe 0x4ae1a
movl $0x0, (%r12,%r13,4)
incq %r13
cmpq %rbx, %r13
jne 0x4ad56
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x1c1b2(%rip), %r14     # 0x66ff8
movq (%r14), %rcx
leaq 0x131f8(%rip), %rdi     # 0x5e048
movl $0x24, %esi
movl $0x1, %edx
callq 0x2290
movq (%r14), %rdi
leaq 0x127fc(%rip), %rsi     # 0x5d665
movq %rbx, %rdx
xorl %eax, %eax
callq 0x21a0
movq (%r14), %rcx
leaq 0x131f0(%rip), %rdi     # 0x5e06d
movl $0x1c, %esi
movl $0x1, %edx
callq 0x2290
movl $0x1, %edi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O3/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 0x21e0
testq %rax, %rax
je 0x4aebc
shlq $0x2, %rbx
subq %rbx, %rax
addq $0x4, %rax
popq %rbx
retq
leaq 0x131c7(%rip), %rdi     # 0x5e08a
callq 0x4ae38
// File: /workspace/github_c_makefile_star2_O3/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 0x21e0
testq %rax, %rax
je 0x4aeee
shlq $0x2, %rbx
subq %rbx, %rax
addq $0x4, %rax
popq %rbx
retq
leaq 0x131b4(%rip), %rdi     # 0x5e0a9
callq 0x4ae38
// File: /workspace/github_c_makefile_star2_O3/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 0x21e0
testq %rax, %rax
je 0x4af17
subq %rbx, %rax
incq %rax
popq %rbx
retq
leaq 0x131ab(%rip), %rdi     # 0x5e0c9
callq 0x4ae38
// File: /workspace/github_c_makefile_star2_O3/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 0x21e0
testq %rax, %rax
je 0x4af49
shlq $0x3, %rbx
subq %rbx, %rax
addq $0x8, %rax
popq %rbx
retq
leaq 0x13199(%rip), %rdi     # 0x5e0e9
callq 0x4ae38
// File: /workspace/github_c_makefile_star2_O3/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 0x21e0
testq %rax, %rax
je 0x4af7b
shlq $0x3, %rbx
subq %rbx, %rax
addq $0x8, %rax
popq %rbx
retq
leaq 0x13187(%rip), %rdi     # 0x5e109
callq 0x4ae38
// File: /workspace/github_c_makefile_star2_O3/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 0x21e0
testq %rax, %rax
je 0x4b034
movq %rax, %r15
movq %rbx, %rax
subq %r12, %rax
incq %rax
leaq 0x4(,%rbp,4), %rdi
imulq %rax, %rdi
addq $0x4, %rdi
callq 0x21e0
testq %rax, %rax
je 0x4b040
movq %rax, %rcx
leaq 0x8(%r15), %rax
leaq (,%r13,8), %rdx
shlq $0x2, %r12
subq %r12, %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
subq %rdx, %rax
subq %r13, %r14
jle 0x4b025
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 0x4b015
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x130ee(%rip), %rdi     # 0x5e129
callq 0x4ae38
leaq 0x13103(%rip), %rdi     # 0x5e14a
callq 0x4ae38
// File: /workspace/github_c_makefile_star2_O3/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 0x21e0
testq %rax, %rax
je 0x4b100
movq %rax, %r15
movq %rbx, %rax
subq %r12, %rax
incq %rax
shlq $0x3, %rbp
addq $0x8, %rbp
imulq %rax, %rbp
addq $0x8, %rbp
movq %rbp, %rdi
callq 0x21e0
testq %rax, %rax
je 0x4b10c
movq %rax, %rcx
leaq 0x8(%r15), %rax
leaq (,%r13,8), %rdx
shlq $0x3, %r12
subq %r12, %rcx
addq $0x8, %rcx
movq %rcx, (%rax)
subq %rdx, %rax
subq %r13, %r14
jle 0x4b0f1
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 0x4b0e1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13022(%rip), %rdi     # 0x5e129
callq 0x4ae38
leaq 0x13037(%rip), %rdi     # 0x5e14a
callq 0x4ae38
// File: /workspace/github_c_makefile_star2_O3/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 0x21e0
testq %rax, %rax
je 0x4b1c5
movq %rax, %r15
movq %rbx, %rax
subq %r12, %rax
incq %rax
leaq 0x4(,%rbp,4), %rdi
imulq %rax, %rdi
addq $0x4, %rdi
callq 0x21e0
testq %rax, %rax
je 0x4b1d1
movq %rax, %rcx
leaq 0x8(%r15), %rax
leaq (,%r13,8), %rdx
shlq $0x2, %r12
subq %r12, %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
subq %rdx, %rax
subq %r13, %r14
jle 0x4b1b6
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 0x4b1a6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12f5d(%rip), %rdi     # 0x5e129
callq 0x4ae38
leaq 0x12f72(%rip), %rdi     # 0x5e14a
callq 0x4ae38
// File: /workspace/github_c_makefile_star2_O3/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 0x21e0
testq %rax, %rax
je 0x4b252
addq $0x8, %rax
shlq $0x3, %r13
movq %rax, %rcx
subq %r13, %rcx
subq %r15, %r14
jl 0x4b245
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 0x4b232
movq %rcx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x12f12(%rip), %rdi     # 0x5e16b
callq 0x4ae38
// File: /workspace/github_c_makefile_star2_O3/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 0x21e0
testq %rax, %rax
je 0x4b2db
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 0x4b2ce
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 0x4b2be
movq %rcx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x12eab(%rip), %rdi     # 0x5e18d
callq 0x4ae38
// File: /workspace/github_c_makefile_star2_O3/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 %xmm0, %xmm2
movapd 0xbd08(%rip), %xmm3     # 0x572f0
andpd %xmm3, %xmm2
andpd %xmm1, %xmm3
ucomisd %xmm3, %xmm2
jbe 0x4b600
divsd %xmm2, %xmm3
movapd %xmm2, %xmm0
jmp 0x4b619
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x4b60d
jp 0x4b60d
retq
movapd %xmm3, %xmm0
divsd %xmm3, %xmm2
movapd %xmm2, %xmm3
xorps %xmm1, %xmm1
cvtsd2ss %xmm3, %xmm1
leaq 0x1dae9(%rip), %rax     # 0x69110
movss %xmm1, (%rax)
xorpd %xmm2, %xmm2
ucomiss %xmm2, %xmm1
mulss %xmm1, %xmm1
cvtss2sd %xmm1, %xmm1
movsd 0x5b06(%rip), %xmm2     # 0x51148
addsd %xmm2, %xmm1
jne 0x4b64e
jp 0x4b64e
movapd %xmm2, %xmm1
sqrtsd %xmm1, %xmm1
mulsd %xmm1, %xmm0
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x4c60c
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x4c61b
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
testq %rcx, %rcx
je 0x4c5ac
movl $0x0, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2220
testq %rax, %rax
jne 0x4c61d
movq %r12, %rdi
callq 0x2040
testq %rax, %rax
je 0x4c60f
movq %rax, %r12
movq %rax, %rdi
callq 0x20d0
cmpb $0x2f, -0x1(%r12,%rax)
leaq 0x978b(%rip), %rax      # 0x55d6c
leaq 0x108f6(%rip), %rsi     # 0x5cede
cmoveq %rax, %rsi
movq %rsp, %r15
movq %r15, %rdi
movq %r12, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x2270
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2220
jmp 0x4c61d
xorl %eax, %eax
retq
testq %r15, %r15
je 0x4c61b
movl $0x1, (%r15)
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x21e0
testq %rax, %rax
je 0x4c6b0
movq %rax, %rbx
testl %r15d, %r15d
jle 0x4c6b2
movl %r15d, %r15d
leaq (,%r15,8), %rdx
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2110
imull %r14d, %ebp
movslq %ebp, %r14
movq %r14, %rdi
callq 0x21e0
movq %rax, (%rbx,%r12,8)
testq %rax, %rax
je 0x4c68f
incq %r12
cmpq %r12, %r15
jne 0x4c674
jmp 0x4c6b2
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x4c6a0
callq 0x2050
incq %r14
cmpq %r14, %r15
jne 0x4c692
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_O3/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 0x4c6f8
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x4c6eb
movl %esi, %r14d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
testq %rdi, %rdi
je 0x4c6e3
callq 0x2050
incq %r15
cmpq %r15, %r14
jne 0x4c6d5
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2050
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
movl %esi, %ebx
movl 0x2db98(%rip), %eax     # 0x7aa88
testl %eax, %eax
jle 0x4cf11
movq 0x2db9d(%rip), %rcx     # 0x7aa98
xorl %r14d, %r14d
cmpb %dil, (%rcx,%r14)
je 0x4cf14
incq %r14
cmpq %r14, %rax
jne 0x4cefe
movl %eax, %r14d
jmp 0x4cf19
xorl %r14d, %r14d
cmpl %eax, %r14d
jne 0x4cf3b
movl 0x2db81(%rip), %eax     # 0x7aaa0
cmpl $0x9, %eax
jg 0x4cf3f
movsbl %dil, %esi
leaq 0x1132d(%rip), %rdi     # 0x5e25c
xorl %eax, %eax
callq 0x20f0
movb $0x1, %bpl
jmp 0x4cf53
xorl %ebp, %ebp
jmp 0x4cf53
movb $0x1, %bpl
cmpl $0xa, %eax
jne 0x4cf53
leaq 0x1136e(%rip), %rdi     # 0x5e2bc
callq 0x2090
movslq 0x2db2e(%rip), %rcx     # 0x7aa88
testq %rcx, %rcx
jle 0x4cf77
movq 0x2db32(%rip), %rdx     # 0x7aa98
xorl %eax, %eax
cmpb %bl, (%rdx,%rax)
je 0x4cf79
incq %rax
cmpq %rax, %rcx
jne 0x4cf68
jmp 0x4cf7d
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x4cf9b
movl 0x2db1d(%rip), %eax     # 0x7aaa0
cmpl $0x9, %eax
jg 0x4cfb5
movsbl %bl, %esi
leaq 0x112ca(%rip), %rdi     # 0x5e25c
xorl %eax, %eax
callq 0x20f0
jmp 0x4cfc6
testb %bpl, %bpl
jne 0x4cfc6
movq 0x2dae9(%rip), %rcx     # 0x7aa90
movl %r14d, %edx
movq (%rcx,%rdx,8), %rcx
movl %eax, %eax
movl (%rcx,%rax,4), %eax
jmp 0x4cfce
cmpl $0xa, %eax
jne 0x4cfc6
leaq 0x112fb(%rip), %rdi     # 0x5e2bc
callq 0x2090
incl 0x2dad4(%rip)           # 0x7aaa0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
callq 0x22d0
movq (%rax), %r14
movslq %ebp, %r15
testb $0x2, 0x1(%r14,%r15,2)
je 0x4db58
callq 0x2030
movq (%rax), %rax
movb (%rax,%r15,4), %bpl
movsbq %bl, %r15
testb $0x2, 0x1(%r14,%r15,2)
je 0x4db70
callq 0x2030
movq (%rax), %rax
movb (%rax,%r15,4), %bl
movl 0x2cf12(%rip), %eax     # 0x7aa88
testl %eax, %eax
jle 0x4db97
movq 0x2cf17(%rip), %rcx     # 0x7aa98
xorl %r14d, %r14d
cmpb (%rcx,%r14), %bpl
je 0x4db9a
incq %r14
cmpq %r14, %rax
jne 0x4db84
movl %eax, %r14d
jmp 0x4db9f
xorl %r14d, %r14d
cmpl %eax, %r14d
jne 0x4dbc1
movl 0x2ceff(%rip), %eax     # 0x7aaa4
cmpl $0x9, %eax
jg 0x4dbc5
movsbl %bpl, %esi
leaq 0x106a7(%rip), %rdi     # 0x5e25c
xorl %eax, %eax
callq 0x20f0
movb $0x1, %bpl
jmp 0x4dbd9
xorl %ebp, %ebp
jmp 0x4dbd9
movb $0x1, %bpl
cmpl $0xa, %eax
jne 0x4dbd9
leaq 0x106e8(%rip), %rdi     # 0x5e2bc
callq 0x2090
movslq 0x2cea8(%rip), %rcx     # 0x7aa88
testq %rcx, %rcx
jle 0x4dbfd
movq 0x2ceac(%rip), %rdx     # 0x7aa98
xorl %eax, %eax
cmpb (%rdx,%rax), %bl
je 0x4dbff
incq %rax
cmpq %rax, %rcx
jne 0x4dbee
jmp 0x4dc03
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x4dc21
movl 0x2ce9b(%rip), %eax     # 0x7aaa4
cmpl $0x9, %eax
jg 0x4dc3b
movsbl %bl, %esi
leaq 0x10644(%rip), %rdi     # 0x5e25c
xorl %eax, %eax
callq 0x20f0
jmp 0x4dc4c
testb %bpl, %bpl
jne 0x4dc4c
movq 0x2ce63(%rip), %rcx     # 0x7aa90
movl %r14d, %edx
movq (%rcx,%rdx,8), %rcx
movl %eax, %eax
movl (%rcx,%rax,4), %eax
jmp 0x4dc54
cmpl $0xa, %eax
jne 0x4dc4c
leaq 0x10675(%rip), %rdi     # 0x5e2bc
callq 0x2090
incl 0x2ce52(%rip)           # 0x7aaa4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2cb5f(%rip), %rdx     # 0x7aa90
movq (%rdx), %rax
movl (%rax), %eax
movslq 0x2cb4b(%rip), %rsi     # 0x7aa88
testq %rsi, %rsi
jle 0x4df99
xorl %edi, %edi
movl %eax, %ecx
movq (%rdx,%rdi,8), %r8
xorl %r9d, %r9d
movl %eax, %r10d
movl (%r8,%r9,4), %r11d
cmpl %eax, %r11d
cmovgl %r11d, %eax
cmpl %ecx, %r11d
cmovll %r11d, %ecx
cmovll %r10d, %eax
incq %r9
cmpq %r9, %rsi
jne 0x4df4d
incq %rdi
cmpq %rsi, %rdi
jne 0x4df46
testl %esi, %esi
jle 0x4df9b
xorl %edi, %edi
movq (%rdx,%rdi,8), %r8
xorl %r9d, %r9d
subl %ecx, (%r8,%r9,4)
incq %r9
cmpq %r9, %rsi
jne 0x4df83
incq %rdi
cmpq %rsi, %rdi
jne 0x4df7c
jmp 0x4df9b
movl %eax, %ecx
subl %ecx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %xmm1, %xmm1
movupd %xmm1, (%rdi)
movq $0x0, 0x10(%rdi)
testl %edx, %edx
jle 0x4e9f4
movl %edx, %eax
addq $0x8, %rsi
xorpd %xmm2, %xmm2
xorl %edx, %edx
xorpd %xmm0, %xmm0
xorps %xmm3, %xmm3
cvtss2sd (%rcx,%rdx,4), %xmm3
cvtps2pd -0x8(%rsi), %xmm4
xorps %xmm5, %xmm5
cvtss2sd (%rsi), %xmm5
mulsd %xmm3, %xmm5
addsd %xmm3, %xmm0
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
mulpd %xmm4, %xmm3
addpd %xmm3, %xmm1
addsd %xmm5, %xmm2
incq %rdx
addq $0xc, %rsi
cmpq %rdx, %rax
jne 0x4e9b2
movupd %xmm1, (%rdi)
movsd %xmm2, 0x10(%rdi)
jmp 0x4e9f8
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 0x4e9fa
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4ea4f
movupd (%rsi), %xmm0
movsd 0x10(%rsi), %xmm1
addq $0x8, %rdi
cvtps2pd -0x8(%rdi), %xmm2
addpd %xmm0, %xmm2
cvtpd2ps %xmm2, %xmm2
movlpd %xmm2, -0x8(%rdi)
xorps %xmm2, %xmm2
cvtss2sd (%rdi), %xmm2
addsd %xmm1, %xmm2
cvtsd2ss %xmm2, %xmm2
movss %xmm2, (%rdi)
addq $0xc, %rdi
decl %edx
jne 0x4ea23
retq