LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/anharmonic_tnm.c
// Function: Print_interactions
void Print_interactions(struct interaction *Int_list, int N_int,
			struct interaction **Int_KB,
			int *aa_seq, char *AA_code, int NA, char *name)
{
  // Prepare for printing
  char nameout[100];
  sprintf(nameout,"%s.Inter_SB_KB.dat",name);
  FILE *file_out=fopen(nameout, "w");
  printf("Writing %s\n", nameout);
  int printed[4]; for(int i=0; i<4; i++)printed[i]=0;
  fprintf(file_out, "# NPAR= %d\n#r V(r)\n", NPAR);

  int n, nprint=0; struct interaction *Int=Int_list;
  for(n=0; n<N_int; n++){
    int a=aa_seq[Int->res1], b=aa_seq[Int->res1];
    struct interaction *I_KB=Int_KB[a]+b;
    int type;
    if(Int->r0>I_KB->r0){type=0;}else{type=2;}
    if(I_KB->E_min>0)type++;
    if(printed[type]==0){
      Print_potential(file_out, Int, a, b, "Structure-based", AA_code);
      Print_potential(file_out, I_KB, a,b, "Knowledge-based", AA_code);
      printed[type]=1; nprint++;
      if(nprint==4)break;
    }
    Int++;
  }
  fclose(file_out);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r8, 0x28(%rsp)
movq %rcx, %r15
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r12
movq 0xe0(%rsp), %rdx
leaq 0x39804(%rip), %rsi     # 0x5800f
movl $0x0, 0xc(%rsp)
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2270
leaq 0x389d7(%rip), %rsi     # 0x57200
movq %rbx, %rdi
callq 0x2220
movq %rax, %r13
leaq 0x33514(%rip), %rdi     # 0x51d4f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x20f0
xorpd %xmm0, %xmm0
movapd %xmm0, 0x30(%rsp)
movl 0x4a62b(%rip), %edx     # 0x68e80
leaq 0x397c6(%rip), %rsi     # 0x58022
movq %r13, 0x10(%rsp)
movq %r13, %rdi
xorl %eax, %eax
callq 0x21a0
testl %ebp, %ebp
jle 0x1e93d
movq %r14, %rsi
xorpd %xmm1, %xmm1
movq %r15, 0x20(%rsp)
movq %r14, 0x18(%rsp)
movslq 0x8(%r12), %rax
movslq (%r15,%rax,4), %rbx
movq (%rsi,%rbx,8), %r14
imulq $0xc8, %rbx, %rax
movsd 0x20(%r12), %xmm0
xorl %ecx, %ecx
ucomisd 0x20(%r14,%rax), %xmm0
setbe %cl
movsd 0xb8(%r14,%rax), %xmm0
xorl %edx, %edx
ucomisd %xmm1, %xmm0
seta %dl
leaq (%rdx,%rcx,2), %r13
cmpl $0x0, 0x30(%rsp,%r13,4)
jne 0x1e92e
addq %rax, %r14
movq 0x10(%rsp), %rdi
movq %r12, %rsi
movl %ebx, %edx
movl %ebx, %ecx
leaq 0x39756(%rip), %r8      # 0x58036
movq 0x28(%rsp), %r15
movq %r15, %r9
callq 0x1e959
movq 0x10(%rsp), %rdi
movq %r14, %rsi
movl %ebx, %edx
movl %ebx, %ecx
leaq 0x39746(%rip), %r8      # 0x58046
movq %r15, %r9
movq 0x20(%rsp), %r15
callq 0x1e959
xorpd %xmm1, %xmm1
movq 0x18(%rsp), %rsi
movl $0x1, 0x30(%rsp,%r13,4)
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
cmpl $0x4, %eax
je 0x1e93d
addq $0xc8, %r12
decl %ebp
jne 0x1e884
movq 0x10(%rsp), %rdi
callq 0x20c0
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %r8, %r10
movq %rsi, %r14
movq %rdi, %rbx
movslq %edx, %rax
movsbl (%r9,%rax), %eax
movslq %ecx, %rcx
movsbl (%r9,%rcx), %r8d
movsd 0xb8(%rsi), %xmm1
movsd 0x20(%rsi), %xmm0
movsd 0x28(%rsi), %xmm2
leaq 0x396d1(%rip), %rsi     # 0x58066
movq %r10, %rdx
movl %eax, %ecx
movb $0x3, %al
callq 0x21a0
movsd 0x48(%r14), %xmm0
movsd 0x40(%r14), %xmm1
movsd 0x30(%r14), %xmm3
movsd 0x38(%r14), %xmm2
leaq 0x396db(%rip), %rsi     # 0x5809b
movq %rbx, %rdi
movb $0x4, %al
callq 0x21a0
xorps %xmm0, %xmm0
cvtss2sd 0x10(%r14), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x14(%r14), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x18(%r14), %xmm2
leaq 0x396d6(%rip), %rsi     # 0x580c2
movq %rbx, %rdi
movb $0x3, %al
callq 0x21a0
movss 0x388ce(%rip), %xmm0    # 0x572cc
movl $0x64, %ebp
leaq 0x396d6(%rip), %r15     # 0x580e0
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
movss 0xc(%rsp), %xmm0
callq 0x1c59a
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
movq %rbx, %rdi
movq %r15, %rsi
movsd 0x10(%rsp), %xmm0
movb $0x2, %al
callq 0x21a0
movss 0xc(%rsp), %xmm0
addss 0x38880(%rip), %xmm0    # 0x572d0
decl %ebp
jne 0x1ea0a
leaq 0x39690(%rip), %rdi     # 0x580eb
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2290
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x395c2(%rip), %rsi     # 0x58056
xorl %r12d, %r12d
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x2270
leaq 0x38750(%rip), %rsi     # 0x57200
movq %rbp, %rdi
callq 0x2220
movq %rax, %r13
leaq 0x3328d(%rip), %rdi     # 0x51d4f
movq %rbp, %rsi
xorl %eax, %eax
callq 0x20f0
movl 0x4a3ae(%rip), %edx     # 0x68e80
leaq 0x39549(%rip), %rsi     # 0x58022
movq %r13, %rdi
xorl %eax, %eax
callq 0x21a0
movl %ebx, 0xc(%rsp)
testl %ebx, %ebx
jle 0x1eb22
movl 0xc(%rsp), %ebx
leaq 0x39550(%rip), %rbp     # 0x58046
movslq %r12d, %r12
movq (%r15,%r12,8), %rsi
movq %r13, %rdi
movl %r12d, %edx
xorl %ecx, %ecx
movq %rbp, %r8
movq %r14, %r9
callq 0x1e959
incq %r12
cmpq %rbx, %r12
jl 0x1eaf9
incl %r12d
cmpl 0xc(%rsp), %r12d
jl 0x1eaf6
movq %r13, %rdi
callq 0x20c0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/contacts.c
// Function: Write_contact_list
void Write_contact_list(short **cont_i, short **cont_j,
			struct interaction *Int_list, int *N_int)
{
  int k, nc=0, res1=-1, res2=-1;
  for(k=0; k<*N_int; k++){
    if((Int_list[k].res1!=res1)||(Int_list[k].res2!=res2)){
      res1=Int_list[k].res1; res2=Int_list[k].res2; nc++;
    } 
  }

  *cont_i=malloc(nc*sizeof(int));
  *cont_j=malloc(nc*sizeof(int));
  nc=0; res1=-1; res2=-1;
  for(k=0; k<*N_int; k++){
    if((Int_list[k].res1!=res1)||(Int_list[k].res2!=res2)){
      res1=Int_list[k].res1; res2=Int_list[k].res2;
      (*cont_i)[nc]=res1;
      (*cont_j)[nc]=res2;
      nc++;
    } 
  }
  *N_int=nc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq %rcx, (%rsp)
movslq (%rcx), %rbx
xorl %ebp, %ebp
testq %rbx, %rbx
jle 0x1f2f7
imulq $0xc8, %rbx, %rax
xorl %ecx, %ecx
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
movl 0x8(%r14,%rcx), %r8d
movl 0xc(%r14,%rcx), %r9d
movl %r8d, %r10d
xorl %esi, %r10d
xorl %r9d, %edi
xorl %r11d, %r11d
orl %r10d, %edi
setne %r11b
cmovnel %r8d, %esi
addl %r11d, %edx
addq $0xc8, %rcx
movl %r9d, %edi
cmpq %rcx, %rax
jne 0x1f2bb
movl %edx, %r13d
shlq $0x2, %r13
jmp 0x1f2fa
xorl %r13d, %r13d
movq %r13, %rdi
callq 0x21e0
movq %rax, (%r15)
movq %r13, %rdi
callq 0x21e0
movq %rax, (%r12)
testl %ebx, %ebx
jle 0x1f369
imulq $0xc8, %rbx, %rcx
xorl %edx, %edx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %ebp, %ebp
movl 0x8(%r14,%rdx), %r8d
movl 0xc(%r14,%rdx), %r9d
movl %r8d, %r10d
xorl %edi, %r10d
movl %r9d, %r11d
xorl %esi, %r11d
orl %r10d, %r11d
je 0x1f35d
movq (%r15), %rsi
movslq %ebp, %rbp
movw %r8w, (%rsi,%rbp,2)
movw %r9w, (%rax,%rbp,2)
incl %ebp
movl %r9d, %esi
movl %r8d, %edi
addq $0xc8, %rdx
cmpq %rdx, %rcx
jne 0x1f32a
movq (%rsp), %rax
movl %ebp, (%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/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:
testl %esi, %esi
jle 0x1f484
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl %esi, %eax
imulq $0xc8, %rax, %rax
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
xorl %r15d, %r15d
movq %rdx, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movslq 0x8(%r14,%r15), %r12
movq %r12, %rax
shlq $0x5, %rax
movsbl 0x13(%rdx,%rax), %r13d
movl %r13d, %edi
callq 0x1f488
testl %eax, %eax
js 0x1f42f
movl %eax, %ebp
movslq 0xc(%r14,%r15), %r12
movq %r12, %rax
shlq $0x5, %rax
movq 0x8(%rsp), %rcx
movsbl 0x13(%rcx,%rax), %r13d
movl %r13d, %edi
callq 0x1f488
testl %eax, %eax
js 0x1f42f
leaq 0x49d76(%rip), %rcx     # 0x69180
movq (%rcx), %rcx
movl %ebp, %edx
movq (%rcx,%rdx,8), %rcx
movl %eax, %eax
xorps %xmm0, %xmm0
cvtss2sd (%rcx,%rax,4), %xmm0
movsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rsp)
jmp 0x1f434
cmpl %r12d, %ebx
jne 0x1f439
movl %ebx, %r12d
jmp 0x1f44d
leaq 0x38fe9(%rip), %rdi     # 0x58429
movl %r13d, %esi
movl %r12d, %edx
xorl %eax, %eax
callq 0x20f0
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %r14
addq $0xc8, %r15
movl %r12d, %ebx
cmpq %r15, 0x20(%rsp)
jne 0x1f3c0
xorps %xmm0, %xmm0
cvtsd2ss 0x18(%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/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:
leaq 0x49ce9(%rip), %rax     # 0x69178
movq (%rax), %rcx
xorl %eax, %eax
cmpb %dil, (%rcx,%rax)
je 0x1f4d4
incq %rax
cmpq $0x14, %rax
jne 0x1f494
movl $0x14, %eax
cmpb $0x2d, %dil
je 0x1f4d4
leal -0x20(%rdi), %eax
cmpb $0x61, %dil
movzbl %dil, %esi
movzbl %al, %edx
cmovll %esi, %edx
xorl %eax, %eax
cmpb (%rcx,%rax), %dl
je 0x1f4d4
incq %rax
cmpq $0x14, %rax
jne 0x1f4c1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/screened_interactions.c
// Function: Rank
void Rank(struct ranked *rank,  int i, float x, int Rmax)
{
  // Rank in decreasing order (lowest = 0)
  if((rank->num >= Rmax)&&(x >= rank->last->x))return;

  struct store *store;
  if(rank->num==0){
    store=rank->store;
    store->i=i; store->x=x;
    store->next=NULL;
    rank->num=1;
    rank->first=store;
    rank->last= store;
    return;
  }

  // Find position in the list
  struct store *k=rank->first, *k1=k->next;
  while(k1!=NULL){
    if(k1->x >= x)break;
    k=k1; k1=k1->next;
  }

  if(rank->num < Rmax){
    store=rank->store+rank->num;
    (rank->num)++;
    if(x > rank->last->x)rank->last=store;
  }else if(k1==NULL){
    store=k; rank->last=k;
  }else{
    store=rank->last;
    if(k1==rank->last){
      k1=NULL;
    }else{
      struct store *k2=k1, *k3=k1->next->next;
      while(k3!=NULL){k2=k2->next; k3=k3->next;}
      rank->last=k2; k2->next=NULL;
    }
  }
  if(x < rank->first->x){
    rank->first=store; k1=k;
  }else{
    k->next=store;
  }
  store->i=i; store->x=x; store->next=k1;

  /*printf("%d: ", rank->num);
  struct store *k2=rank->first; float y=0;
  while(k2!=NULL){
    printf("%.2f ", k2->x); 
    if(k2->x < y){
      printf("\nERROR bad ordered list\n");
      exit(8);
    }
    y=k2->x; k2=k2->next;
  }
  printf("\n");*/

  return;
}

// Assembly:
pushq %rbx
movslq (%rdi), %r11
cmpq $0x7d0, %r11            # imm = 0x7D0
jl 0x1fbfb
movq 0x18(%rdi), %rax
ucomiss 0x4(%rax), %xmm0
jb 0x1fc04
jmp 0x1fced
testl %r11d, %r11d
je 0x1fc9c
leaq 0x10(%rdi), %rax
movq 0x10(%rdi), %r8
movq %r8, %rcx
movq %rcx, %rdx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x1fc6d
movss 0x4(%rcx), %xmm1
ucomiss %xmm0, %xmm1
jb 0x1fc0f
leaq 0x8(%rdx), %r9
cmpl $0x7cf, %r11d           # imm = 0x7CF
jle 0x1fc7a
movq 0x18(%rdi), %r10
cmpq %r10, %rcx
je 0x1fcca
movq 0x8(%rcx), %r11
movq 0x8(%r11), %r11
movq %rcx, %rbx
testq %r11, %r11
je 0x1fc5f
movq %rcx, %rbx
movq 0x8(%rbx), %rbx
movq 0x8(%r11), %r11
testq %r11, %r11
jne 0x1fc52
movq %rbx, 0x18(%rdi)
movq $0x0, 0x8(%rbx)
jmp 0x1fccc
leaq 0x8(%rdx), %r9
cmpl $0x7d0, %r11d           # imm = 0x7D0
jge 0x1fcbf
movq %r11, %r10
shlq $0x4, %r10
incl %r11d
addq 0x8(%rdi), %r10
movl %r11d, (%rdi)
movq 0x18(%rdi), %r11
ucomiss 0x4(%r11), %xmm0
jbe 0x1fccc
movq %r10, 0x18(%rdi)
jmp 0x1fccc
movq 0x8(%rdi), %rax
movl %esi, (%rax)
movss %xmm0, 0x4(%rax)
movq $0x0, 0x8(%rax)
movl $0x1, (%rdi)
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
jmp 0x1fced
movq %rdx, 0x18(%rdi)
xorl %ecx, %ecx
movq %rdx, %r10
jmp 0x1fccc
xorl %ecx, %ecx
movss 0x4(%r8), %xmm1
ucomiss %xmm0, %xmm1
cmovaq %rax, %r9
cmovaq %rdx, %rcx
movq %r10, (%r9)
movl %esi, (%r10)
movss %xmm0, 0x4(%r10)
movq %rcx, 0x8(%r10)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movss %xmm1, 0x14(%rsp)
xorl %ebx, %ebx
testq %rdx, %rdx
je 0x201be
movq %r9, %r14
movq %r8, %r12
movq %rdx, %r13
movaps %xmm0, %xmm4
movq %rsi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movl 0x64(%rcx), %ebp
movl 0x64(%r8), %r15d
movss %xmm2, 0x10(%rsp)
movss %xmm0, 0xc(%rsp)
movss 0x4(%r13), %xmm0
ucomiss %xmm2, %xmm0
ja 0x201be
movslq (%r13), %rax
imulq $0x70, %rax, %rax
addq %r14, %rax
cmpq %r12, %rax
je 0x20194
movsd (%r12), %xmm1
movsd 0x8(%r12), %xmm3
subsd (%rax), %xmm1
subsd 0x8(%rax), %xmm3
mulsd %xmm1, %xmm1
mulsd %xmm3, %xmm3
addsd %xmm1, %xmm3
movsd 0x10(%r12), %xmm1
subsd 0x10(%rax), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm3, %xmm1
cvtsd2ss %xmm1, %xmm1
ucomiss %xmm2, %xmm1
jae 0x20194
movaps %xmm1, %xmm3
maxss %xmm0, %xmm3
ucomiss %xmm3, %xmm4
jbe 0x20194
movss %xmm3, 0x8(%rsp)
movl 0x64(%rax), %edi
movl %ebp, %esi
movl %r15d, %edx
callq 0x18966
testl %eax, %eax
je 0x201a3
movss 0x14(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
ucomiss %xmm1, %xmm0
movss 0x10(%rsp), %xmm2
movss 0xc(%rsp), %xmm4
ja 0x201b0
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0x200f6
jmp 0x201be
movq 0x20(%rsp), %rax
movss 0x8(%rsp), %xmm1
jmp 0x201b5
movq 0x18(%rsp), %rax
movss %xmm1, (%rax)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/screened_interactions.c
// Function: Shadow_cosine
int Shadow_cosine(float *c_nb, float *c_bo, float S2_NB, float S2_BO,
		   struct store *store1, float d2_ij,
		   atom *atom_i, atom *atom_j, atom *atoms)
{
  int resi=atom_i->res, resj=atom_j->res;
  float cos2_a, d2_jk;
  while(store1 != NULL){
    if(store1->x > d2_ij)break; // store1->x= d2_ik
    atom *atom_k=atoms+store1->i;
    if(atom_k!=atom_j){
      d2_jk=Dist2(atom_j->r, atom_k->r);
      if(d2_jk >= d2_ij)goto next;
      if(d2_jk > store1->x){
	cos2_a=Scalar(atom_j->r, atom_i->r, atom_k->r);
	cos2_a=(cos2_a*cos2_a)/(d2_ij*d2_jk); 
      }else{
	cos2_a=Scalar(atom_i->r, atom_j->r, atom_k->r);
	cos2_a=(cos2_a*cos2_a)/(d2_ij*store1->x);
      }
      if(cos2_a > S2_NB){
	int bond=Bond(atom_k->res, resi, store1->x, resj, d2_jk);
	if(bond){
	  if(cos2_a > S2_BO){*c_bo=cos2_a; return(1);}
	}else{
	  if(cos2_a > S2_NB){*c_nb=cos2_a; return(1);}
	}
      }
    }
  next:
    store1=store1->next;
  }
  return(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movss %xmm1, 0x14(%rsp)
testq %rdx, %rdx
je 0x20332
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %rbp
movaps %xmm0, %xmm6
movq %rsi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movl 0x64(%rcx), %r14d
movl 0x64(%r8), %r12d
movss %xmm2, 0x10(%rsp)
movss %xmm0, 0xc(%rsp)
movss 0x4(%rbp), %xmm0
ucomiss %xmm2, %xmm0
ja 0x20332
movslq (%rbp), %rax
imulq $0x70, %rax, %rax
addq %rbx, %rax
cmpq %r15, %rax
je 0x20325
movsd (%r15), %xmm1
movsd 0x8(%r15), %xmm3
subsd (%rax), %xmm1
subsd 0x8(%rax), %xmm3
mulsd %xmm1, %xmm1
mulsd %xmm3, %xmm3
addsd %xmm1, %xmm3
movsd 0x10(%r15), %xmm1
subsd 0x10(%rax), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm3, %xmm1
cvtsd2ss %xmm1, %xmm1
ucomiss %xmm2, %xmm1
jae 0x20325
xorpd %xmm5, %xmm5
xorl %ecx, %ecx
ucomiss %xmm0, %xmm1
jbe 0x202b2
movsd (%r15,%rcx,8), %xmm3
movapd %xmm3, %xmm4
subsd (%r13,%rcx,8), %xmm4
subsd (%rax,%rcx,8), %xmm3
mulsd %xmm4, %xmm3
addsd %xmm3, %xmm5
incq %rcx
cmpq $0x3, %rcx
jne 0x20286
movaps %xmm1, %xmm3
jmp 0x202dc
movsd (%r13,%rcx,8), %xmm3
movapd %xmm3, %xmm4
subsd (%r15,%rcx,8), %xmm4
subsd (%rax,%rcx,8), %xmm3
mulsd %xmm4, %xmm3
addsd %xmm3, %xmm5
incq %rcx
cmpq $0x3, %rcx
jne 0x202b2
movaps %xmm0, %xmm3
xorps %xmm4, %xmm4
cvtsd2ss %xmm5, %xmm4
mulss %xmm4, %xmm4
mulss %xmm2, %xmm3
divss %xmm3, %xmm4
ucomiss %xmm6, %xmm4
jbe 0x20325
movss %xmm4, 0x8(%rsp)
movl 0x64(%rax), %edi
movl %r14d, %esi
movl %r12d, %edx
callq 0x18966
testl %eax, %eax
je 0x20343
movss 0x8(%rsp), %xmm0
ucomiss 0x14(%rsp), %xmm0
movss 0x10(%rsp), %xmm2
movss 0xc(%rsp), %xmm6
ja 0x20350
movq 0x8(%rbp), %rbp
testq %rbp, %rbp
jne 0x20219
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%rsp), %rax
movss 0x8(%rsp), %xmm0
jmp 0x20355
movq 0x18(%rsp), %rax
movss %xmm0, (%rax)
movl $0x1, %eax
jmp 0x20334
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/screened_interactions.c
// Function: Axis_distance
int Axis_distance(float *d2_nb, float *d2_bo, float S2_NB, float S2_BO,
		  struct store *store1, float d2_ij,
		  atom *atom_i, atom *atom_j, atom *atoms)
{
  int resi=atom_i->res, resj=atom_j->res;
  float d2, d2_jk, d2_c;
  while(store1 != NULL){
    if(store1->x > d2_ij)break;
    atom *atom_k=atoms+store1->i;
    if(atom_k!=atom_j){
      d2_jk=Dist2(atom_j->r, atom_k->r);
      if(d2_jk >= d2_ij)goto next1;
      if(d2_jk > store1->x){
	d2_c=Scalar(atom_j->r, atom_i->r, atom_k->r);
	d2=d2_jk-d2_c*d2_c/d2_ij; 
      }else{
	d2_c=Scalar(atom_i->r, atom_j->r, atom_k->r);
	d2=store1->x-d2_c*d2_c/d2_ij;
      }
      if(d2 < S2_NB){
	int bond=Bond(atom_k->res, resi, store1->x, resj, d2_jk);
	if(bond){
	  if(d2 < S2_BO){*d2_bo=d2; return(1);}
	}else{
	  if(d2 < S2_NB){*d2_nb=d2; return(1);}
	}
      }
    }
  next1:
    store1=store1->next;
  }
  return(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movss %xmm1, 0x14(%rsp)
testq %rdx, %rdx
je 0x204c7
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %rbp
movaps %xmm0, %xmm6
movq %rsi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movl 0x64(%rcx), %r14d
movl 0x64(%r8), %r12d
movss %xmm2, 0x10(%rsp)
movss %xmm0, 0xc(%rsp)
movss 0x4(%rbp), %xmm0
ucomiss %xmm2, %xmm0
ja 0x204c7
movslq (%rbp), %rax
imulq $0x70, %rax, %rax
addq %rbx, %rax
cmpq %r15, %rax
je 0x204ba
movsd (%r15), %xmm1
movsd 0x8(%r15), %xmm3
subsd (%rax), %xmm1
subsd 0x8(%rax), %xmm3
mulsd %xmm1, %xmm1
mulsd %xmm3, %xmm3
addsd %xmm1, %xmm3
movsd 0x10(%r15), %xmm1
subsd 0x10(%rax), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm3, %xmm1
cvtsd2ss %xmm1, %xmm1
ucomiss %xmm2, %xmm1
jae 0x204ba
xorpd %xmm5, %xmm5
xorl %ecx, %ecx
ucomiss %xmm0, %xmm1
jbe 0x20443
movsd (%r15,%rcx,8), %xmm3
movapd %xmm3, %xmm4
subsd (%r13,%rcx,8), %xmm4
subsd (%rax,%rcx,8), %xmm3
mulsd %xmm4, %xmm3
addsd %xmm3, %xmm5
incq %rcx
cmpq $0x3, %rcx
jne 0x20417
movaps %xmm1, %xmm4
jmp 0x2046d
movsd (%r13,%rcx,8), %xmm3
movapd %xmm3, %xmm4
subsd (%r15,%rcx,8), %xmm4
subsd (%rax,%rcx,8), %xmm3
mulsd %xmm4, %xmm3
addsd %xmm3, %xmm5
incq %rcx
cmpq $0x3, %rcx
jne 0x20443
movaps %xmm0, %xmm4
xorps %xmm3, %xmm3
cvtsd2ss %xmm5, %xmm3
mulss %xmm3, %xmm3
divss %xmm2, %xmm3
subss %xmm3, %xmm4
ucomiss %xmm4, %xmm6
jbe 0x204ba
movss %xmm4, 0x8(%rsp)
movl 0x64(%rax), %edi
movl %r14d, %esi
movl %r12d, %edx
callq 0x18966
testl %eax, %eax
je 0x204d8
movss 0x14(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
ucomiss %xmm1, %xmm0
movss 0x10(%rsp), %xmm2
movss 0xc(%rsp), %xmm6
ja 0x204e5
movq 0x8(%rbp), %rbp
testq %rbp, %rbp
jne 0x203aa
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%rsp), %rax
movss 0x8(%rsp), %xmm1
jmp 0x204ea
movq 0x18(%rsp), %rax
movss %xmm1, (%rax)
movl $0x1, %eax
jmp 0x204c9
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
testq %rcx, %rcx
je 0x208ed
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r12
movl 0x64(%r8), %r13d
movslq (%r15), %rax
imulq $0x70, %rax, %rax
addq %rbx, %rax
cmpq %r14, %rax
je 0x208e0
movss 0x4(%r15), %xmm0
movss %xmm0, 0x14(%rsp)
movsd (%r14), %xmm2
movsd 0x8(%r14), %xmm1
subsd (%rax), %xmm2
mulsd %xmm2, %xmm2
subsd 0x8(%rax), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
movsd 0x10(%r14), %xmm2
subsd 0x10(%rax), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtsd2ss %xmm2, %xmm1
movss %xmm1, 0x10(%rsp)
movl 0x64(%rax), %edi
movl %ebp, %esi
movl %r13d, %edx
callq 0x18966
movss 0x10(%rsp), %xmm2
movss 0x14(%rsp), %xmm1
ucomiss %xmm1, %xmm2
jbe 0x20899
testl %eax, %eax
je 0x208b0
movss (%r12), %xmm0
ucomiss %xmm2, %xmm0
jbe 0x208e0
movss %xmm2, (%r12)
jmp 0x208e0
testl %eax, %eax
je 0x208c9
movss (%r12), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x208e0
movss %xmm1, (%r12)
jmp 0x208e0
movq 0x8(%rsp), %rax
movss (%rax), %xmm0
ucomiss %xmm2, %xmm0
jbe 0x208e0
movq 0x8(%rsp), %rax
movss %xmm2, (%rax)
jmp 0x208e0
movq 0x8(%rsp), %rax
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x208e0
movq 0x8(%rsp), %rax
movss %xmm1, (%rax)
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x20805
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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:
xorpd %xmm0, %xmm0
movapd %xmm0, -0x18(%rsp)
movq $0x0, -0x8(%rsp)
movslq 0x8(%rsp), %rax
testq %rax, %rax
jle 0x20e8e
leaq 0x8(%rsp), %rdx
movq 0x10(%rdx), %rcx
movq 0x28(%rdx), %rdx
xorpd %xmm0, %xmm0
xorl %r8d, %r8d
movslq (%rdx,%r8,4), %r9
imulq $0x70, %r9, %r9
addq %rdi, %r9
xorps %xmm1, %xmm1
cvtss2sd (%rcx,%r8,4), %xmm1
xorl %r10d, %r10d
movsd (%r9,%r10,8), %xmm2
mulsd %xmm1, %xmm2
addsd -0x18(%rsp,%r10,8), %xmm2
movsd %xmm2, -0x18(%rsp,%r10,8)
incq %r10
cmpq $0x3, %r10
jne 0x20e5f
addsd %xmm1, %xmm0
incq %r8
cmpq %rax, %r8
jne 0x20e48
jmp 0x20e92
xorpd %xmm0, %xmm0
xorl %eax, %eax
movsd -0x18(%rsp,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, -0x18(%rsp,%rax,8)
incq %rax
cmpq $0x3, %rax
jne 0x20e94
testl %esi, %esi
jle 0x20edc
movl %esi, %eax
xorl %ecx, %ecx
xorl %edx, %edx
movsd (%rdi,%rdx,8), %xmm0
subsd -0x18(%rsp,%rdx,8), %xmm0
movsd %xmm0, (%rdi,%rdx,8)
incq %rdx
cmpq $0x3, %rdx
jne 0x20eb7
incq %rcx
addq $0x70, %rdi
cmpq %rax, %rcx
jne 0x20eb5
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/kinetic_tnm.c
// Function: Internal_Jacobian
int Internal_Jacobian(// Output:
		      struct Jacobian J,
		      // Input:
		      struct Reference Ref,
		      atom *atoms, int N_atoms,
		      struct axe *axes, int N_axes)
{
  // Jacobian: derivatives with respect to torsions for all atoms
  // (only internal degrees of freedom)
  int i, j, k;
  for(k=0; k<N_axes; k++){
    float *Jacobian_a=J.Jacobian_ar[k]; int jj=0;
    struct axe *axe=axes+k;
    for(i=0; i<Ref.N_ref; i++){
      double *rot,  *shift;
      if((i>=axe->first_kin)&&(i<=axe->last_kin)){
	rot=axe->local_rot;  shift=axe->local_shift;
      }else{
	rot=axe->global_rot; shift=axe->global_shift;
      }
      double *ri=atoms[Ref.atom_num[i]].r;
      double r[3]; for(j=0; j<3; j++)r[j]=ri[j];
      double dk[3]; Vector_product_d(dk, rot, r);
      for(j=0; j<3; j++){
	Jacobian_a[jj]=(dk[j]+shift[j]); jj++;
      }
    }
  }

  return(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, 0x10(%rsp)
testl %ecx, %ecx
jle 0x21b27
movq %rdi, %r14
leaq 0x108(%rsp), %rax
leaq 0xc0(%rsp), %rdx
movq 0x10(%rdx), %rdx
movq %rdx, 0x20(%rsp)
movl (%rax), %edx
movq %rdx, 0x18(%rsp)
movq 0x28(%rax), %rax
movq %rax, 0x40(%rsp)
movl %ecx, %eax
movq %rax, 0x28(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rbx
cmpl $0x0, 0x18(%rsp)
jle 0x21b08
movq 0x8(%rsp), %rcx
imulq $0x158, %rcx, %r15      # imm = 0x158
addq 0x10(%rsp), %r15
movq 0x20(%rsp), %rax
movq (%rax,%rcx,8), %rax
movq %rax, 0x48(%rsp)
leaq 0xd8(%r15), %rax
movq %rax, 0x30(%rsp)
leaq 0xa8(%r15), %rax
movq %rax, 0x38(%rsp)
xorl %ebp, %ebp
xorl %r13d, %r13d
movslq 0x18(%r15), %rax
cmpq %rax, %rbp
jl 0x21a8d
movslq 0x1c(%r15), %rax
movl $0xc0, %r12d
movq 0x30(%rsp), %rsi
cmpq %rax, %rbp
jle 0x21a98
movl $0x90, %r12d
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rax
movslq (%rax,%rbp,4), %rax
imulq $0x70, %rax, %rax
movq 0x10(%r14,%rax), %rcx
movq %rcx, 0x60(%rsp)
movups (%r14,%rax), %xmm0
movaps %xmm0, 0x50(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x103bb
movslq %r13d, %r13
movq 0x48(%rsp), %rax
leaq (%rax,%r13,4), %rcx
addq %rbx, %r12
xorl %eax, %eax
movsd 0x70(%rsp,%rax,8), %xmm0
addsd (%r12,%rax,8), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rcx,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x21ad9
incq %rbp
addq %rax, %r13
cmpq 0x18(%rsp), %rbp
jne 0x21a70
movq 0x8(%rsp), %rcx
incq %rcx
addq $0x158, %rbx            # imm = 0x158
movq %rcx, 0x8(%rsp)
cmpq 0x28(%rsp), %rcx
jne 0x21a29
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r14
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %r15
leaq 0x36d0f(%rip), %rdi     # 0x5886b
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x20f0
testl %r13d, %r13d
jle 0x21bbd
leaq 0x70(%rsp), %rbp
movl %r13d, %eax
movq %rax, 0x30(%rsp)
xorl %r13d, %r13d
movq (%r15,%r13,8), %rdi
movups (%rbp), %xmm0
movups 0x10(%rbp), %xmm1
movups 0x20(%rbp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r12, %rsi
movl %r13d, %ecx
movq %r14, %r8
callq 0x22edb
addl %eax, %ebx
incq %r13
addq $0x158, %r14            # imm = 0x158
cmpq %r13, 0x30(%rsp)
jne 0x21b7a
testl %ebx, %ebx
jne 0x21bcc
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x36cc6(%rip), %rdi     # 0x58899
movl %ebx, %esi
xorl %eax, %eax
callq 0x20f0
movl $0x8, %edi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
movl %edx, %edi
callq 0x4971a
testl %ebp, %ebp
jle 0x22303
movl %ebp, %ecx
movl %ebx, %edx
xorl %esi, %esi
testl %ebx, %ebx
jle 0x222fb
movq (%rax,%rsi,8), %rdi
xorl %r8d, %r8d
movq (%r14,%r8,8), %r9
movss (%r9,%rsi,4), %xmm0
movss %xmm0, (%rdi,%r8,4)
incq %r8
cmpq %r8, %rdx
jne 0x222e3
incq %rsi
cmpq %rcx, %rsi
jne 0x222d8
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
movl %edx, %edi
callq 0x4971a
testl %ebp, %ebp
jle 0x22352
movl %ebp, %ecx
movl %ebx, %edx
xorl %esi, %esi
testl %ebx, %ebx
jle 0x2234a
movq (%rax,%rsi,8), %rdi
xorl %r8d, %r8d
movq (%r14,%r8,8), %r9
xorps %xmm0, %xmm0
cvtsd2ss (%r9,%rsi,8), %xmm0
movss %xmm0, (%rdi,%r8,4)
incq %r8
cmpq %r8, %rdx
jne 0x2232f
incq %rsi
cmpq %rcx, %rsi
jne 0x22324
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
movq (%rsi,%rax,8), %rcx
movq (%rdi,%rax,8), %r8
movq %rax, %r9
movsd (%rcx,%r9,8), %xmm1
movsd (%rdx,%rax,8), %xmm2
mulsd (%rdx,%r9,8), %xmm2
divsd %xmm0, %xmm2
subsd %xmm2, %xmm1
movsd %xmm1, (%r8,%r9,8)
incq %r9
cmpq $0x3, %r9
jne 0x226b9
incq %rax
cmpq $0x3, %rax
jne 0x226ae
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movsd (%rax), %xmm0
addsd 0x8(%rcx), %xmm0
movq 0x10(%rdi), %rax
addsd 0x10(%rax), %xmm0
xorl %eax, %eax
movapd 0x2e983(%rip), %xmm1    # 0x51090
movq (%rdi,%rax,8), %rcx
movapd %xmm0, %xmm2
subsd (%rcx,%rax,8), %xmm2
movsd %xmm2, (%rcx,%rax,8)
cmpq $0x1, %rax
ja 0x2274b
movq %rax, %rdx
movsd 0x8(%rcx,%rdx,8), %xmm2
xorpd %xmm1, %xmm2
movlpd %xmm2, 0x8(%rcx,%rdx,8)
movq 0x8(%rdi,%rdx,8), %rsi
movlpd %xmm2, (%rsi,%rax,8)
incq %rdx
cmpq $0x2, %rdx
jne 0x22728
incq %rax
cmpq $0x3, %rax
jne 0x2270d
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x18(%rsi), %edx
movl 0x18(%rdi), %ecx
cmpl %ecx, %edx
jge 0x2276f
movl 0x1c(%r14), %esi
jmp 0x2277d
movl 0x1c(%r14), %esi
movl $0x1, %eax
cmpl %esi, 0x1c(%rbx)
jle 0x22788
xorl %eax, %eax
cmpl %edx, %esi
jl 0x22788
cmpl %ecx, 0x1c(%rbx)
jge 0x22790
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x362d4(%rip), %rdi     # 0x58a6b
callq 0x2090
movsbl (%r14), %esi
movl 0x18(%r14), %edx
movl 0x1c(%r14), %ecx
leaq 0x361a5(%rip), %rdi     # 0x58954
xorl %eax, %eax
callq 0x20f0
movsbl (%rbx), %esi
movl 0x18(%rbx), %edx
movl 0x1c(%rbx), %ecx
leaq 0x361b5(%rip), %rdi     # 0x5897b
xorl %eax, %eax
callq 0x20f0
movl $0x8, %edi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/kinetic_tnm.c
// Function: Kinetic_energy_Jac
int Kinetic_energy_Jac(struct Jacobian J, struct Reference Ref, int N_axes)
{
  // Compute kinetic energy tensor T=T_sqrt T_sqrt^T (only internal dof)
  // Lower tridiagonal matrix T[i][j] with j<=i
  int k, l, j, diff=0;
  for(l=0; l<N_axes; l++){
    float *Jl=J.Jacobian_ar[l];
    for(k=0; k<=l; k++){
      float *Jk=J.Jacobian_ar[k]; double sum=0;
      for(j=0; j<Ref.N_Cart; j++)sum+=Jk[j]*Jl[j]*Ref.mass_coord[j];
      if(fabs(sum-J.T[l][k])>0.0001*fabs(J.T[l][l])){
	printf("%d %d %.6f %.6f\n", l, k, sum, J.T[l][k]);
	diff++;
      }
      J.T[l][k]=sum;
      if(l!=k)J.T[k][l]=J.T[l][k];
    }
  }
  if(diff){
    printf("ERROR, %d components of the kinetic energy are different\n",
	   diff); exit(8);
  }else{
    printf("All components of the kinetic energy are equal\n"); exit(8);
  }
  if(DEBUG){
    int ini=N_axes-20;
    printf("###  Kinetic energy matrix (calc):\n");
    for(k=ini; k<ini+20; k++){
      for(l=ini; l<=k; l++)printf(" %.4g", J.T[k][l]);
      printf("\n");
    }
  }
  return(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testl %edi, %edi
jle 0x22922
leaq 0xa8(%rsp), %rax
leaq 0x60(%rsp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x20(%rcx), %rbp
movl 0x4(%rax), %r15d
movq 0x18(%rax), %r13
movl %edi, %eax
movq %rax, 0x10(%rsp)
xorl %r14d, %r14d
movl $0x1, %edi
movapd 0x34aca(%rip), %xmm3    # 0x572f0
movsd 0x3339a(%rip), %xmm4    # 0x55bc8
xorl %esi, %esi
movq 0x8(%rsp), %rax
movq (%rax,%r14,8), %rbx
xorl %r12d, %r12d
movq %rdi, 0x18(%rsp)
testl %r15d, %r15d
jle 0x22878
movq 0x8(%rsp), %rax
movq (%rax,%r12,8), %rax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
movss (%rax,%rcx,4), %xmm1
mulss (%rbx,%rcx,4), %xmm1
mulss (%r13,%rcx,4), %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rcx
cmpq %rcx, %r15
jne 0x22855
jmp 0x2287c
xorpd %xmm0, %xmm0
movq (%rbp,%r14,8), %rax
movsd (%rax,%r12,8), %xmm1
movapd %xmm0, %xmm5
subsd %xmm1, %xmm5
andpd %xmm3, %xmm5
movsd (%rax,%r14,8), %xmm2
andpd %xmm3, %xmm2
mulsd %xmm4, %xmm2
ucomisd %xmm2, %xmm5
jbe 0x228eb
leaq 0x35dc5(%rip), %rdi     # 0x58673
movl %esi, 0x4(%rsp)
movl %r14d, %esi
movl %r12d, %edx
movb $0x2, %al
movsd %xmm0, 0x20(%rsp)
callq 0x20f0
movsd 0x20(%rsp), %xmm0
movsd 0x332f5(%rip), %xmm4    # 0x55bc8
movapd 0x34a15(%rip), %xmm3    # 0x572f0
movq 0x18(%rsp), %rdi
movl 0x4(%rsp), %esi
incl %esi
movq (%rbp,%r14,8), %rax
movsd %xmm0, (%rax,%r12,8)
cmpq %r12, %r14
je 0x22901
movq (%rbp,%r12,8), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r12
cmpq %rdi, %r12
jne 0x22841
incq %r14
incq %rdi
cmpq 0x10(%rsp), %r14
jne 0x22830
testl %esi, %esi
jne 0x22930
leaq 0x36159(%rip), %rdi     # 0x58a82
callq 0x2090
jmp 0x2293e
leaq 0x35d4d(%rip), %rdi     # 0x58684
xorl %eax, %eax
callq 0x20f0
movl $0x8, %edi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O3/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:
xorpd %xmm0, %xmm0
cmpl %r8d, %ecx
jg 0x229e9
pushq %r14
pushq %rbx
leaq 0x18(%rsp), %r9
movq 0x10(%r9), %rax
movq 0x28(%r9), %r9
movslq %ecx, %rcx
incl %r8d
xorpd %xmm0, %xmm0
movslq (%r9,%rcx,4), %r10
imulq $0x70, %r10, %r10
addq %rdx, %r10
xorps %xmm1, %xmm1
cvtss2sd (%rax,%rcx,4), %xmm1
xorl %r11d, %r11d
movsd (%r10,%r11,8), %xmm2
mulsd %xmm1, %xmm2
cvtsd2ss %xmm2, %xmm2
cvtss2sd %xmm2, %xmm2
movsd (%rdi,%r11,8), %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, (%rdi,%r11,8)
movq (%rsi,%r11,8), %rbx
movq %r11, %r14
movsd (%r10,%r14,8), %xmm3
mulsd %xmm2, %xmm3
addsd (%rbx,%r14,8), %xmm3
movsd %xmm3, (%rbx,%r14,8)
incq %r14
cmpq $0x3, %r14
jne 0x229ae
incq %r11
cmpq $0x3, %r11
jne 0x22985
addsd %xmm1, %xmm0
incq %rcx
cmpl %ecx, %r8d
jne 0x2296f
cvtsd2ss %xmm0, %xmm0
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/kinetic_tnm.c
// Function: Compute_Jtilde
int Compute_Jtilde(struct Jacobian *J)
{
  // Jtilde = J L^t(-1)
  // Jtilde_ia = sum_b J_ib L^t(-1)_ba =  sum_b J_ib L(-1)_ab
  // Jtilde_ai = L(-1)_ab sum_b J_bi => LJtilde = J
  int a, i, b;

  if(J->Jtilde_ar==NULL)
    J->Jtilde_ar=Allocate_mat2_f(J->N_axes, J->N_Cart);
  if(J->T_sqrt_inv!=NULL){
    // T_sqrt is not lower diagonal!
    for(a=0; a<J->N_kin; a++){
      for(i=0; i<J->N_Cart; i++){
	double sum=0;
	for(b=0; b<J->N_axes; b++)
	  sum+=J->T_sqrt_inv[a][b]*J->Jacobian_ar[b][i];
	J->Jtilde_ar[a][i]=sum;
      }
    }
  }else{
    // Exploit that T_sqrt is lower diagonal
    // T_sqrt Jtilde = J
    double *X=malloc(J->N_axes*sizeof(double));
    double *Y=malloc(J->N_axes*sizeof(double));
    for(i=0; i<J->N_Cart; i++){
      for(a=0; a<J->N_axes; a++)Y[a]=J->Jacobian_ar[a][i];
      Forward_substitution(X, J->T_sqrt, Y, J->N_axes);
      for(a=0; a<J->N_axes; a++)J->Jtilde_ar[a][i]=X[a];
    }
    free(X); free(Y);
  }
  return(0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
testq %rax, %rax
jne 0x22a30
movl (%rbx), %edi
movl 0x4(%rbx), %esi
callq 0x4971a
movq %rax, 0x18(%rbx)
movq 0x30(%rbx), %rcx
testq %rcx, %rcx
je 0x22ab1
movslq 0x8(%rbx), %rdx
testq %rdx, %rdx
jle 0x22b5b
movl 0x4(%rbx), %esi
xorl %edi, %edi
testl %esi, %esi
jle 0x22aa4
movl (%rbx), %r8d
movq (%rax,%rdi,8), %r9
xorl %r10d, %r10d
testl %r8d, %r8d
jle 0x22a93
movq (%rcx,%rdi,8), %r11
movq 0x10(%rbx), %r14
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
movss (%r11,%r15,4), %xmm1
movq (%r14,%r15,8), %r12
mulss (%r12,%r10,4), %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %r15
cmpq %r15, %r8
jne 0x22a6d
cvtsd2ss %xmm0, %xmm0
jmp 0x22a96
xorps %xmm0, %xmm0
movss %xmm0, (%r9,%r10,4)
incq %r10
cmpq %rsi, %r10
jne 0x22a59
incq %rdi
cmpq %rdx, %rdi
jne 0x22a4b
jmp 0x22b5b
movslq (%rbx), %r14
leaq (,%r14,8), %r12
movq %r12, %rdi
callq 0x21e0
movq %rax, %r15
movq %r12, %rdi
callq 0x21e0
movq %rax, %r12
cmpl $0x0, 0x4(%rbx)
jle 0x22b4b
xorl %r13d, %r13d
testl %r14d, %r14d
jle 0x22b04
movq 0x10(%rbx), %rax
movl %r14d, %ecx
xorl %edx, %edx
movq (%rax,%rdx,8), %rsi
xorps %xmm0, %xmm0
cvtss2sd (%rsi,%r13,4), %xmm0
movsd %xmm0, (%r12,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x22ae9
movq 0x28(%rbx), %rsi
movq %r15, %rdi
movq %r12, %rdx
movl %r14d, %ecx
callq 0x49a2e
movslq (%rbx), %r14
testq %r14, %r14
jle 0x22b3f
movq 0x18(%rbx), %rax
xorl %ecx, %ecx
xorps %xmm0, %xmm0
cvtsd2ss (%r15,%rcx,8), %xmm0
movq (%rax,%rcx,8), %rdx
movss %xmm0, (%rdx,%r13,4)
incq %rcx
cmpq %rcx, %r14
jne 0x22b24
incq %r13
movslq 0x4(%rbx), %rax
cmpq %rax, %r13
jl 0x22adb
movq %r15, %rdi
callq 0x2050
movq %r12, %rdi
callq 0x2050
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/kinetic_tnm.c
// Function: Normal_vector
void Normal_vector(double *v, struct bond *bond, double *vers)
{
  double *r0=NULL; int j;
  if((bond)&&(bond->previous)&&(bond->previous->previous)&&
     (bond->previous->previous->atom)){
    r0=bond->previous->previous->atom->r;
  }
  if(r0==NULL){
    printf("ERROR, no previous atom found for bond angle\n");
    goto error_normal;
  }
  double *r1=bond->previous->atom->r, dr[3];
  for(j=0; j<3; j++)dr[j]=r1[j]-r0[j];
  Vector_product_d(v, vers, dr);
  // Normalize:
  double v2=0; for(j=0; j<3; j++)v2+=v[j]*v[j];
  if(v2<=0){
    printf("ERROR for bond angle, zero norm (%.6f) of rotation axis\n",v2);
    goto error_normal;
  }
  v2=1./sqrt(v2); for(j=0; j<3; j++)v[j]*=v2;
  return;
 error_normal:
  printf("atoms: %s %d %s %d prev. bond: %d prev. prev.: %d\n",
	 bond->previous->atom->name, bond->previous->atom->res,
	 bond->atom->name, bond->atom->res,
	 bond->previous->i_atom, bond->previous->previous->i_atom);
  exit(8);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
testq %rsi, %rsi
je 0x231bf
movq 0x28(%r14), %rcx
testq %rcx, %rcx
je 0x231bf
movq 0x28(%rcx), %rax
testq %rax, %rax
je 0x231bf
movq (%rax), %rax
testq %rax, %rax
je 0x231bf
movq %rdi, %rbx
movq (%rcx), %rcx
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm0
subsd (%rax,%rsi,8), %xmm0
movsd %xmm0, 0x10(%rsp,%rsi,8)
incq %rsi
cmpq $0x3, %rsi
jne 0x2312b
leaq 0x10(%rsp), %rax
movq %rbx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x103bb
xorpd %xmm0, %xmm0
xorl %eax, %eax
movsd (%rbx,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq $0x3, %rax
jne 0x2315d
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x2320a
ucomisd %xmm1, %xmm0
jb 0x2318d
sqrtsd %xmm0, %xmm0
jmp 0x23192
callq 0x22a0
movsd 0x2dfae(%rip), %xmm1    # 0x51148
divsd %xmm0, %xmm1
xorl %eax, %eax
movsd (%rbx,%rax,8), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, (%rbx,%rax,8)
incq %rax
cmpq $0x3, %rax
jne 0x231a0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x358eb(%rip), %rdi     # 0x58ab1
callq 0x2090
movq (%r14), %rcx
movq 0x28(%r14), %rax
movq (%rax), %rsi
movl 0x64(%rsi), %edx
addq $0x18, %rsi
movl 0x64(%rcx), %r8d
addq $0x18, %rcx
movl 0x20(%rax), %r9d
movq 0x28(%rax), %rax
movl 0x20(%rax), %eax
movl %eax, (%rsp)
leaq 0x35728(%rip), %rdi     # 0x58921
xorl %eax, %eax
callq 0x20f0
movl $0x8, %edi
callq 0x2280
leaq 0x356d7(%rip), %rdi     # 0x588e8
movb $0x1, %al
callq 0x20f0
jmp 0x231cb
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
leaq 0x10(%rsp), %rbx
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x2327c
movl (%rbx), %esi
callq 0x496ae
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x2328c
movl (%rbx), %esi
callq 0x49678
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x2329c
movl (%rbx), %esi
callq 0x49678
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x232ac
movl (%rbx), %esi
callq 0x496ae
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x232bc
movl (%rbx), %esi
callq 0x49678
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x232ce
movl 0x8(%rbx), %esi
popq %rbx
jmp 0x49678
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq 0x48(%rsp), %rdi
movl 0x10(%rsp), %ebx
movl %ebx, %esi
callq 0x49678
movq 0x50(%rsp), %rdi
movl %ebx, %esi
callq 0x49678
movq 0x58(%rsp), %rdi
movl %ebx, %esi
callq 0x49678
movq 0x30(%rsp), %rdi
callq 0x2050
movq 0x28(%rsp), %rdi
callq 0x2050
movq 0xd0(%rsp), %rdi
callq 0x2050
movq 0x38(%rsp), %rdi
callq 0x2050
movq 0x78(%rsp), %rdi
callq 0x2050
movq 0x80(%rsp), %rdi
callq 0x2050
movq 0x88(%rsp), %rdi
callq 0x2050
movq 0x70(%rsp), %rdi
callq 0x2050
movq 0xc8(%rsp), %rdi
callq 0x2050
movq 0xa8(%rsp), %rdi
callq 0x2050
movq 0xb0(%rsp), %rdi
callq 0x2050
movq 0xb8(%rsp), %rdi
callq 0x2050
movq 0xc0(%rsp), %rdi
callq 0x2050
movq 0x90(%rsp), %rdi
callq 0x2050
movq 0x68(%rsp), %rdi
callq 0x2050
movq 0x60(%rsp), %rdi
callq 0x2050
movq 0x40(%rsp), %rdi
popq %rbx
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %rcx, %r8
movl %edx, %ecx
movq %rsi, %rdx
movl %edi, %ebx
movq 0x40(%rsp), %r14
movq 0x58(%rsp), %r12
movq 0x50(%rsp), %r13
movq 0x48(%rsp), %rbp
movq %r9, %rdi
movl %ebx, %esi
callq 0x23b07
movl %ebx, %edi
movq %r15, %rsi
movq %rbp, %rdx
movq %r14, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x4a559
movq %r12, %rdi
movq %r13, %rsi
movl %ebx, %edx
movq %rbp, %rcx
movq %r14, %r8
callq 0x23bdb
testl %ebx, %ebx
jle 0x23af8
cvtsi2ss %ebx, %xmm0
movss %xmm0, 0x4(%rsp)
movq 0x60(%rsp), %r15
movl %ebx, %r12d
xorl %r13d, %r13d
movq (%r14,%r13,8), %rdi
movl %ebx, %esi
callq 0x10bf3
divss 0x4(%rsp), %xmm0
movss %xmm0, (%r15,%r13,4)
incq %r13
cmpq %r13, %r12
jne 0x23ad9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq