LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/anharmonic_tnm.c
// Function: Initialize_energy
void Initialize_energy(struct interaction *Int_list, int N_int,
		       float *r, atom *atoms, int natoms, int nres)
{
  INI_ENERGY=1;

  E_repulsion=Int_list[0].A4;
  C22=C_THR*C_THR;
  lambda_2=2*lambda;
  lambda_4=4*lambda;
  
  // Auxiliary matrices for energy computation: interaction list
  nat_res1_res2=Native_interactions(Int_list, N_int, atoms, nres);
  // YY matrix with the index of the interaction data (in Int_list)
  INT_MAX=150*nres;
  Int_list_all=malloc(INT_MAX*sizeof(struct interaction));
  N_int_all=
    Interactions_CA(Int_list_all, d_CA_high, atoms, natoms, nres, r);
  N_int_ini=N_int_all;
  Int_list_ini=malloc(N_int_ini*sizeof(struct interaction));
  for(int i=0; i<N_int_ini; i++)Int_list_ini[i]=Int_list_all[i];
  // YY List of interactions with d(CA-CA)<22
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movl $0x1, 0x74ba3(%rip)     # 0x9c24c
movq -0x8(%rbp), %rax
movsd 0x48(%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
leaq 0x649db(%rip), %rax     # 0x8c098
movss %xmm0, (%rax)
leaq 0x64960(%rip), %rax     # 0x8c028
movss (%rax), %xmm0
leaq 0x64955(%rip), %rax     # 0x8c028
mulss (%rax), %xmm0
movss %xmm0, 0x74bbd(%rip)    # 0x9c29c
movss 0x4e9ad(%rip), %xmm0    # 0x76094
leaq 0x649a6(%rip), %rax     # 0x8c094
mulss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x74ba2(%rip)    # 0x9c2a0
movss 0x548e6(%rip), %xmm0    # 0x7bfec
leaq 0x64987(%rip), %rax     # 0x8c094
mulss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x74b8b(%rip)    # 0x9c2a8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rdx
movl -0x28(%rbp), %ecx
callq 0x270e0
movq %rax, 0x74b59(%rip)     # 0x9c290
imull $0x96, -0x28(%rbp), %eax
movl %eax, 0x74b54(%rip)     # 0x9c298
movslq 0x74b4d(%rip), %rax     # 0x9c298
imulq $0xc8, %rax, %rdi
callq 0x1180
movq %rax, 0x74b22(%rip)     # 0x9c280
movq 0x74b1b(%rip), %rdi     # 0x9c280
movss 0x646e3(%rip), %xmm0    # 0x8be50
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %r8
callq 0x260b0
movl %eax, 0x74af6(%rip)     # 0x9c27c
movl 0x74af0(%rip), %eax     # 0x9c27c
movl %eax, 0x74ae6(%rip)     # 0x9c278
movslq 0x74adf(%rip), %rax     # 0x9c278
imulq $0xc8, %rax, %rdi
callq 0x1180
movq %rax, 0x74adc(%rip)     # 0x9c288
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl 0x74abc(%rip), %eax     # 0x9c278
jge 0x277fd
movq 0x74ac3(%rip), %rdi     # 0x9c288
movslq -0x2c(%rbp), %rax
imulq $0xc8, %rax, %rax
addq %rax, %rdi
movq 0x74aa6(%rip), %rsi     # 0x9c280
movslq -0x2c(%rbp), %rax
imulq $0xc8, %rax, %rax
addq %rax, %rsi
movl $0xc8, %edx
callq 0x1160
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x277b3
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/anharmonic_tnm.c
// Function: Dist_thr
int Dist_thr(struct interaction *Int_cov, atom *atoms){
  if(Int_cov->i1>=0 && Int_cov->i2>=0){   
    double *r1=atoms[Int_cov->i1].r, *r2=atoms[Int_cov->i2].r;
    double d2=0, d; for(int j=0; j<3; j++){d=r1[j]-r2[j]; d*=d; d2+=d;}
    Int_cov->r0=sqrt(d2);
    if(Int_cov->r0 < C_THR){return(1);}
    else{return(0);}
  }
  return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jl 0x291c8
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x291c8
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x4(%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x3c(%rbp)
cmpl $0x3, -0x3c(%rbp)
jge 0x29185
movq -0x20(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x3c(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x29137
movsd -0x30(%rbp), %xmm0
callq 0x1220
movq -0x10(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movq -0x10(%rbp), %rax
movsd 0x20(%rax), %xmm1
leaq 0x62e80(%rip), %rax     # 0x8c028
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x291bf
movl $0x1, -0x4(%rbp)
jmp 0x291cf
movl $0x0, -0x4(%rbp)
jmp 0x291cf
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/anharmonic_tnm.c
// Function: Print_potential
void Print_potential(FILE *file_out, struct interaction *Int,
		     int a, int b, char *what, char *AA_code)
{
  fprintf(file_out, "# %s potential %c-%c, r0= %.2f Vmin= %.3f V''= %.3f\n",
	  what, AA_code[a], AA_code[b], Int->r0, Int->E_min, Int->sec_der);
  fprintf(file_out, "# A4= %.3g A2= %.3g A1= %.3g A0= %.3g\n",
	  Int->A4, Int->A2, Int->A1, Int->A0);
  fprintf(file_out, "# r1= %.2f r2= %.2f r3= %.2f\n", Int->r1, Int->r2, Int->r3);
  int n=100; float r=1.5, dr=(5.0-r)/n;
  for(int k=0; k<n; k++){
    fprintf(file_out, "%.2f %.4g\n", r, Compute_V(Int, r)); r+=dr;
  }
  fprintf(file_out, "&\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rsi
movsbl (%rax,%rsi), %r8d
movq -0x10(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0xb8(%rax), %xmm1
movq -0x10(%rbp), %rax
movsd 0x28(%rax), %xmm2
leaq 0x5249b(%rip), %rsi     # 0x7d30f
movb $0x3, %al
callq 0x1150
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd 0x48(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x40(%rax), %xmm1
movq -0x10(%rbp), %rax
movsd 0x38(%rax), %xmm2
movq -0x10(%rbp), %rax
movsd 0x30(%rax), %xmm3
leaq 0x5249a(%rip), %rsi     # 0x7d344
movb $0x4, %al
callq 0x1150
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movss 0x10(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x10(%rbp), %rax
movss 0x14(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
movq -0x10(%rbp), %rax
movss 0x18(%rax), %xmm2
cvtss2sd %xmm2, %xmm2
leaq 0x52488(%rip), %rsi     # 0x7d36b
movb $0x3, %al
callq 0x1150
movl $0x64, -0x2c(%rbp)
movss 0x514ff(%rip), %xmm0    # 0x7c3f8
movss %xmm0, -0x30(%rbp)
movss -0x30(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x51521(%rip), %xmm0    # 0x7c430
subsd %xmm1, %xmm0
cvtsi2sdl -0x2c(%rbp), %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x2af90
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movss -0x30(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movss -0x30(%rbp), %xmm0
callq 0x27810
movq -0x48(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
cvtss2sd %xmm1, %xmm1
leaq 0x5241a(%rip), %rsi     # 0x7d389
movb $0x2, %al
callq 0x1150
movss -0x34(%rbp), %xmm0
addss -0x30(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x2af2c
movq -0x8(%rbp), %rdi
leaq 0x523f9(%rip), %rsi     # 0x7d394
movb $0x0, %al
callq 0x1150
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/anharmonic_tnm.c
// Function: Print_interactions_KB
void Print_interactions_KB(struct interaction **Int_KB,
			   char *AA_code, int NA, char *name)
{
  // Prepare for printing
  char nameout[100];
  sprintf(nameout,"%s.Inter_KB.dat",name);
  FILE *file_out=fopen(nameout, "w");
  printf("Writing %s\n", nameout);
  fprintf(file_out, "# NPAR= %d\n#r V(r)\n", NPAR);
  for(int a=0; a<NA; a++){
    for(int b=0; a<NA; a++){
      struct interaction *I_KB=Int_KB[a]+b;
      Print_potential(file_out, I_KB, a,b, "Knowledge-based", AA_code);
    }
  }
  fclose(file_out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x90(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x52323(%rip), %rsi     # 0x7d2ff
movb $0x0, %al
callq 0x1200
leaq -0x90(%rbp), %rdi
leaq 0x51381(%rip), %rsi     # 0x7c372
callq 0x11b0
movq %rax, -0x98(%rbp)
leaq -0x90(%rbp), %rsi
leaq 0x4c4e3(%rip), %rdi     # 0x774ee
movb $0x0, %al
callq 0x10d0
movq -0x98(%rbp), %rdi
movl 0x60e21(%rip), %edx     # 0x8be40
leaq 0x522a5(%rip), %rsi     # 0x7d2cb
movb $0x0, %al
callq 0x1150
movl $0x0, -0x9c(%rbp)
movl -0x9c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2b0d3
movl $0x0, -0xa0(%rbp)
movl -0x9c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2b0bd
movq -0x8(%rbp), %rax
movslq -0x9c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xa0(%rbp), %rcx
imulq $0xc8, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0xa8(%rbp)
movq -0x98(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movl -0x9c(%rbp), %edx
movl -0xa0(%rbp), %ecx
movq -0x10(%rbp), %r9
leaq 0x52248(%rip), %r8      # 0x7d2ef
callq 0x2ae10
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9c(%rbp)
jmp 0x2b050
jmp 0x2b0bf
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9c(%rbp)
jmp 0x2b037
movq -0x98(%rbp), %rdi
callq 0x10a0
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/contacts.c
// Function: Contact_energy
float Contact_energy(struct interaction *Int_list, int N_int,
		     struct residue *seq){
  double E=0; int i, ai, aj, res=-1;
  for(i=0; i<N_int; i++){
    ai=Code_AA(seq[Int_list[i].res1].amm);
    if(ai<0){
      if(res!=Int_list[i].res1){
        res=Int_list[i].res1;
	printf("WARNING, unknown a.a. %c residue %d\n",seq[res].amm, res);
      }
      continue;
    }
    aj=Code_AA(seq[Int_list[i].res2].amm);
    if(aj<0){
      if(res!=Int_list[i].res2){
        res=Int_list[i].res2;
	printf("WARNING, unknown a.a. %c residue %d\n",seq[res].amm, res);
      }
      continue;
    }
    E+=Econt[ai][aj];
  }
  return(E);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2bea5
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x24(%rbp), %rdx
imulq $0xc8, %rdx, %rdx
addq %rdx, %rcx
movslq 0x8(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsbl 0x13(%rax), %edi
callq 0x2bec0
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jge 0x2bde3
movl -0x30(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x24(%rbp), %rdx
imulq $0xc8, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
je 0x2bdde
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0xc8, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsbl 0x13(%rax), %esi
movl -0x30(%rbp), %edx
leaq 0x5185d(%rip), %rdi     # 0x7d634
movb $0x0, %al
callq 0x10d0
jmp 0x2be97
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x24(%rbp), %rdx
imulq $0xc8, %rdx, %rdx
addq %rdx, %rcx
movslq 0xc(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsbl 0x13(%rax), %edi
callq 0x2bec0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x2be6e
movl -0x30(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x24(%rbp), %rdx
imulq $0xc8, %rdx, %rdx
addq %rdx, %rcx
cmpl 0xc(%rcx), %eax
je 0x2be6c
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0xc8, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsbl 0x13(%rax), %esi
movl -0x30(%rbp), %edx
leaq 0x517cf(%rip), %rdi     # 0x7d634
movb $0x0, %al
callq 0x10d0
jmp 0x2be97
leaq 0x602cb(%rip), %rax     # 0x8c140
movq (%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2bd49
movsd -0x20(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/contacts.c
// Function: Code_AA
int Code_AA(char res){
  int i; for(i=0; i<20; i++)if(res==AA_code[i])return(i);
  if(res=='-')return(20); // gap
  i=(int)res; char r; if(i>96){r=(char)(i-32);}else{r=res;}
  for(i=0; i<20; i++)if(r==AA_code[i])return(i);
  //printf("WARNING, wrong aa type %c\n", res);
  return(-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x14, -0xc(%rbp)
jge 0x2bf09
movsbl -0x5(%rbp), %eax
leaq 0x60256(%rip), %rcx     # 0x8c138
movq (%rcx), %rcx
movslq -0xc(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x2befc
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2bf7c
jmp 0x2befe
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2bed1
movsbl -0x5(%rbp), %eax
cmpl $0x2d, %eax
jne 0x2bf1b
movl $0x14, -0x4(%rbp)
jmp 0x2bf7c
movsbl -0x5(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x60, -0xc(%rbp)
jle 0x2bf33
movl -0xc(%rbp), %eax
subl $0x20, %eax
movb %al, -0xd(%rbp)
jmp 0x2bf39
movb -0x5(%rbp), %al
movb %al, -0xd(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x14, -0xc(%rbp)
jge 0x2bf75
movsbl -0xd(%rbp), %eax
leaq 0x601e7(%rip), %rcx     # 0x8c138
movq (%rcx), %rcx
movslq -0xc(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x2bf68
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2bf7c
jmp 0x2bf6a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2bf40
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/screened_interactions.c
// Function: Screening_distance
int Screening_distance(float *d2_nb, float *d2_bo, float D2_NB, float D2_BO,
		       struct store *store1, float d2_ij,
		       atom *atom_i, atom *atom_j, atom *atoms)
{
  int resi=atom_i->res, resj=atom_j->res;
  while(store1 != NULL){
    if(store1->x > d2_ij)break; // store1->x= d2_ik
    atom *atom_k=atoms+store1->i;
    if(atom_k!=atom_j){
      float d2, d2_jk=Dist2(atom_j->r, atom_k->r);
      if(d2_jk >= d2_ij)goto next3;
      if(d2_jk > store1->x){
	d2=d2_jk;
      }else{
	d2=store1->x;
      }
      if(d2 < D2_NB){
	int bond=Bond(atom_k->res, resi, store1->x, resj, d2_jk);
	if(bond){
	  if(d2 < D2_BO){*d2_bo=d2; return(1);}
	}else{
	  if(d2 < D2_NB){*d2_nb=d2; return(1);}
	}
      }
    }
  next3:
    store1=store1->next;
  }
  return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movss %xmm1, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movss %xmm2, -0x2c(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq %r9, -0x48(%rbp)
movq -0x38(%rbp), %rax
movl 0x64(%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x40(%rbp), %rax
movl 0x64(%rax), %eax
movl %eax, -0x50(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2d22e
movq -0x28(%rbp), %rax
movss 0x4(%rax), %xmm0
ucomiss -0x2c(%rbp), %xmm0
jbe 0x2d122
jmp 0x2d22e
movq -0x48(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq (%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x2d21b
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x2db20
movss %xmm0, -0x60(%rbp)
movss -0x60(%rbp), %xmm0
ucomiss -0x2c(%rbp), %xmm0
jb 0x2d168
jmp 0x2d21d
movss -0x60(%rbp), %xmm0
movq -0x28(%rbp), %rax
ucomiss 0x4(%rax), %xmm0
jbe 0x2d183
movss -0x60(%rbp), %xmm0
movss %xmm0, -0x5c(%rbp)
jmp 0x2d191
movq -0x28(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x5c(%rbp)
movss -0x5c(%rbp), %xmm1
movss -0x1c(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2d219
movq -0x58(%rbp), %rax
movl 0x64(%rax), %edi
movl -0x4c(%rbp), %esi
movq -0x28(%rbp), %rax
movss 0x4(%rax), %xmm0
movl -0x50(%rbp), %edx
movss -0x60(%rbp), %xmm1
callq 0x21a70
movl %eax, -0x64(%rbp)
cmpl $0x0, -0x64(%rbp)
je 0x2d1f0
movss -0x5c(%rbp), %xmm1
movss -0x20(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2d1ee
movss -0x5c(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x2d235
jmp 0x2d217
movss -0x5c(%rbp), %xmm1
movss -0x1c(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2d215
movss -0x5c(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x2d235
jmp 0x2d217
jmp 0x2d219
jmp 0x2d21b
jmp 0x2d21d
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2d103
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/screened_interactions.c
// Function: Screening_distance_old
int Screening_distance_old(float *d2_nb, float *d2_bo,
			   int res1, struct store *store1,
			   atom *atom2, atom *atoms)
{
  int res2=atom2->res;
  while(store1 != NULL){
    atom *atom3=atoms+store1->i;
    if(atom3!=atom2){
      float d_13=store1->x, d_23=Dist2(atom2->r, atom3->r);
      int bond=Bond(atom3->res, res1, d_13, res2, d_23);
      if(d_23 > d_13){
	if(bond){if(d_23 < *d2_bo)*d2_bo=d_23;}
	else{if(d_23 < *d2_nb)*d2_nb=d_23;}
      }else{
	if(bond){if(d_13 < *d2_bo)*d2_bo=d_13;}
	else{if(d_13 < *d2_nb)*d2_nb=d_13;}
      }
    }
    store1=store1->next;
  }
  return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl 0x64(%rax), %eax
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2db09
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x2daf8
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x44(%rbp)
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x2db20
movss %xmm0, -0x48(%rbp)
movq -0x40(%rbp), %rax
movl 0x64(%rax), %edi
movl -0x14(%rbp), %esi
movss -0x44(%rbp), %xmm0
movl -0x34(%rbp), %edx
movss -0x48(%rbp), %xmm1
callq 0x21a70
movl %eax, -0x4c(%rbp)
movss -0x48(%rbp), %xmm0
ucomiss -0x44(%rbp), %xmm0
jbe 0x2daac
cmpl $0x0, -0x4c(%rbp)
je 0x2da89
movss -0x48(%rbp), %xmm1
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2da87
movss -0x48(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
jmp 0x2daaa
movss -0x48(%rbp), %xmm1
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2daa8
movss -0x48(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
jmp 0x2daaa
jmp 0x2daf6
cmpl $0x0, -0x4c(%rbp)
je 0x2dad3
movss -0x44(%rbp), %xmm1
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2dad1
movss -0x44(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
jmp 0x2daf4
movss -0x44(%rbp), %xmm1
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2daf2
movss -0x44(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
jmp 0x2daf4
jmp 0x2daf6
jmp 0x2daf8
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2d9e9
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/screened_interactions.c
// Function: Dist2
float Dist2(double *ri, double *rj){
  double d=ri[0]-rj[0], d2=d*d;
  d=ri[1]-rj[1]; d2+=d*d;
  d=ri[2]-rj[2]; d2+=d*d;
  return(d2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
subsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
subsd 0x8(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd -0x18(%rbp), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rbp), %rax
subsd 0x10(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd -0x18(%rbp), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/screened_interactions.c
// Function: Scalar
float Scalar(double *ri, double *rj, double *rk){
  double dijk=0; int a;
  for(a=0; a<3; a++){
    double dij=ri[a]-rj[a], dik=ri[a]-rk[a];
    dijk+=dij*dik;
  } 
  return(dijk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jge 0x2dc5a
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2dbef
movsd -0x20(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/kinetic_tnm.c
// Function: Center_atoms
void Center_atoms(atom *atoms, int N_atoms, struct Reference Ref)
{
  double r_tot[3], M_tot=0; int iref, i, j;
  for(j=0; j<3; j++)r_tot[j]=0;
  for(iref=0; iref< Ref.N_ref; iref++){
    double *r=atoms[Ref.atom_num[iref]].r;
    double m = Ref.mass_atom[iref];
    M_tot+=m; for(j=0; j<3; j++)r_tot[j]+=m*r[j];
  }
  for(j=0; j<3; j++)r_tot[j]/=M_tot;
  for(i=0; i<N_atoms; i++){
    for(j=0; j<3; j++)atoms[i].r[j]-=r_tot[j];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x44(%rbp)
cmpl $0x3, -0x44(%rbp)
jge 0x2e1a0
movslq -0x44(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp,%rax,8)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x2e182
movl $0x0, -0x3c(%rbp)
movq -0x60(%rbp), %rcx
movl -0x3c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x2e24c
movq -0x60(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rax), %rdx
movslq -0x3c(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
imulq $0x70, %rdx, %rdx
addq %rdx, %rcx
movq %rcx, -0x50(%rbp)
movq 0x10(%rax), %rax
movslq -0x3c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x44(%rbp)
cmpl $0x3, -0x44(%rbp)
jge 0x2e23c
movsd -0x58(%rbp), %xmm0
movq -0x50(%rbp), %rax
movslq -0x44(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movslq -0x44(%rbp), %rax
movsd -0x30(%rbp,%rax,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp,%rax,8)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x2e201
jmp 0x2e23e
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x2e1a7
movl $0x0, -0x44(%rbp)
cmpl $0x3, -0x44(%rbp)
jge 0x2e27d
movsd -0x38(%rbp), %xmm1
movslq -0x44(%rbp), %rax
movsd -0x30(%rbp,%rax,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp,%rax,8)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x2e253
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2e2dc
movl $0x0, -0x44(%rbp)
cmpl $0x3, -0x44(%rbp)
jge 0x2e2cf
movslq -0x44(%rbp), %rax
movsd -0x30(%rbp,%rax,8), %xmm1
movq -0x8(%rbp), %rax
movslq -0x40(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movslq -0x44(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x2e293
jmp 0x2e2d1
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x2e284
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/kinetic_tnm.c
// Function: Eckart_test
void Eckart_test(float **Jacobian_ar, int N_axes,
		 atom *atoms, int N_atoms,
		 struct Reference Ref, struct axe *axes)
{
  printf("Testing Eckart conditions for each axis (%d)\n", N_axes);
  int EV=0;
  for(int k=0; k<N_axes; k++){
    EV+=Test_Eckart(Jacobian_ar[k], atoms, N_atoms, Ref, k, axes+k);
  }
  if(EV){
    printf("ERROR, %d violations of the Eckart conditions\n", EV);
    exit(8);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl -0xc(%rbp), %esi
leaq 0x4e735(%rip), %rdi     # 0x7db31
movb $0x0, %al
callq 0x10d0
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2f474
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x30(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x30(%rbp), %ecx
movq -0x28(%rbp), %r8
movslq -0x30(%rbp), %r9
imulq $0x158, %r9, %r9        # imm = 0x158
addq %r9, %r8
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x31020
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2f411
cmpl $0x0, -0x2c(%rbp)
je 0x2f495
movl -0x2c(%rbp), %esi
leaq 0x4e6db(%rip), %rdi     # 0x7db5f
movb $0x0, %al
callq 0x10d0
movl $0x8, %edi
callq 0x1210
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/kinetic_tnm.c
// Function: Transpose_matrix
float **Transpose_matrix(float **M, int n1, int n2){
  float **M_tr=Allocate_mat2_f(n2, n1); int i, j;
  for(i=0; i<n2; i++){
    for(j=0; j<n1; j++)M_tr[i][j]=M[j][i];
  }
  return(M_tr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x69360
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x2fe31
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2fe24
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2fde7
jmp 0x2fe26
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2fdd8
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/kinetic_tnm.c
// Function: Transpose_matrix_d2f
float **Transpose_matrix_d2f(double **M, int n1, int n2){
  float **M_tr=Allocate_mat2_f(n2, n1); int i, j;
  for(i=0; i<n2; i++){
    for(j=0; j<n1; j++)M_tr[i][j]=M[j][i];
  }
  return(M_tr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x69360
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x2fec5
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2feb8
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2fe77
jmp 0x2feba
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2fe68
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/kinetic_tnm.c
// Function: Inertia_tensor
void Inertia_tensor(double **inertia, double **corr_sum,
	            double *r_sum, double M_sum)
{
  // Only upper diagonal of corr_sum is needed
  int i, j; double r2;
  for(i=0; i<3; i++){
    for(j=i; j<3; j++)
      inertia[i][j]=corr_sum[i][j]-r_sum[i]*r_sum[j]/M_sum;
  }
  r2=inertia[0][0]+inertia[1][1]+inertia[2][2];
  for(i=0; i<3; i++){
    inertia[i][i]=r2-inertia[i][i];
    for(j=i+1; j<3; j++){
      inertia[i][j]=-inertia[i][j];
      inertia[j][i]= inertia[i][j];
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jge 0x303d3
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x3, -0x28(%rbp)
jge 0x303c6
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm1
divsd -0x20(%rbp), %xmm1
subsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x30368
jmp 0x303c8
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3035c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addsd 0x10(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jge 0x304d2
movsd -0x30(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
cmpl $0x3, -0x28(%rbp)
jge 0x304c2
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x30446
jmp 0x304c4
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x30404
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/kinetic_tnm.c
// Function: Dof_overlap
int Dof_overlap(struct axe *axe_k, struct axe *axe_l)
{
  // dof k<=l. Returns 1 if they move a common subset of atoms
  if((axe_l->first_kin>=axe_k->first_kin)&&
     (axe_l->last_kin <=axe_k->last_kin)){
    return(1);
  }else if((axe_k->last_kin < axe_l->first_kin)||
	   (axe_l->last_kin < axe_k->first_kin)){
    return(0);
  }
  printf("ERROR, not nested axes\n");
  printf("k: type %c first_kin: %d last_kin: %d\n",
	 axe_k->type, axe_k->first_kin, axe_k->last_kin);
  printf("l: type %c first_kin: %d last_kin: %d\n",
	 axe_l->type, axe_l->first_kin, axe_l->last_kin);
  exit(8);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jl 0x3051c
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jg 0x3051c
movl $0x1, -0x4(%rbp)
jmp 0x305a5
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jl 0x3053c
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x30545
movl $0x0, -0x4(%rbp)
jmp 0x305a5
jmp 0x30547
leaq 0x4d6fa(%rip), %rdi     # 0x7dc48
movb $0x0, %al
callq 0x10d0
movq -0x10(%rbp), %rax
movsbl (%rax), %esi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %ecx
leaq 0x4d6ef(%rip), %rdi     # 0x7dc60
movb $0x0, %al
callq 0x10d0
movq -0x18(%rbp), %rax
movsbl (%rax), %esi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %edx
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %ecx
leaq 0x4d6f3(%rip), %rdi     # 0x7dc87
movb $0x0, %al
callq 0x10d0
movl $0x8, %edi
callq 0x1210
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/kinetic_tnm.c
// Function: Sum_inertia
float Sum_inertia(double *mr_tot, double **corr_sum,
		  atom *atoms, struct Reference Ref,
		  int ini_ref, int end_ref)
{
  double M_tot=0; int i, j;
  for(int iref=ini_ref; iref<=end_ref; iref++){
    double *r=atoms[Ref.atom_num[iref]].r;
    double m = Ref.mass_atom[iref];
    M_tot+=m;
    for(i=0; i<3; i++){
      float mri=m*r[i]; mr_tot[i]+=mri;
      for(j=i; j<3; j++)corr_sum[i][j]+=mri*r[j];
    }
  }
  return(M_tot);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x30903
movq -0x58(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x28(%rax), %rdx
movslq -0x34(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
imulq $0x70, %rdx, %rdx
addq %rdx, %rcx
movq %rcx, -0x40(%rbp)
movq 0x10(%rax), %rax
movslq -0x34(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x3, -0x2c(%rbp)
jge 0x308f3
movsd -0x48(%rbp), %xmm0
movq -0x40(%rbp), %rax
movslq -0x2c(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4c(%rbp)
movss -0x4c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $0x3, -0x30(%rbp)
jge 0x308e3
movss -0x4c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x40(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x3089a
jmp 0x308e5
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x30854
jmp 0x308f5
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x307fd
movsd -0x28(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/kinetic_tnm.c
// Function: Allocate_Jacobian
void Allocate_Jacobian(struct Jacobian *J, int N_axes, int N_Cart)
{
  J->N_axes=N_axes; J->N_Cart=N_Cart;
  J->T=Allocate_mat2_d(N_axes,N_axes);
  J->T_sqrt=Allocate_mat2_d(N_axes,N_axes);
  J->Jacobian_ar=Allocate_mat2_f(N_axes,N_Cart);
  J->Jtilde_ar=NULL;  // Allocate_mat2_f(N_axes,N_Cart);
  J->T_sqrt_tr=NULL;
  J->T_sqrt_inv=NULL;
  J->T_sqrt_inv_tr=NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0xc(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x694a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0xc(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x694a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x69360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/kinetic_tnm.c
// Function: Empty_Jacobian
void Empty_Jacobian(struct Jacobian J)
{
  if(J.T!=NULL)Empty_matrix_d(J.T, J.N_axes);
  if(J.Jacobian_ar!=NULL)Empty_matrix_f(J.Jacobian_ar, J.N_axes);
  if(J.Jtilde_ar!=NULL)Empty_matrix_f(J.Jtilde_ar, J.N_axes);
  if(J.T_sqrt!=NULL)Empty_matrix_d(J.T_sqrt, J.N_axes);
  if(J.T_sqrt_inv!=NULL)Empty_matrix_f(J.T_sqrt_inv, J.N_axes);
  if(J.T_sqrt_tr!=NULL)Empty_matrix_f(J.T_sqrt_tr, J.N_kin); //modyves: this was never freed
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, 0x20(%rax)
je 0x31626
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl (%rax), %esi
callq 0x692a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x31640
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl (%rax), %esi
callq 0x69240
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x3165a
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl (%rax), %esi
callq 0x69240
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x31674
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movl (%rax), %esi
callq 0x692a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x3168e
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl (%rax), %esi
callq 0x69240
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x316a9
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movl 0x8(%rax), %esi
callq 0x69240
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/kinetic_tnm.c
// Function: Det_33
float Det_33(float **rot){
  float det=
    rot[0][0]*(rot[1][1]*rot[2][2]-rot[1][2]*rot[2][1])-
    rot[0][1]*(rot[1][0]*rot[2][2]-rot[1][2]*rot[2][0])+
    rot[0][2]*(rot[1][0]*rot[2][1]-rot[1][1]*rot[2][0]);
  return(det);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movss (%rax), %xmm1
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movss 0x4(%rax), %xmm2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movss 0x8(%rax), %xmm3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movss 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
mulss 0x4(%rax), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
mulss %xmm3, %xmm2
addss %xmm0, %xmm2
movq -0x8(%rbp), %rax
movq (%rax), %rax
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movss (%rax), %xmm3
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movss 0x8(%rax), %xmm5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movss 0x8(%rax), %xmm4
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
mulss (%rax), %xmm4
movd %xmm4, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm4
mulss %xmm5, %xmm3
addss %xmm4, %xmm3
mulss %xmm3, %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq -0x8(%rbp), %rax
movq (%rax), %rax
movss 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movss (%rax), %xmm2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movss 0x4(%rax), %xmm4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movss 0x4(%rax), %xmm3
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
mulss (%rax), %xmm3
movd %xmm3, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm3
mulss %xmm4, %xmm2
addss %xmm3, %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0xc(%rbp), %xmm0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/nma.c
// Function: Empty_Normal_modes
void Empty_Normal_modes(struct Normal_Mode NM)
{

  // Cleaning normal modes
  Empty_matrix_f(NM.Cart, NM.N);
  Empty_matrix_f(NM.Tors, NM.N);
  Empty_matrix_f(NM.MW_Tors, NM.N);
  free(NM.omega2);
  free(NM.omega);
  free(NM.select); //modyves: was never freed
  free(NM.sigma2);
  free(NM.Cart_coll);
  free(NM.Tors_coll);
  free(NM.MW_Tors_coll);
  free(NM.Tors_frac);
  free(NM.sort);
  free(NM.Anharmonicity);
  free(NM.Anharm_struct);
  free(NM.Max_factor);
  free(NM.Max_RMSD);
  free(NM.Max_dev); 
  free(NM.cart_fluct);
  free(NM.tors_fluct);
  free(NM.confchange2);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq 0x38(%rax), %rdi
movl (%rax), %esi
callq 0x69240
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movl (%rax), %esi
callq 0x69240
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movl (%rax), %esi
callq 0x69240
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/nma.c
// Function: Normal_modes_INM
void Normal_modes_INM(int N,           //degrees of freedom
		      struct interaction *Int_list, int N_int,
		      atom *atoms, int N_atoms,
		      double **Hessian, float **eigen_vector,
		      float *eigen_value, float *eigen_B,
		      float *B_CA, float *Cart_collectivity)
{
  int i;

  Compute_Hessian_INM(Hessian, N, Int_list, N_int, atoms);
  d_Diagonalize(N, Hessian, eigen_value, eigen_vector, -1);
  Compute_Bfact_INM(B_CA, eigen_B, N, eigen_value, eigen_vector);
  for(i=0; i<N; i++)
    Cart_collectivity[i]=Collectivity_norm2(eigen_vector[i], N)/N;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %r8
callq 0x320d0
movl -0x4(%rbp), %edi
movq -0x30(%rbp), %rsi
movq 0x18(%rbp), %rdx
movq 0x10(%rbp), %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x6ac30
movq 0x28(%rbp), %rdi
movq 0x20(%rbp), %rsi
movl -0x4(%rbp), %edx
movq 0x18(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0x32260
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x320bf
movq 0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0x4(%rbp), %esi
callq 0x15dc0
cvtsi2ssl -0x4(%rbp), %xmm1
divss %xmm1, %xmm0
movq 0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x32082
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/nma.c
// Function: Compute_Hessian_INM
void Compute_Hessian_INM (double **Hessian, int N,
			  struct interaction *Int_list, int N_int,
			  atom *atoms)
{
  int i, j, n;

  for(i=0; i<N; i++)for(j=0; j<N; j++)Hessian[i][j]=0;

  for(n=0; n<N_int; n++){
    float h=Int_list[n].sec_der;
    i=(atoms+Int_list[n].i1)->res;
    j=(atoms+Int_list[n].i2)->res;
    Hessian[i][j]=-h; Hessian[j][i]=-h;
    Hessian[i][i]+=h; Hessian[j][j]+=h;
  }
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x32134
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x32127
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x320fc
jmp 0x32129
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x320ed
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3225e
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
imulq $0xc8, %rcx, %rcx
addq %rcx, %rax
movsd 0x28(%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x34(%rbp), %rdx
imulq $0xc8, %rdx, %rdx
addq %rdx, %rcx
movslq (%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movl 0x64(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x34(%rbp), %rdx
imulq $0xc8, %rdx, %rdx
addq %rdx, %rcx
movslq 0x4(%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movl 0x64(%rax), %eax
movl %eax, -0x30(%rbp)
movss -0x38(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movss -0x38(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x8(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movss -0x38(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movss -0x38(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x8(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3213b
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/nma.c
// Function: Compute_Bfact_INM
int Compute_Bfact_INM(float *B_CA, float *eigen_B, int N,
		      float *eigen_value, float **eigen_vector)
{
  int ia, i; double B, B_ia;
  for(i=0; i<N; i++)eigen_B[i]=0;

  for(i=0; i<N; i++){
    B=0;
    for(ia=0; ia<N; ia++){
      if(eigen_value[ia] < E_MIN)continue;
      B_ia= eigen_vector[ia][i]*eigen_vector[ia][i]/eigen_value[ia];
      B += B_ia; eigen_B[ia]+=B_ia;
    }
    B_CA[i]=B;
  }
  return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x322a1
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x3227e
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x32392
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3236e
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
leaq 0x59dd1(%rip), %rax     # 0x8c0b4
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x322ee
jmp 0x32360
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
mulss (%rax,%rcx,4), %xmm0
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
divss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x40(%rbp), %xmm1
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x322c3
movsd -0x38(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rax
movslq -0x30(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x322a8
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)