LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r9d, %ebx
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r14
movl $0x1, 0x59784(%rip)     # 0x7428c
cvtsd2ss 0x48(%rdi), %xmm0
leaq 0x495c4(%rip), %rax     # 0x640d8
movss %xmm0, (%rax)
leaq 0x49549(%rip), %rax     # 0x64068
movss (%rax), %xmm0
mulss %xmm0, %xmm0
movss %xmm0, 0x597ad(%rip)    # 0x742dc
leaq 0x4959e(%rip), %rax     # 0x640d4
movss (%rax), %xmm0
movaps %xmm0, %xmm1
addss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm1
movsd %xmm1, 0x59793(%rip)    # 0x742e0
mulss 0x362a3(%rip), %xmm0    # 0x50df8
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x59787(%rip)    # 0x742e8
movq %rcx, %rdx
movl %r9d, %ecx
callq 0x1a78b
movq %rax, 0x5975d(%rip)     # 0x742d0
imull $0x96, %ebx, %eax
movl %eax, 0x59759(%rip)     # 0x742d8
cltq
imulq $0xc8, %rax, %rdi
callq 0x21d0
movq %rax, 0x5972c(%rip)     # 0x742c0
movss 0x492f4(%rip), %xmm0    # 0x63e90
movq %rax, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl %ebx, %ecx
movq %r14, %r8
callq 0x19c18
movl %eax, 0x59708(%rip)     # 0x742bc
movl %eax, 0x596fe(%rip)     # 0x742b8
movslq %eax, %r12
imulq $0xc8, %r12, %rdi
callq 0x21d0
movq %rax, %rbx
movq %rax, 0x596f5(%rip)     # 0x742c8
movq 0x596e6(%rip), %r14     # 0x742c0
xorl %r15d, %r15d
testl %r12d, %r12d
cmovlel %r15d, %r12d
imulq $0xc8, %r12, %r12
cmpq %r15, %r12
je 0x1ac0b
leaq (%rbx,%r15), %rdi
leaq (%r14,%r15), %rsi
movl $0xc8, %edx
callq 0x21a0
addq $0xc8, %r15
jmp 0x1abeb
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl (%rdi), %ecx
xorl %eax, %eax
testl %ecx, %ecx
js 0x1bb7d
pushq %rbx
movq %rdi, %rbx
movslq 0x4(%rdi), %rdx
testq %rdx, %rdx
js 0x1bb7c
imulq $0x70, %rcx, %rax
addq %rsi, %rax
imulq $0x70, %rdx, %rcx
addq %rsi, %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
cmpq $0x3, %rdx
je 0x1bb4e
movsd (%rax,%rdx,8), %xmm1
subsd (%rcx,%rdx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdx
jmp 0x1bb31
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1bb5e
sqrtsd %xmm0, %xmm0
jmp 0x1bb63
callq 0x2290
movsd %xmm0, 0x20(%rbx)
leaq 0x484f9(%rip), %rax     # 0x64068
cvtss2sd (%rax), %xmm1
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %esi, %ebp
movq %rdi, %r15
movq 0xe0(%rsp), %rdx
leaq 0x35213(%rip), %rsi     # 0x51f6f
xorl %r14d, %r14d
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2260
leaq 0x343db(%rip), %rsi     # 0x51150
movq %rbx, %rdi
callq 0x2210
movq %rax, (%rsp)
leaq 0x2ef1f(%rip), %rdi     # 0x4bca7
movq %rbx, %rsi
xorl %eax, %eax
callq 0x20f0
cmpq $0x4, %r14
je 0x1cda3
andl $0x0, 0x30(%rsp,%r14,4)
incq %r14
jmp 0x1cd92
movl 0x470d7(%rip), %edx     # 0x63e80
leaq 0x351d2(%rip), %rsi     # 0x51f82
xorl %r14d, %r14d
movq (%rsp), %rdi
xorl %eax, %eax
callq 0x2190
testl %ebp, %ebp
cmovlel %r14d, %ebp
xorpd %xmm1, %xmm1
movq 0x18(%rsp), %r8
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movq (%rsp), %r12
subl $0x1, %ebp
jb 0x1ce9c
movslq 0x8(%rsi), %rax
movslq (%r8,%rax,4), %rbx
movq (%rdi,%rbx,8), %r13
imulq $0xc8, %rbx, %rax
movsd 0x20(%rsi), %xmm0
xorl %ecx, %ecx
ucomisd 0x20(%r13,%rax), %xmm0
setbe %cl
movsd 0xb8(%r13,%rax), %xmm0
xorl %edx, %edx
ucomisd %xmm1, %xmm0
seta %dl
leaq (%rdx,%rcx,2), %r15
cmpl $0x0, 0x30(%rsp,%r15,4)
jne 0x1ce90
addq %rax, %r13
movq %r12, %rdi
movl %ebx, %edx
movl %ebx, %ecx
movq %rsi, 0x28(%rsp)
leaq 0x3515b(%rip), %r8      # 0x51f96
movl %r14d, 0xc(%rsp)
movq 0x20(%rsp), %r14
movq %r14, %r9
callq 0x1ceb7
movq %r12, %rdi
movq %r13, %rsi
movl %ebx, %edx
movl %ebx, %ecx
leaq 0x35148(%rip), %r8      # 0x51fa6
movq %r14, %r9
movl 0xc(%rsp), %r14d
callq 0x1ceb7
xorpd %xmm1, %xmm1
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %r8
movl $0x1, 0x30(%rsp,%r15,4)
incl %r14d
cmpl $0x4, %r14d
je 0x1ce9c
addq $0xc8, %rsi
jmp 0x1cdd9
movq (%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_O2/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 0x350d3(%rip), %rsi     # 0x51fc6
movq %r10, %rdx
movl %eax, %ecx
movb $0x3, %al
callq 0x2190
movsd 0x48(%r14), %xmm0
movsd 0x40(%r14), %xmm1
movsd 0x30(%r14), %xmm3
movsd 0x38(%r14), %xmm2
leaq 0x350dd(%rip), %rsi     # 0x51ffb
movq %rbx, %rdi
movb $0x4, %al
callq 0x2190
cvtss2sd 0x10(%r14), %xmm0
cvtss2sd 0x14(%r14), %xmm1
cvtss2sd 0x18(%r14), %xmm2
leaq 0x350e1(%rip), %rsi     # 0x52022
movq %rbx, %rdi
movb $0x3, %al
callq 0x2190
movss 0x342c9(%rip), %xmm0    # 0x5121c
pushq $0x64
popq %rbp
leaq 0x350e3(%rip), %r15     # 0x52040
subl $0x1, %ebp
jb 0x1cfa7
cvtss2sd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movq %r14, %rdi
movss %xmm0, 0xc(%rsp)
movss 0xc(%rsp), %xmm0
callq 0x1ac14
cvtss2sd %xmm0, %xmm1
movq %rbx, %rdi
movq %r15, %rsi
movsd 0x10(%rsp), %xmm0
movb $0x2, %al
callq 0x2190
movss 0xc(%rsp), %xmm0
addss 0x3427b(%rip), %xmm0    # 0x51220
jmp 0x1cf5d
leaq 0x3509d(%rip), %rdi     # 0x5204b
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2280
// File: /workspace/github_c_makefile_star2_O2/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 $0x88, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, 0x18(%rsp)
leaq 0x34fce(%rip), %rsi     # 0x51fb6
xorl %ebp, %ebp
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x2260
leaq 0x3414d(%rip), %rsi     # 0x51150
movq %r13, %rdi
callq 0x2210
movq %rax, %r12
leaq 0x2ec92(%rip), %rdi     # 0x4bca7
movq %r13, %rsi
xorl %eax, %eax
callq 0x20f0
movl 0x46e5b(%rip), %edx     # 0x63e80
leaq 0x34f56(%rip), %rsi     # 0x51f82
movq %r12, %rdi
xorl %eax, %eax
callq 0x2190
movl %ebx, 0xc(%rsp)
movslq %ebx, %rax
movq %rax, 0x10(%rsp)
incl %eax
movl %eax, 0x8(%rsp)
cmpl 0xc(%rsp), %ebp
jge 0x1d096
movslq %ebp, %rax
movq 0x10(%rsp), %r15
subq %rax, %r15
movq 0x18(%rsp), %rcx
leaq (%rcx,%rax,8), %rbx
movl %ebp, %ebp
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x1d08e
movq (%rbx,%r13,8), %rsi
leal (%rbp,%r13), %edx
movq %r12, %rdi
xorl %ecx, %ecx
leaq 0x34f25(%rip), %r8      # 0x51fa6
movq %r14, %r9
callq 0x1ceb7
incq %r13
jmp 0x1d067
movl 0x8(%rsp), %eax
movl %eax, %ebp
jmp 0x1d048
movq %r12, %rdi
callq 0x20c0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movl (%rcx), %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
imulq $0xc8, %rcx, %rbp
pushq $-0x1
popq %rcx
xorl %edx, %edx
movl %ecx, %esi
cmpq %rax, %rbp
je 0x1d799
movl 0x8(%r14,%rax), %edi
movl 0xc(%r14,%rax), %r8d
movl %edi, %r9d
xorl %ecx, %r9d
xorl %r8d, %esi
xorl %r10d, %r10d
orl %r9d, %esi
cmovnel %edi, %ecx
setne %r10b
addl %r10d, %edx
addq $0xc8, %rax
movl %r8d, %esi
jmp 0x1d766
movl %edx, %r13d
shlq $0x2, %r13
movq %r13, %rdi
callq 0x21d0
movq %rax, (%r15)
movq %r13, %rdi
callq 0x21d0
movq %rax, (%r12)
pushq $-0x1
popq %rsi
xorl %ecx, %ecx
xorl %edx, %edx
movl %esi, %edi
cmpq %rcx, %rbp
je 0x1d801
movl 0x8(%r14,%rcx), %r8d
movl 0xc(%r14,%rcx), %r9d
movl %r8d, %r10d
xorl %esi, %r10d
movl %r9d, %r11d
xorl %edi, %r11d
orl %r10d, %r11d
je 0x1d7f8
movq (%r15), %rsi
movslq %edx, %rdx
movw %r8w, (%rsi,%rdx,2)
movw %r9w, (%rax,%rdx,2)
incl %edx
movl %r9d, %edi
movl %r8d, %esi
addq $0xc8, %rcx
jmp 0x1d7c0
movl %edx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
imulq $0xc8, %rsi, %rax
movq %rax, 0x20(%rsp)
pushq $-0x1
popq %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
xorl %r15d, %r15d
movq %rdx, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
cmpq %r15, 0x20(%rsp)
je 0x1d907
movl %eax, 0x4(%rsp)
movslq 0x8(%rbx,%r15), %r12
movq %r12, %rax
shlq $0x5, %rax
movsbl 0x13(%r14,%rax), %r13d
movl %r13d, %edi
callq 0x1d91c
testl %eax, %eax
js 0x1d8cc
movl %eax, %ebp
movslq 0xc(%rbx,%r15), %r12
movq %r12, %rax
shlq $0x5, %rax
movsbl 0x13(%r14,%rax), %r13d
movl %r13d, %edi
callq 0x1d91c
testl %eax, %eax
js 0x1d8cc
leaq 0x468da(%rip), %rcx     # 0x64180
movq (%rcx), %rcx
movl %ebp, %edx
movq (%rcx,%rdx,8), %rcx
movl %eax, %eax
cvtss2sd (%rcx,%rax,4), %xmm0
movsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rsp)
movl 0x4(%rsp), %eax
jmp 0x1d8d5
movl 0x4(%rsp), %eax
cmpl %r12d, %eax
jne 0x1d8da
movl %eax, %r12d
jmp 0x1d8ee
leaq 0x34aa8(%rip), %rdi     # 0x52389
movl %r13d, %esi
movl %r12d, %edx
xorl %eax, %eax
callq 0x20f0
movq 0x10(%rsp), %r14
movq 0x8(%rsp), %rbx
addq $0xc8, %r15
movl %r12d, %eax
jmp 0x1d852
cvtsd2ss 0x18(%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x46855(%rip), %rax     # 0x64178
movq (%rax), %rcx
xorl %eax, %eax
cmpq $0x14, %rax
je 0x1d939
cmpb %dil, (%rcx,%rax)
je 0x1d942
incq %rax
jmp 0x1d928
cmpb $0x2d, %dil
jne 0x1d943
pushq $0x14
popq %rax
retq
leal -0x20(%rdi), %eax
cmpb $0x61, %dil
movzbl %dil, %esi
movzbl %al, %edx
cmovll %esi, %edx
xorl %esi, %esi
pushq $-0x1
popq %rax
cmpq $0x14, %rsi
je 0x1d942
cmpb (%rcx,%rsi), %dl
je 0x1d969
incq %rsi
jmp 0x1d959
movl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1e068
movq 0x18(%rdi), %rax
ucomiss 0x4(%rax), %xmm0
jb 0x1e06d
jmp 0x1e142
testl %r11d, %r11d
je 0x1e0e9
leaq 0x10(%rdi), %rax
movq 0x10(%rdi), %r8
movq %r8, %rcx
movq %rcx, %rdx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x1e0ba
movss 0x4(%rcx), %xmm1
ucomiss %xmm0, %xmm1
jb 0x1e078
leaq 0x8(%rdx), %r9
cmpl $0x7cf, %r11d           # imm = 0x7CF
jle 0x1e0c7
movq 0x18(%rdi), %r10
cmpq %r10, %rcx
je 0x1e11f
movq 0x8(%rcx), %rbx
movq %rcx, %r11
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x1e114
movq 0x8(%r11), %r11
jmp 0x1e0ab
leaq 0x8(%rdx), %r9
cmpl $0x7d0, %r11d           # imm = 0x7D0
jge 0x1e109
movq %r11, %r10
shlq $0x4, %r10
incl %r11d
addq 0x8(%rdi), %r10
movl %r11d, (%rdi)
movq 0x18(%rdi), %r11
ucomiss 0x4(%r11), %xmm0
jbe 0x1e121
movq %r10, 0x18(%rdi)
jmp 0x1e121
movq 0x8(%rdi), %rax
movl %esi, (%rax)
movss %xmm0, 0x4(%rax)
andq $0x0, 0x8(%rax)
movl $0x1, (%rdi)
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
jmp 0x1e142
movq %rdx, 0x18(%rdi)
xorl %ecx, %ecx
movq %rdx, %r10
jmp 0x1e121
movq %r11, 0x18(%rdi)
andq $0x0, 0x8(%r11)
jmp 0x1e121
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_O2/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
movq %r9, %rbx
movq %r8, %r15
movq %rdx, %r12
movss %xmm1, 0xc(%rsp)
movss %xmm0, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movl 0x64(%rcx), %ebp
movl 0x64(%r8), %r13d
movss %xmm2, 0x8(%rsp)
xorl %eax, %eax
testq %r12, %r12
je 0x1e4c8
movss 0x4(%r12), %xmm0
ucomiss %xmm2, %xmm0
ja 0x1e4c8
movslq (%r12), %rax
imulq $0x70, %rax, %r14
addq %rbx, %r14
cmpq %r15, %r14
je 0x1e4a5
movq %r15, %rdi
movq %r14, %rsi
movss %xmm0, 0x14(%rsp)
callq 0x1eb16
movss 0x14(%rsp), %xmm3
movss 0x8(%rsp), %xmm2
ucomiss %xmm2, %xmm0
jae 0x1e4a5
movaps %xmm0, %xmm1
movaps %xmm0, %xmm4
maxss %xmm3, %xmm4
movss 0x10(%rsp), %xmm0
ucomiss %xmm4, %xmm0
jbe 0x1e4a5
movss %xmm4, 0x4(%rsp)
movl 0x64(%r14), %edi
movl %ebp, %esi
movaps %xmm3, %xmm0
movl %r13d, %edx
callq 0x173fa
testl %eax, %eax
je 0x1e4af
movss 0xc(%rsp), %xmm0
movss 0x4(%rsp), %xmm1
ucomiss %xmm1, %xmm0
movss 0x8(%rsp), %xmm2
ja 0x1e4bc
movq 0x8(%r12), %r12
jmp 0x1e411
movq 0x20(%rsp), %rax
movss 0x4(%rsp), %xmm1
jmp 0x1e4c1
movq 0x18(%rsp), %rax
movss %xmm1, (%rax)
pushq $0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r12
movss %xmm2, 0x8(%rsp)
movq %rdx, %r13
movss %xmm1, 0xc(%rsp)
movss %xmm0, 0x14(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movl 0x64(%rcx), %eax
movl %eax, 0x10(%rsp)
movl 0x64(%r8), %r14d
xorl %eax, %eax
testq %r13, %r13
je 0x1e612
movss 0x4(%r13), %xmm0
ucomiss 0x8(%rsp), %xmm0
ja 0x1e612
movslq (%r13), %rax
imulq $0x70, %rax, %rbp
addq %rbx, %rbp
cmpq %r15, %rbp
je 0x1e5f1
movq %r15, %rdi
movq %rbp, %rsi
movss %xmm0, 0x4(%rsp)
callq 0x1eb16
movss 0x4(%rsp), %xmm1
ucomiss 0x8(%rsp), %xmm0
jae 0x1e5f1
ucomiss %xmm1, %xmm0
movss %xmm0, (%rsp)
jbe 0x1e599
movq %r15, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x1eb4b
movaps %xmm0, %xmm3
mulss %xmm0, %xmm3
movss (%rsp), %xmm1
movaps %xmm1, %xmm2
movss 0x4(%rsp), %xmm0
jmp 0x1e5bc
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x1eb4b
movaps %xmm0, %xmm3
mulss %xmm0, %xmm3
movss 0x4(%rsp), %xmm0
movaps %xmm0, %xmm2
movss (%rsp), %xmm1
mulss 0x8(%rsp), %xmm2
divss %xmm2, %xmm3
ucomiss 0x14(%rsp), %xmm3
jbe 0x1e5f1
movss %xmm3, (%rsp)
movl 0x64(%rbp), %edi
movl 0x10(%rsp), %esi
movl %r14d, %edx
callq 0x173fa
testl %eax, %eax
je 0x1e5fa
movss (%rsp), %xmm0
ucomiss 0xc(%rsp), %xmm0
ja 0x1e606
movq 0x8(%r13), %r13
jmp 0x1e518
movq 0x20(%rsp), %rax
movss (%rsp), %xmm0
jmp 0x1e60b
movq 0x18(%rsp), %rax
movss %xmm0, (%rax)
pushq $0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r12
movss %xmm2, 0x8(%rsp)
movq %rdx, %r13
movss %xmm1, 0xc(%rsp)
movss %xmm0, 0x14(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movl 0x64(%rcx), %eax
movl %eax, 0x10(%rsp)
movl 0x64(%r8), %r14d
xorl %eax, %eax
testq %r13, %r13
je 0x1e761
movss 0x4(%r13), %xmm0
ucomiss 0x8(%rsp), %xmm0
ja 0x1e761
movslq (%r13), %rax
imulq $0x70, %rax, %rbp
addq %rbx, %rbp
cmpq %r15, %rbp
je 0x1e740
movq %r15, %rdi
movq %rbp, %rsi
movss %xmm0, 0x4(%rsp)
callq 0x1eb16
movss 0x4(%rsp), %xmm1
ucomiss 0x8(%rsp), %xmm0
jae 0x1e740
ucomiss %xmm1, %xmm0
movss %xmm0, (%rsp)
jbe 0x1e6e0
movq %r15, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x1eb4b
mulss %xmm0, %xmm0
movss (%rsp), %xmm1
movaps %xmm1, %xmm3
movss 0x4(%rsp), %xmm2
jmp 0x1e700
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x1eb4b
mulss %xmm0, %xmm0
movss 0x4(%rsp), %xmm2
movaps %xmm2, %xmm3
movss (%rsp), %xmm1
divss 0x8(%rsp), %xmm0
subss %xmm0, %xmm3
movss 0x14(%rsp), %xmm0
ucomiss %xmm3, %xmm0
jbe 0x1e740
movss %xmm3, (%rsp)
movl 0x64(%rbp), %edi
movl 0x10(%rsp), %esi
movaps %xmm2, %xmm0
movl %r14d, %edx
callq 0x173fa
testl %eax, %eax
je 0x1e749
movss 0xc(%rsp), %xmm0
movss (%rsp), %xmm1
ucomiss %xmm1, %xmm0
ja 0x1e755
movq 0x8(%r13), %r13
jmp 0x1e662
movq 0x20(%rsp), %rax
movss (%rsp), %xmm1
jmp 0x1e75a
movq 0x18(%rsp), %rax
movss %xmm1, (%rax)
pushq $0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movl 0x64(%r8), %r13d
testq %r15, %r15
je 0x1eb05
movslq (%r15), %rax
imulq $0x70, %rax, %r12
addq %rbx, %r12
cmpq %r14, %r12
je 0x1eafc
movss 0x4(%r15), %xmm0
movss %xmm0, 0xc(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x1eb16
movaps %xmm0, %xmm1
movss %xmm0, 0x24(%rsp)
movl 0x64(%r12), %edi
movl %ebp, %esi
movss 0xc(%rsp), %xmm0
movl %r13d, %edx
callq 0x173fa
movss 0x24(%rsp), %xmm2
movss 0xc(%rsp), %xmm1
ucomiss %xmm1, %xmm2
jbe 0x1eab3
testl %eax, %eax
je 0x1eacc
movq 0x18(%rsp), %rax
movss (%rax), %xmm0
ucomiss %xmm2, %xmm0
jbe 0x1eafc
movq 0x18(%rsp), %rax
jmp 0x1eadf
testl %eax, %eax
je 0x1eae5
movq 0x18(%rsp), %rax
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x1eafc
movq 0x18(%rsp), %rax
jmp 0x1eaf8
movq 0x10(%rsp), %rax
movss (%rax), %xmm0
ucomiss %xmm2, %xmm0
jbe 0x1eafc
movq 0x10(%rsp), %rax
movss %xmm2, (%rax)
jmp 0x1eafc
movq 0x10(%rsp), %rax
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x1eafc
movq 0x10(%rsp), %rax
movss %xmm1, (%rax)
movq 0x8(%r15), %r15
jmp 0x1ea38
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
subsd (%rsi), %xmm0
mulsd %xmm0, %xmm0
subsd 0x8(%rsi), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd 0x10(%rdi), %xmm0
subsd 0x10(%rsi), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorpd %xmm0, %xmm0
xorl %eax, %eax
cmpq $0x3, %rax
je 0x1eb77
movsd (%rdi,%rax,8), %xmm1
movapd %xmm1, %xmm2
subsd (%rsi,%rax,8), %xmm2
subsd (%rdx,%rax,8), %xmm1
mulsd %xmm2, %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x1eb51
cvtsd2ss %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/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:
leaq 0x8(%rsp), %rdx
xorl %eax, %eax
cmpq $0x3, %rax
je 0x1ef58
andq $0x0, -0x18(%rsp,%rax,8)
incq %rax
jmp 0x1ef47
movl (%rdx), %eax
movq 0x28(%rdx), %rcx
movq 0x10(%rdx), %rdx
xorl %r8d, %r8d
testl %eax, %eax
cmovlel %r8d, %eax
xorpd %xmm0, %xmm0
cmpq %rax, %r8
je 0x1efb4
movslq (%rcx,%r8,4), %r9
imulq $0x70, %r9, %r9
addq %rdi, %r9
cvtss2sd (%rdx,%r8,4), %xmm1
xorl %r10d, %r10d
cmpq $0x3, %r10
je 0x1efab
movsd (%r9,%r10,8), %xmm2
mulsd %xmm1, %xmm2
addsd -0x18(%rsp,%r10,8), %xmm2
movsd %xmm2, -0x18(%rsp,%r10,8)
incq %r10
jmp 0x1ef88
addsd %xmm1, %xmm0
incq %r8
jmp 0x1ef6f
xorl %eax, %eax
cmpq $0x3, %rax
je 0x1efd1
movsd -0x18(%rsp,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, -0x18(%rsp,%rax,8)
incq %rax
jmp 0x1efb6
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
cmpq %rsi, %rax
je 0x1f003
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x1effa
movsd (%rdi,%rcx,8), %xmm0
subsd -0x18(%rsp,%rcx,8), %xmm0
movsd %xmm0, (%rdi,%rcx,8)
incq %rcx
jmp 0x1efdf
incq %rax
addq $0x70, %rdi
jmp 0x1efd8
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rdi, 0x40(%rsp)
movl 0x108(%rsp), %eax
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
movq %rax, 0x48(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x8(%rsp)
testl %ecx, %ecx
cmovlel %esi, %ecx
movq %rcx, 0x18(%rsp)
movq 0x130(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %rdx, 0x10(%rsp)
cmpq 0x18(%rsp), %rsi
je 0x1fbb0
movq 0x8(%rsp), %rax
movq (%rax,%rsi,8), %r12
movq %rsi, 0x20(%rsp)
imulq $0x158, %rsi, %rax      # imm = 0x158
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax), %r13
leaq (%rcx,%rax), %rdx
addq $0xd8, %rdx
movq %rdx, 0x28(%rsp)
addq %rcx, %rax
addq $0xa8, %rax
movq %rax, 0x30(%rsp)
xorl %ebp, %ebp
xorl %r15d, %r15d
cmpq 0x48(%rsp), %rbp
je 0x1fb9c
movslq 0x18(%r13), %rax
cmpq %rax, %rbp
jl 0x1fb21
movslq 0x1c(%r13), %rax
movl $0xc0, %r14d
movq 0x28(%rsp), %rsi
cmpq %rax, %rbp
jle 0x1fb2c
movl $0x90, %r14d
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rax
movslq (%rax,%rbp,4), %rax
imulq $0x70, %rax, %rax
addq 0x40(%rsp), %rax
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x1fb56
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x70(%rsp,%rcx,8)
incq %rcx
jmp 0x1fb40
leaq 0x50(%rsp), %rdi
leaq 0x70(%rsp), %rdx
callq 0xf8f7
movslq %r15d, %r15
addq %rbx, %r14
leaq (%r12,%r15,4), %rcx
xorl %eax, %eax
cmpq $0x3, %rax
je 0x1fb91
movsd 0x50(%rsp,%rax,8), %xmm0
addsd (%r14,%rax,8), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rcx,%rax,4)
incq %rax
jmp 0x1fb71
incq %rbp
addq %rax, %r15
jmp 0x1faf9
movq 0x20(%rsp), %rsi
incq %rsi
addq $0x158, %rbx            # imm = 0x158
jmp 0x1faad
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_O2/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, %rbx
movq %rdx, 0x30(%rsp)
movl %esi, %r15d
movq %rdi, %r12
leaq 0x70(%rsp), %r14
leaq 0x32bdf(%rip), %rdi     # 0x527cb
xorl %r13d, %r13d
xorl %eax, %eax
callq 0x20f0
testl %r15d, %r15d
cmovlel %r13d, %r15d
xorl %ebp, %ebp
cmpq %r13, %r15
je 0x1fc42
movq (%r12,%r13,8), %rdi
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq 0x30(%rsp), %rsi
movl %r13d, %ecx
movq %rbx, %r8
callq 0x20d9e
addl %eax, %ebp
incq %r13
addq $0x158, %rbx            # imm = 0x158
jmp 0x1fbff
testl %ebp, %ebp
jne 0x1fc55
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x32b9d(%rip), %rdi     # 0x527f9
movl %ebp, %esi
xorl %eax, %eax
callq 0x20f0
pushq $0x8
popq %rdi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
movl %edx, %edi
callq 0x4379e
xorl %ecx, %ecx
testl %r14d, %r14d
cmovlel %ecx, %r14d
testl %ebx, %ebx
cmovlel %ecx, %ebx
cmpq %rbx, %rcx
je 0x20308
xorl %edx, %edx
cmpq %rdx, %r14
je 0x20303
movq (%r15,%rdx,8), %rsi
movss (%rsi,%rcx,4), %xmm0
movq (%rax,%rcx,8), %rsi
movss %xmm0, (%rsi,%rdx,4)
incq %rdx
jmp 0x202e7
incq %rcx
jmp 0x202e0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
movl %edx, %edi
callq 0x4379e
xorl %ecx, %ecx
testl %r14d, %r14d
cmovlel %ecx, %r14d
testl %ebx, %ebx
cmovlel %ecx, %ebx
cmpq %rbx, %rcx
je 0x20358
xorl %edx, %edx
cmpq %rdx, %r14
je 0x20353
movq (%r15,%rdx,8), %rsi
cvtsd2ss (%rsi,%rcx,8), %xmm0
movq (%rax,%rcx,8), %rsi
movss %xmm0, (%rsi,%rdx,4)
incq %rdx
jmp 0x20337
incq %rcx
jmp 0x20330
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpq $0x3, %rax
je 0x206c2
movq %rax, %rcx
cmpq $0x3, %rcx
je 0x206bd
movq (%rsi,%rax,8), %r8
movsd (%r8,%rcx,8), %xmm1
movsd (%rdx,%rax,8), %xmm2
mulsd (%rdx,%rcx,8), %xmm2
divsd %xmm0, %xmm2
subsd %xmm2, %xmm1
movq (%rdi,%rax,8), %r8
movsd %xmm1, (%r8,%rcx,8)
incq %rcx
jmp 0x2068c
incq %rax
jmp 0x20683
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 0x2a9db(%rip), %xmm1    # 0x4b0c0
cmpq $0x3, %rax
je 0x2072a
movq (%rdi,%rax,8), %rcx
movapd %xmm0, %xmm2
subsd (%rcx,%rax,8), %xmm2
movsd %xmm2, (%rcx,%rax,8)
movq %rax, %rdx
cmpq $0x2, %rdx
je 0x20725
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
jmp 0x20700
incq %rax
jmp 0x206e5
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x20745
movl 0x1c(%r14), %esi
jmp 0x2074e
movl 0x1c(%r14), %esi
cmpl %esi, 0x1c(%rbx)
jle 0x2079e
xorl %eax, %eax
cmpl %edx, %esi
jl 0x207a1
cmpl %ecx, 0x1c(%rbx)
jl 0x207a1
leaq 0x3226b(%rip), %rdi     # 0x529cb
callq 0x2090
movsbl (%r14), %esi
movl 0x18(%r14), %edx
movl 0x1c(%r14), %ecx
leaq 0x3213c(%rip), %rdi     # 0x528b4
xorl %eax, %eax
callq 0x20f0
movsbl (%rbx), %esi
movl 0x18(%rbx), %edx
movl 0x1c(%rbx), %ecx
leaq 0x3214c(%rip), %rdi     # 0x528db
xorl %eax, %eax
callq 0x20f0
pushq $0x8
popq %rdi
callq 0x2270
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq 0x70(%rsp), %rdx
movq 0x80(%rsp), %r8
movl 0xac(%rsp), %r15d
movq 0xc0(%rsp), %r13
xorl %ebx, %ebx
testl %r15d, %r15d
cmovlel %ebx, %r15d
testl %edi, %edi
cmovlel %ebx, %edi
movq %rdi, (%rsp)
pushq $0x1
popq %rdi
movapd 0x30a4f(%rip), %xmm3    # 0x51240
movsd 0x2f31f(%rip), %xmm4    # 0x4fb18
xorl %r14d, %r14d
movq %r8, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq (%rsp), %rbx
je 0x208e8
movq (%rdx,%rbx,8), %rbp
xorl %r12d, %r12d
movq %rdi, 0x18(%rsp)
cmpq %rdi, %r12
je 0x208dd
movq (%rdx,%r12,8), %rax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
cmpq %rcx, %r15
je 0x20853
movss (%rax,%rcx,4), %xmm1
mulss (%rbp,%rcx,4), %xmm1
mulss (%r13,%rcx,4), %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rcx
jmp 0x2082f
movq (%r8,%rbx,8), %rax
movsd (%rax,%r12,8), %xmm1
movapd %xmm0, %xmm5
subsd %xmm1, %xmm5
andpd %xmm3, %xmm5
movsd (%rax,%rbx,8), %xmm2
andpd %xmm3, %xmm2
mulsd %xmm4, %xmm2
ucomisd %xmm2, %xmm5
jbe 0x208c1
leaq 0x31d50(%rip), %rdi     # 0x525d3
movl %ebx, %esi
movl %r12d, %edx
movb $0x2, %al
movsd %xmm0, 0x20(%rsp)
callq 0x20f0
movsd 0x20(%rsp), %xmm0
movsd 0x2f275(%rip), %xmm4    # 0x4fb18
movapd 0x30995(%rip), %xmm3    # 0x51240
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %rdx
incl %r14d
movq (%r8,%rbx,8), %rax
movsd %xmm0, (%rax,%r12,8)
cmpq %r12, %rbx
je 0x208d5
movq (%r8,%r12,8), %rax
movsd %xmm0, (%rax,%rbx,8)
incq %r12
jmp 0x2081c
incq %rbx
incq %rdi
jmp 0x20806
testl %r14d, %r14d
jne 0x208fb
leaq 0x320ee(%rip), %rdi     # 0x529e2
callq 0x2090
jmp 0x2090c
leaq 0x31ce2(%rip), %rdi     # 0x525e4
movl %r14d, %esi
xorl %eax, %eax
callq 0x20f0
pushq $0x8
popq %rdi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq 0x28(%rsp), %rax
movq 0x40(%rsp), %r9
movslq %ecx, %rcx
movslq %r8d, %r8
xorpd %xmm0, %xmm0
cmpq %r8, %rcx
jg 0x209a1
movslq (%r9,%rcx,4), %r10
imulq $0x70, %r10, %r10
addq %rdx, %r10
cvtss2sd (%rax,%rcx,4), %xmm1
xorl %r11d, %r11d
cmpq $0x3, %r11
je 0x20998
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 %r11, %rbx
cmpq $0x3, %rbx
je 0x20993
movq (%rsi,%r11,8), %r14
movsd (%r10,%rbx,8), %xmm3
mulsd %xmm2, %xmm3
addsd (%r14,%rbx,8), %xmm3
movsd %xmm3, (%r14,%rbx,8)
incq %rbx
jmp 0x2096e
incq %r11
jmp 0x20943
addsd %xmm1, %xmm0
incq %rcx
jmp 0x2092b
cvtsd2ss %xmm0, %xmm0
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x209f8
movl (%rbx), %edi
movl 0x4(%rbx), %esi
callq 0x4379e
movq %rax, 0x18(%rbx)
movq 0x30(%rbx), %rcx
testq %rcx, %rcx
je 0x20a7c
movl 0x8(%rbx), %edx
xorl %esi, %esi
testl %edx, %edx
cmovlel %esi, %edx
xorl %edi, %edi
cmpq %rdx, %rdi
je 0x20b2a
movl 0x4(%rbx), %r8d
testl %r8d, %r8d
cmovlel %esi, %r8d
xorl %r9d, %r9d
cmpq %r8, %r9
je 0x20a77
movl (%rbx), %r10d
testl %r10d, %r10d
cmovlel %esi, %r10d
xorpd %xmm0, %xmm0
xorl %r11d, %r11d
cmpq %r11, %r10
je 0x20a64
movq (%rcx,%rdi,8), %r14
movss (%r14,%r11,4), %xmm1
movq 0x10(%rbx), %r14
movq (%r14,%r11,8), %r14
mulss (%r14,%r9,4), %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %r11
jmp 0x20a3a
cvtsd2ss %xmm0, %xmm0
movq (%rax,%rdi,8), %r10
movss %xmm0, (%r10,%r9,4)
incq %r9
jmp 0x20a24
incq %rdi
jmp 0x20a0d
movslq (%rbx), %r14
movq %r14, %r12
shlq $0x3, %r12
movq %r12, %rdi
callq 0x21d0
movq %rax, %r15
movq %r12, %rdi
callq 0x21d0
movq %rax, %r12
xorl %r13d, %r13d
movslq 0x4(%rbx), %rax
cmpq %rax, %r13
jge 0x20b1a
testl %r14d, %r14d
movl $0x0, %eax
cmovgl %r14d, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x20ad4
movq 0x10(%rbx), %rdx
movq (%rdx,%rcx,8), %rdx
cvtss2sd (%rdx,%r13,4), %xmm0
movsd %xmm0, (%r12,%rcx,8)
incq %rcx
jmp 0x20ab6
movq 0x28(%rbx), %rsi
movq %r15, %rdi
movq %r12, %rdx
movl %r14d, %ecx
callq 0x43a6b
movl (%rbx), %r14d
testl %r14d, %r14d
movl $0x0, %eax
cmovgl %r14d, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x20b15
cvtsd2ss (%r15,%rcx,8), %xmm0
movq 0x18(%rbx), %rdx
movq (%rdx,%rcx,8), %rdx
movss %xmm0, (%rdx,%r13,4)
incq %rcx
jmp 0x20af7
incq %r13
jmp 0x20a9f
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_O2/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 0x2106e
movq 0x28(%r14), %rcx
testq %rcx, %rcx
je 0x2106e
movq 0x28(%rcx), %rax
testq %rax, %rax
je 0x2106e
movq (%rax), %rax
testq %rax, %rax
je 0x2106e
movq %rdi, %rbx
movq (%rcx), %rcx
xorl %esi, %esi
cmpq $0x3, %rsi
je 0x20fef
movsd (%rcx,%rsi,8), %xmm0
subsd (%rax,%rsi,8), %xmm0
movsd %xmm0, 0x10(%rsp,%rsi,8)
incq %rsi
jmp 0x20fd4
leaq 0x10(%rsp), %rax
movq %rbx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0xf8f7
xorpd %xmm0, %xmm0
xorl %eax, %eax
cmpq $0x3, %rax
je 0x21020
movsd (%rbx,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x21008
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x210b7
ucomisd %xmm1, %xmm0
jb 0x2103a
sqrtsd %xmm0, %xmm0
jmp 0x2103f
callq 0x2290
movsd 0x2a001(%rip), %xmm1    # 0x4b048
divsd %xmm0, %xmm1
xorl %eax, %eax
cmpq $0x3, %rax
je 0x21066
movsd (%rbx,%rax,8), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, (%rbx,%rax,8)
incq %rax
jmp 0x2104d
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x3199c(%rip), %rdi     # 0x52a11
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 0x317d9(%rip), %rdi     # 0x52881
xorl %eax, %eax
callq 0x20f0
pushq $0x8
popq %rdi
callq 0x2270
leaq 0x3178a(%rip), %rdi     # 0x52848
movb $0x1, %al
callq 0x20f0
jmp 0x2107a
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %esi, %edi
callq 0x43878
movq %rax, 0x20(%r14)
movl %ebp, %edi
movl %ebp, %esi
callq 0x43878
movq %rax, 0x28(%r14)
movl %ebp, %edi
movl %ebx, %esi
callq 0x4379e
movq %rax, 0x10(%r14)
andq $0x0, 0x18(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r14)
andq $0x0, 0x40(%r14)
popq %rbx
popq %r14
popq %rbp
retq