LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/simulation.c
// Function: Set_masses
void Set_masses(float *mass, atom *atoms, int natoms){
  int n=0, i;
  for(i=0; i<natoms; i++){
    //ALIGN
    if(atoms[i].ali==0)continue;
    mass[n] = Mass(atoms+i); n++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x49765
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x54(%rax)
jne 0x49730
jmp 0x4975a
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x70, %rax, %rax
addq %rax, %rdi
callq 0x351c0
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x49711
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/simulation.c
// Function: Put_coord
int Put_coord(float *coord_all, struct bond *bonds, int natoms)
{
  float *coord=coord_all; int i;
  for(i=0; i<natoms; i++){
    if(bonds[i].i_atom<0)break;
    for(int j=0; j<3; j++){*coord=bonds[i].r[j]; coord++;}
  }
  return(i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x49809
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0xc0, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x20(%rax)
jge 0x497b0
jmp 0x49809
movl $0x0, -0x28(%rbp)
cmpl $0x3, -0x28(%rbp)
jge 0x497fc
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0xc0, %rcx, %rcx
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movsd 0x8(%rax,%rcx,8), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x497b7
jmp 0x497fe
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4978e
movl -0x24(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/simulation.c
// Function: Metropolis
int Metropolis(float Ene_tmp, float Ene, float T)
{
  // Initialize random numbers
  if(INIRAN==0){
     INIRAN=1;
     unsigned long iran=randomgenerator();
     InitRandom( (RANDOMTYPE)iran);
     //RANFACTOR=pow(12.0,1/3.0);
  }
  if(Ene_tmp < Ene)return(1);
  float fact=exp((Ene-Ene_tmp)/T);
  //float ran=RandomFloating()*RANFACTOR;
  //if(ran < fact)return(1);
  if(RandomFloating() < fact)return(1);
  return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x8(%rbp)
movss %xmm1, -0xc(%rbp)
movss %xmm2, -0x10(%rbp)
cmpl $0x0, 0x5287a(%rip)     # 0x9c4c8
jne 0x49c6c
movl $0x1, 0x5286e(%rip)     # 0x9c4c8
callq 0x49ce0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x756e0
movss -0x8(%rbp), %xmm1
movss -0xc(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x49c84
movl $0x1, -0x4(%rbp)
jmp 0x49cce
movss -0xc(%rbp), %xmm0
subss -0x8(%rbp), %xmm0
divss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x1230
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movb $0x0, %al
callq 0x75930
movaps %xmm0, %xmm1
movss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x49cc7
movl $0x1, -0x4(%rbp)
jmp 0x49cce
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/simulation.c
// Function: randomgenerator
unsigned long randomgenerator(void){

     unsigned long tm;
     time_t seconds;

     time(&seconds);
     srand((unsigned)(seconds % 65536));
     do   /* waiting time equal 1 second */
       tm= clock();
     while (tm/CLOCKS_PER_SEC < (unsigned)(1));
     return((unsigned long) (rand()));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x10(%rbp), %rdi
callq 0x1170
movq -0x10(%rbp), %rax
movl $0x10000, %ecx          # imm = 0x10000
cqto
idivq %rcx
movl %edx, %edi
callq 0x1120
callq 0x1090
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
xorl %edx, %edx
divq %rcx
cmpq $0x1, %rax
jb 0x49d06
callq 0x1240
cltq
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/simulation.c
// Function: Extract_dphi
void Extract_dphi(double *d_phi, float **Tors_mode, float *sigma,
		  int N_modes, int N_axes, float factor, long *idum)
{
  float gasdev(long *idum);
  int i, k; float z, coeff;

  for(i=0; i<N_axes; i++)d_phi[i]=0;
  for(k=0; k<N_modes; k++){
    z=gasdev(idum);
    coeff = z*sigma[k];
    double *phi=d_phi; float *mode=Tors_mode[k];
    for(i=0; i<N_axes; i++){*phi += coeff*(*mode); phi++; mode++;}
  }
  for(i=0; i<N_axes; i++)d_phi[i]*=factor;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movss %xmm0, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x49d7e
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x49d5b
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x49e2d
movq -0x30(%rbp), %rdi
callq 0x75410
movss %xmm0, -0x3c(%rbp)
movss -0x3c(%rbp), %xmm0
movq -0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
mulss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x49e1d
movss -0x40(%rbp), %xmm0
movq -0x50(%rbp), %rax
mulss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x48(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x50(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x49dd5
jmp 0x49e1f
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x49d85
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x49e62
movss -0x24(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x49e34
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/simulation.c
// Function: Extract_dx
void Extract_dx(float *dx, float **Cart_mode, float *sigma,
		int N_modes, int N_Cart, float factor, long *idum)
{
  float gasdev(long *idum);
  int i, k; float z, coeff;

  for(i=0; i<N_Cart; i++)dx[i]=0;
  for(k=0; k<N_modes; k++){
    z=gasdev(idum);
    coeff = z*sigma[k];
    float *x=dx, *mode=Cart_mode[k];
    for(i=0; i<N_Cart; i++){*x += coeff*(*mode); x++; mode++;}
  }
  for(i=0; i<N_Cart; i++)dx[i]*=factor;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movss %xmm0, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x49ebe
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x49e9b
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x49f71
movq -0x30(%rbp), %rdi
callq 0x75410
movss %xmm0, -0x3c(%rbp)
movss -0x3c(%rbp), %xmm0
movq -0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
mulss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x49f61
movss -0x40(%rbp), %xmm0
movq -0x50(%rbp), %rax
movss (%rax), %xmm2
movq -0x48(%rbp), %rax
movss (%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax)
movq -0x48(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x50(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x49f15
jmp 0x49f63
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x49ec5
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x49fa2
movss -0x24(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
mulss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x49f78
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/simulation.c
// Function: Print_seqres
void Print_seqres(FILE *file_out, struct chain *chains, int Nchain)
{
  char aaname3[8]; for(int i=0; i<8; i++)aaname3[i]='\0';
  int line=1;
  for(int i=0; i<Nchain; i++){
    struct chain *ch=chains+i;
    int lines=ch->N_seqres/13+1, k=0;
    for(int l=0; l<lines; l++){
      fprintf(file_out, "SEQRES %3d %c %4d ",
	      line, ch->label, ch->N_seqres);
      for(int j=0; j<13; j++){
	if(k<ch->N_seqres){
	  Name3(aaname3, Code_AA(ch->seqres[k]));
	  fprintf(file_out, " %3s", aaname3);
	}else{
	  fprintf(file_out, "    ");
	}
	k++;
      }
      fprintf(file_out, "\n"); line++;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x8, -0x20(%rbp)
jge 0x49fe4
movslq -0x20(%rbp), %rax
movb $0x0, -0x1c(%rbp,%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x49fca
movl $0x1, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4a11d
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x60(%rax), %eax
movl $0xd, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x4a10d
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %edx
movq -0x30(%rbp), %rax
movsbl 0x34(%rax), %ecx
movq -0x30(%rbp), %rax
movl 0x60(%rax), %r8d
leaq 0x3613c(%rip), %rsi     # 0x8019a
movb $0x0, %al
callq 0x1150
movl $0x0, -0x40(%rbp)
cmpl $0xd, -0x40(%rbp)
jge 0x4a0e4
movl -0x38(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl 0x60(%rcx), %eax
jge 0x4a0be
leaq -0x1c(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2bec0
movq -0x48(%rbp), %rdi
movl %eax, %esi
callq 0x37330
movq -0x8(%rbp), %rdi
leaq -0x1c(%rbp), %rdx
leaq 0x360f8(%rip), %rsi     # 0x801ad
movb $0x0, %al
callq 0x1150
jmp 0x4a0d0
movq -0x8(%rbp), %rdi
leaq 0x344b5(%rip), %rsi     # 0x7e57e
movb $0x0, %al
callq 0x1150
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x4a06c
movq -0x8(%rbp), %rdi
leaq 0x33f89(%rip), %rsi     # 0x7e078
movb $0x0, %al
callq 0x1150
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x4a034
jmp 0x4a10f
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x49ff2
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/simulation.c
// Function: Write_ref_coord_atom
void Write_ref_coord_atom(float *coord_ref, int N_ref, atom *atoms,
                          int *atom_num)
{
  float *coord=coord_ref;
  for(int i=0;i<N_ref;i++){
    double *r=atoms[atom_num[i]].r;
    for(int j=0; j<3; j++){*coord=*r; coord++; r++;}
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4a1c6
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
cmpl $0x3, -0x3c(%rbp)
jge 0x4a1b9
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, (%rax)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x4a17c
jmp 0x4a1bb
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4a152
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/simulation.c
// Function: Write_ref_coord
void Write_ref_coord(float *coord_ref, int N_ref, float *coord_all,
		     int *atom_num)
{
  float *coord=coord_ref;
  for(int i=0;i<N_ref;i++){
    float *r=coord_all+3*atom_num[i];
    for(int j=0; j<3; j++){*coord=*r; coord++; r++;}
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4a265
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
imull $0x3, (%rcx,%rdx,4), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
cmpl $0x3, -0x3c(%rbp)
jge 0x4a258
movq -0x38(%rbp), %rax
movss (%rax), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, (%rax)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x4a21f
jmp 0x4a25a
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4a1f2
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/simulation.c
// Function: Put_atoms
int Put_atoms(atom *atoms, float *coords, int natoms){
  atom *atom=atoms; float *coord=coords;
  for(int i=0; i<natoms; i++){
    for(int j=0; j<3; j++){atom->r[j]=*coord; coord++;}
    atom++;
  }
  return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4a2f2
movl $0x0, -0x30(%rbp)
cmpl $0x3, -0x30(%rbp)
jge 0x4a2db
movq -0x28(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x4a2a5
movq -0x20(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4a296
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/simulation.c
// Function: Write_all_coord_atom
void Write_all_coord_atom(float *coords, atom *atoms, int natoms)
{
  int i, j; float *coord=coords;
  for(i=0; i<natoms; i++){
    double *r=atoms[i].r;
    for(j=0; j<3; j++){*coord=*r; coord++; r++;}
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4a38a
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0x4a37d
movq -0x30(%rbp), %rax
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, (%rax)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4a340
jmp 0x4a37f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4a31e
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/simulation.c
// Function: Copy_bonds
void Copy_bonds(struct bond *bonds1, struct bond *bonds, int natoms)
{
  struct bond *bond1=bonds1, *bond=bonds;
  bond1->previous=NULL;
  for(int i=0; i<natoms; i++){
    *bond1=*bond;
    //if(bond->i_atom<0)break;
    if(i){
      bond1->previous=bonds1+(int)(bond->previous-bonds);
    }
    bond++; bond1++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, 0x28(%rax)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4ae5e
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0xc0, %edx
callq 0x1160
cmpl $0x0, -0x2c(%rbp)
je 0x4ae37
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rdx
subq %rdx, %rax
movl $0xc0, %esi
cqto
idivq %rsi
cltq
imulq $0xc0, %rax, %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rax
addq $0xc0, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0xc0, %rax
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4ade6
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/simulation.c
// Function: Copy_ali
void Copy_ali(struct ali_atoms *ali_a, struct Reference Ref)
{    
  ali_a->N_ref=Ref.N_ref; ali_a->N_Cart=Ref.N_Cart;
  ali_a->ali1=Ref.atom_num;
  ali_a->ali2=Ref.atom_num;
  ali_a->mass=Ref.mass_atom;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl (%rax), %edx
movq -0x8(%rbp), %rcx
movl %edx, 0x18(%rcx)
movl 0x4(%rax), %edx
movq -0x8(%rbp), %rcx
movl %edx, 0x1c(%rcx)
movq 0x28(%rax), %rdx
movq -0x8(%rbp), %rcx
movq %rdx, (%rcx)
movq 0x28(%rax), %rdx
movq -0x8(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/simulation.c
// Function: Copy_atoms_bonds
void Copy_atoms_bonds(atom *atoms, struct bond *bonds, int natoms){
  atom *atom=atoms; struct bond *bond=bonds;
  for(int i=0; i<natoms; i++){
    double *r1=atom->r, *r2=bond->r;
    for(int j=0; j<3; j++){*r1=*r2; r1++; r2++;}
    atom++; bond++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4e52a
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
cmpl $0x3, -0x44(%rbp)
jge 0x4e502
movq -0x40(%rbp), %rax
movsd (%rax), %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x4e4c9
movq -0x20(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0xc0, %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4e4a6
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/simulation.c
// Function: Test_buildup
float Test_buildup(struct bond *bonds, atom *atoms, int natoms, int naxes)
{
  printf("Testing build up\n");
  // Compute new conformation
  float coord_old[3*natoms], coord_new[3*natoms];
  Set_bonds_measure(bonds, natoms, atoms);
  Put_coord(coord_old, bonds, natoms);
  Build_up(bonds, natoms, NULL, naxes);
  Put_coord(coord_new, bonds, natoms);
  float mass[natoms]; for(int i=0; i<natoms; i++)mass[i]=1;
  float RMSD=rmsd_mclachlan_f(coord_old, coord_new, mass, natoms);
  printf("RMSD with no torsion change: %.2g\n", RMSD);
  if(RMSD > 0.5){
    printf("ERROR in Test_buildup, RMSD= %.2f\n", RMSD);
    exit(8);
  }
  return(RMSD);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
leaq 0x2fff7(%rip), %rdi     # 0x80b24
xorl %eax, %eax
movl %eax, -0x54(%rbp)
callq 0x10d0
movl -0x14(%rbp), %ecx
movl %ecx, %eax
leal (%rax,%rax,2), %eax
movq %rsp, %rcx
movq %rcx, -0x20(%rbp)
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x60(%rbp)
movq %rcx, %rsp
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, %eax
leal (%rax,%rax,2), %eax
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x50(%rbp)
movq %rcx, %rsp
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x1bf00
movq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x49770
movl -0x54(%rbp), %eax
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %ecx
movl %eax, %edx
callq 0x1c4f0
movq -0x50(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x49770
movl -0x14(%rbp), %eax
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x48(%rbp)
movq %rcx, %rsp
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x50c1b
movq -0x48(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movss 0x25485(%rip), %xmm0    # 0x76090
movss %xmm0, (%rax,%rcx,4)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x50bf3
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rsi
movq -0x60(%rbp), %rdi
movl -0x14(%rbp), %ecx
callq 0x70af0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x40(%rbp)
movss -0x40(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x2feee(%rip), %rdi     # 0x80b36
movb $0x1, %al
callq 0x10d0
movss -0x40(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x253a8(%rip), %xmm1    # 0x76008
ucomisd %xmm1, %xmm0
jbe 0x50c87
movss -0x40(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x2fee3(%rip), %rdi     # 0x80b59
movb $0x1, %al
callq 0x10d0
movl $0x8, %edi
callq 0x1210
movss -0x40(%rbp), %xmm0
movq -0x20(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/simulation.c
// Function: Check_nan_f
int Check_nan_f(float *x, int N, char *name){
  float *y=x;
  for(int i=0; i<N; i++){
    if(isnan(*y)){
      printf("ERROR, variable %s i= %d over %d is nan\n", name, i, N);
      printf("Reference atom: %d over %d\n", i/3, N/3);
      return(1);
    }
    y++;
  }
  return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5391e
movq -0x28(%rbp), %rax
movss (%rax), %xmm0
ucomiss %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x538be
jmp 0x53907
movq -0x20(%rbp), %rsi
movl -0x2c(%rbp), %edx
movl -0x14(%rbp), %ecx
leaq 0x2d874(%rip), %rdi     # 0x81143
movb $0x0, %al
callq 0x10d0
movl -0x2c(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %eax, %esi
movl -0x14(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %eax, %edx
leaq 0x2d875(%rip), %rdi     # 0x8116c
movb $0x0, %al
callq 0x10d0
movl $0x1, -0x4(%rbp)
jmp 0x53925
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x538a2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/simulation.c
// Function: Compute_RMSD
float Compute_RMSD(float f, float *Diff_Tors, int naxes,
		   struct bond *bonds_ini, struct bond *bonds, int natoms1,
		   struct Reference Ref1, float *coord_ref_2)
{
  double diff_tors[naxes];
  for(int i=0; i<naxes; i++)diff_tors[i]=f*Diff_Tors[i];
  Copy_bonds(bonds, bonds_ini, natoms1);
  Build_up(bonds, natoms1, diff_tors, naxes);
  float coord_all[3*natoms1];
  Put_coord(coord_all, bonds, natoms1);
  float coord_new[Ref1.N_Cart];
  Write_ref_coord(coord_new, Ref1.N_ref, coord_all, Ref1.atom_num);
  float RMSD=
    rmsd_mclachlan_f(coord_ref_2, coord_new, Ref1.mass_atom, Ref1.N_ref);
  return(RMSD);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movss %xmm0, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
movl -0x14(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x40(%rbp)
leaq 0xf(,%rax,8), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x70(%rbp)
movq %rcx, %rsp
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x53ed3
movq -0x70(%rbp), %rax
movss -0x4(%rbp), %xmm0
movq -0x10(%rbp), %rcx
movslq -0x4c(%rbp), %rdx
mulss (%rcx,%rdx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movslq -0x4c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x53e9d
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x4adb0
movq -0x70(%rbp), %rdx
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x14(%rbp), %ecx
callq 0x1c4f0
movl -0x2c(%rbp), %ecx
movl %ecx, %eax
leal (%rax,%rax,2), %eax
leaq 0xf(,%rax,4), %rcx
andq $-0x10, %rcx
movq %rsp, %rdi
subq %rcx, %rdi
movq %rdi, -0x88(%rbp)
movq %rdi, %rsp
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x49770
movq -0x88(%rbp), %rdx
movq -0x78(%rbp), %rax
movl 0x4(%rax), %ecx
leaq 0xf(,%rcx,4), %rsi
andq $-0x10, %rsi
movq %rsp, %rdi
subq %rsi, %rdi
movq %rdi, -0x80(%rbp)
movq %rdi, %rsp
movq %rcx, -0x60(%rbp)
movl (%rax), %esi
movq 0x28(%rax), %rcx
callq 0x4a1d0
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rsi
movq -0x38(%rbp), %rdi
movq 0x10(%rax), %rdx
movl (%rax), %ecx
callq 0x70af0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x64(%rbp)
movss -0x64(%rbp), %xmm0
movq -0x40(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/force2confchange.c
// Function: Find_atom_seq
atom *
Find_atom_seq(struct residue *seq, int nres, atom atom1)
{
  struct residue *seq_i=seq+atom1.res;
  if(seq_i->amm != atom1.aa){
    printf("ERROR, wrong residue type\n"); return(NULL);
  }
  atom *atom=seq_i->atom_ptr; int i;
  for(i=0; i<seq_i->n_atom; i++){
    if(strncmp(atom->name, atom1.name, 3)==0)return(atom);
    atom++;
  }
  return(NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq 0x64(%rcx), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl 0x13(%rax), %eax
movsbl 0x68(%rcx), %ecx
cmpl %ecx, %eax
je 0x54682
leaq 0x2cc79(%rip), %rdi     # 0x812ea
movb $0x0, %al
callq 0x10d0
movq $0x0, -0x8(%rbp)
jmp 0x546e8
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x546e0
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
addq $0x18, %rsi
movl $0x3, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x546c9
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x546e8
movq -0x28(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x54694
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/force2confchange.c
// Function: Read_force
int Read_force(float *Force_input_cart, atom *atoms1,
	       int *atom_num1, int N_ref, char *FILE_FORCE)
{
  FILE *file_in=fopen(FILE_FORCE, "r");
  int iref=0, res; float f1, f2, f3;
  char name[20], aa1[5], string[1000];
  if(file_in==NULL){
    printf("ERROR, I could not find file with input force %s\n",
	   FILE_FORCE); return(-1);
  }
  while(fgets(string, sizeof(string), file_in)!=NULL){
    sscanf(string, "%s%s%d%f%f%f", name, aa1, &res, &f1, &f2, &f3);
    if(Find_atom_seq1(&iref, name, aa1, res, atoms1,atom_num1, N_ref)<0){
      printf("ERROR, reference number not found for %s", string);
      return(-1);
    }
    Force_input_cart[3*iref]=f1;
    Force_input_cart[3*iref+1]=f2;
    Force_input_cart[3*iref+2]=f3;
  }
  return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp            # imm = 0x460
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x2ddb4(%rip), %rsi     # 0x824dd
callq 0x11b0
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x5475e
movq -0x30(%rbp), %rsi
leaq 0x2cb37(%rip), %rdi     # 0x81282
movb $0x0, %al
callq 0x10d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5484b
jmp 0x54760
leaq -0x450(%rbp), %rdi
movq -0x38(%rbp), %rdx
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x1130
cmpq $0x0, %rax
je 0x54844
leaq -0x450(%rbp), %rdi
leaq -0x60(%rbp), %rdx
leaq -0x65(%rbp), %rcx
leaq 0x2cb1f(%rip), %rsi     # 0x812b4
leaq -0x40(%rbp), %r8
leaq -0x44(%rbp), %r9
leaq -0x48(%rbp), %r10
leaq -0x4c(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x11a0
leaq -0x60(%rbp), %rsi
leaq -0x65(%rbp), %rdx
movl -0x40(%rbp), %ecx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
movl -0x24(%rbp), %eax
leaq -0x3c(%rbp), %rdi
movl %eax, (%rsp)
callq 0x54860
cmpl $0x0, %eax
jge 0x547fa
leaq -0x450(%rbp), %rsi
leaq 0x2cad7(%rip), %rdi     # 0x812c1
movb $0x0, %al
callq 0x10d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5484b
movss -0x44(%rbp), %xmm0
movq -0x10(%rbp), %rax
imull $0x3, -0x3c(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0x48(%rbp), %xmm0
movq -0x10(%rbp), %rax
imull $0x3, -0x3c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0x4c(%rbp), %xmm0
movq -0x10(%rbp), %rax
imull $0x3, -0x3c(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
jmp 0x54760
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x460, %rsp            # imm = 0x460
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/mutation.c
// Function: Mainchain
int Mainchain(char *atom_name){
  if(strncmp(atom_name,"N ",2)==0)return(1);
  if(strncmp(atom_name,"CA",2)==0)return(1);
  if(strncmp(atom_name,"C ",2)==0)return(1);
  if(strncmp(atom_name,"O ",2)==0)return(1);
  return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x20e86(%rip), %rsi     # 0x7b02d
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x5a1bf
movl $0x1, -0x4(%rbp)
jmp 0x5a22f
movq -0x10(%rbp), %rdi
leaq 0x1c13e(%rip), %rsi     # 0x76308
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x5a1e2
movl $0x1, -0x4(%rbp)
jmp 0x5a22f
movq -0x10(%rbp), %rdi
leaq 0x20e43(%rip), %rsi     # 0x7b030
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x5a205
movl $0x1, -0x4(%rbp)
jmp 0x5a22f
movq -0x10(%rbp), %rdi
leaq 0x20e23(%rip), %rsi     # 0x7b033
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x5a228
movl $0x1, -0x4(%rbp)
jmp 0x5a22f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/mutation.c
// Function: Convert_to_tors
float *Convert_to_tors(float *Cart, int N3, float **J_ar, int N_axes)
{
  // Torsional force = J^t f = sum_i dr_i/dphi_a f_i
  float *Tors=malloc(N_axes*sizeof(float)); int a, i;
  for(a=0; a<N_axes; a++){
    double sum=0; float *J=J_ar[a], *f=Cart;
    for(i=0; i<N3; i++){sum+=(*J)*(*f); J++; f++;}
    Tors[a]=sum;
  }
  return(Tors);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movslq -0x1c(%rbp), %rdi
shlq $0x2, %rdi
callq 0x1180
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x5a30e
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5a2ea
movq -0x40(%rbp), %rax
movss (%rax), %xmm0
movq -0x48(%rbp), %rax
mulss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x40(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x48(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x5a2a1
movsd -0x38(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5a26e
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/mutation.c
// Function: Cosine
float Cosine(float *scale, float *xx, float *yy, int n)
{
  double sum_xy=0, sum_x2=0, sum_y2=0;
  float *x=xx, *y=yy;
  for(int i=0; i<n; i++){
    sum_xy+=(*x)*(*y);
    sum_x2+=(*x)*(*x);
    sum_y2+=(*y)*(*y);
    x++; y++;
  }
  if(sum_x2){
    *scale=sqrt(sum_y2/sum_x2);
    return(sum_xy/sqrt(sum_x2*sum_y2));
  }else{
    *scale=0;
    return(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x5a3f2
movq -0x48(%rbp), %rax
movss (%rax), %xmm0
movq -0x50(%rbp), %rax
mulss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x48(%rbp), %rax
movss (%rax), %xmm0
movq -0x48(%rbp), %rax
mulss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x50(%rbp), %rax
movss (%rax), %xmm0
movq -0x50(%rbp), %rax
mulss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x48(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x50(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x5a366
movsd -0x38(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x5a404
jp 0x5a404
jmp 0x5a44f
movsd -0x40(%rbp), %xmm0
divsd -0x38(%rbp), %xmm0
callq 0x1220
cvtsd2ss %xmm0, %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x38(%rbp), %xmm0
mulsd -0x40(%rbp), %xmm0
callq 0x1220
movaps %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x5a462
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/mutation.c
// Function: Extract_reference_atoms
int Extract_reference_atoms(int *resatom, atom *atoms, int natoms,
			    struct residue *seq, int Nres)
{
  char SEL[4]="CA"; if(strcmp(REF_CC, "CB")==0)strcpy(SEL, "CB");
  int Na=0; 
  // resatom[i]= Reference atom for residue i
  // Center of mass and inertia tensor

  for(int i=0; i<natoms; i++){
    atom *atm=atoms+i;
    if((strncmp(atm->name, SEL, 2)!=0)&&
       ((seq[atm->res].amm!='G')||(strncmp(atm->name, "CA", 2)!=0)))continue;
    resatom[Na]=i; Na++;
  }
  if(Na!=Nres)printf("WARNING, %d residues expected, %d found\n", Nres, Na);
  if(Na > Nres){printf("Leaving\n"); return(0);}
  return(Na);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl 0x19c4b(%rip), %eax     # 0x760bc
movl %eax, -0x30(%rbp)
leaq 0x309d9(%rip), %rdi     # 0x8ce54
leaq 0x19ec7(%rip), %rsi     # 0x76349
callq 0x1140
cmpl $0x0, %eax
jne 0x5c49c
leaq -0x30(%rbp), %rdi
leaq 0x19eb2(%rip), %rsi     # 0x76349
callq 0x1060
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x5c545
movq -0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
leaq -0x30(%rbp), %rsi
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
je 0x5c520
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movslq 0x64(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsbl 0x13(%rax), %eax
cmpl $0x47, %eax
jne 0x5c51e
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
leaq 0x19df9(%rip), %rsi     # 0x76308
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
je 0x5c520
jmp 0x5c537
movl -0x38(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x5c4aa
movl -0x34(%rbp), %eax
cmpl -0x2c(%rbp), %eax
je 0x5c561
movl -0x2c(%rbp), %esi
movl -0x34(%rbp), %edx
leaq 0x24e5a(%rip), %rdi     # 0x813b4
movb $0x0, %al
callq 0x10d0
movl -0x34(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jle 0x5c580
leaq 0x24e6d(%rip), %rdi     # 0x813dd
movb $0x0, %al
callq 0x10d0
movl $0x0, -0x4(%rbp)
jmp 0x5c586
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/optimization.c
// Function: Rearrange_points
void Rearrange_points(float *x1, float *x2, float *x3,
		      float *y1, float *y2, float *y3,
		      float x0, float y0)
{
  if(y0<*y1){
    *x3=*x2; *y3=*y2;
    *x2=*x1; *y2=*y1;
    *x1=x0;  *y1=y0;
  }else if(y0<*y2){
    *x3=*x2; *y3=*y2;
    *x2=x0;  *y2=y0;
  }else if(y0<*y3){
    *x1=*x2; *y1=*y2;
    *x2=x0; *y2=y0;
  }else{
    *x1=*x2; *y1=*y2;
    *x2=*x3; *y2=*y3;
    *x3=x0;  *y3=y0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movss %xmm0, -0x34(%rbp)
movss %xmm1, -0x38(%rbp)
movss -0x38(%rbp), %xmm1
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x5d1a7
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movq -0x28(%rbp), %rax
movss (%rax), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, (%rax)
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, (%rax)
movss -0x34(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
movss -0x38(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
jmp 0x5d2a4
movss -0x38(%rbp), %xmm1
movq -0x28(%rbp), %rax
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x5d1f8
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movq -0x28(%rbp), %rax
movss (%rax), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, (%rax)
movss -0x34(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movss -0x38(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, (%rax)
jmp 0x5d2a2
movss -0x38(%rbp), %xmm1
movq -0x30(%rbp), %rax
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x5d246
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
movq -0x28(%rbp), %rax
movss (%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
movss -0x34(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movss -0x38(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, (%rax)
jmp 0x5d2a0
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
movq -0x28(%rbp), %rax
movss (%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movq -0x30(%rbp), %rax
movss (%rax), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, (%rax)
movss -0x34(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movss -0x38(%rbp), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, (%rax)
jmp 0x5d2a2
jmp 0x5d2a4
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/output_tnm.c
// Function: Check_make_dir
int Check_make_dir(char *outdir){
  char name_out[1000]; FILE *file_out;
  if(outdir[0]=='\0')return(0);
  sprintf(name_out, "%s/%s", outdir, "tmp");
  file_out=fopen(name_out, "w");
  if(file_out!=NULL){fclose(file_out); return(1);}
  sprintf(name_out, "mkdir -p %s\n", outdir);
  if(system(name_out)==0)return(1);
  return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x5e147
movl $0x0, -0x4(%rbp)
jmp 0x5e1da
leaq -0x400(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x24101(%rip), %rsi     # 0x8225a
leaq 0x24100(%rip), %rcx     # 0x82260
movb $0x0, %al
callq 0x1200
leaq -0x400(%rbp), %rdi
leaq 0x1e1fd(%rip), %rsi     # 0x7c372
callq 0x11b0
movq %rax, -0x408(%rbp)
cmpq $0x0, -0x408(%rbp)
je 0x5e1a0
movq -0x408(%rbp), %rdi
callq 0x10a0
movl $0x1, -0x4(%rbp)
jmp 0x5e1da
leaq -0x400(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x240b2(%rip), %rsi     # 0x82264
movb $0x0, %al
callq 0x1200
leaq -0x400(%rbp), %rdi
callq 0x10c0
cmpl $0x0, %eax
jne 0x5e1d3
movl $0x1, -0x4(%rbp)
jmp 0x5e1da
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/output_tnm.c
// Function: Print_cart_fluct
void Print_cart_fluct(int *atom_num, int N_atom, float *fluct,
		      atom *atoms, struct residue *seq,
		      char *name, char *type)
{
  float MAX_B=50.0;
  int i, ia=0, n=1;
  FILE *file_out=fopen(name, "w");
  printf("Writing %s\n", name);
  fprintf(file_out, "REMARK %d B_factor = %s\n",n, type);

  { // Normalize such that max_fluctuation = MAX_B
    float max_f=0, norm;
    for(i=0; i<N_atom; i++)if(fluct[i]>max_f)max_f=fluct[i];
    norm=MAX_B/max_f; for(i=0; i<N_atom; i++)fluct[i]*=norm;
  }
  for(i=0; i<N_atom; i++){
    Print_atom(atoms+atom_num[i], &ia, fluct[i], seq, file_out);
  }
  fprintf(file_out, "TER\n");
  fclose(file_out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movss 0x23e91(%rip), %xmm0    # 0x820ac
movss %xmm0, -0x34(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0x1, -0x40(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x1e139(%rip), %rsi     # 0x7c372
callq 0x11b0
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rsi
leaq 0x192a1(%rip), %rdi     # 0x774ee
movb $0x0, %al
callq 0x10d0
movq -0x48(%rbp), %rdi
movl -0x40(%rbp), %edx
movq 0x10(%rbp), %rcx
leaq 0x2400b(%rip), %rsi     # 0x82271
movb $0x0, %al
callq 0x1150
xorps %xmm0, %xmm0
movss %xmm0, -0x4c(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5e2b6
movq -0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss -0x4c(%rbp), %xmm0
jbe 0x5e2a9
movq -0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x4c(%rbp)
jmp 0x5e2ab
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x5e27c
movss -0x34(%rbp), %xmm0
divss -0x4c(%rbp), %xmm0
movss %xmm0, -0x50(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5e2f6
movss -0x50(%rbp), %xmm0
movq -0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
mulss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x5e2cc
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5e345
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
imulq $0x70, %rax, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x28(%rbp), %rdx
movq -0x48(%rbp), %rcx
leaq -0x3c(%rbp), %rsi
callq 0x5e370
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x5e2fd
movq -0x48(%rbp), %rdi
leaq 0x23f3a(%rip), %rsi     # 0x8228a
movb $0x0, %al
callq 0x1150
movq -0x48(%rbp), %rdi
callq 0x10a0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/output_tnm.c
// Function: Print_atom
void Print_atom(atom *atom, int *num, float B, struct residue *seq,
		FILE *file_out)
{
  struct residue *s=seq+atom->res;
  char aaname3[4]; Name3(aaname3, s->i_aa);
  (*num)++; int jatom=*num; if(jatom>99999)jatom=99999;
  fprintf(file_out,
	  "ATOM  %5d  %4s%3s %c%4d   %8.3f%8.3f%8.3f%6.2f%6.2f\n",
	  jatom, atom->name, aaname3, 'A', atom->res+1,
	  atom->r[0], atom->r[1], atom->r[2], 1.0, B);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x64(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
leaq -0x34(%rbp), %rdi
movq -0x30(%rbp), %rax
movswl 0x14(%rax), %esi
callq 0x37330
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x38(%rbp)
cmpl $0x1869f, -0x38(%rbp)   # imm = 0x1869F
jle 0x5e3d9
movl $0x1869f, -0x38(%rbp)   # imm = 0x1869F
movq -0x28(%rbp), %rdi
movl -0x38(%rbp), %edx
movq -0x8(%rbp), %rcx
addq $0x18, %rcx
leaq -0x34(%rbp), %r8
movq -0x8(%rbp), %rax
movl 0x64(%rax), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rsi
movsd (%rsi), %xmm0
movq -0x8(%rbp), %rsi
movsd 0x8(%rsi), %xmm1
movq -0x8(%rbp), %rsi
movsd 0x10(%rsi), %xmm2
movss -0x14(%rbp), %xmm3
cvtss2sd %xmm3, %xmm4
leaq 0x23f09(%rip), %rsi     # 0x82329
movl $0x41, %r9d
movsd 0x17c1a(%rip), %xmm3    # 0x76048
movl %eax, (%rsp)
movb $0x5, %al
callq 0x1150
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/output_tnm.c
// Function: Print_change
int Print_change(float *Fluct_pred, float *Fluct_obs, int N,
		char *nameout, char *what)
{
  char namefile[200]; FILE *file_out; int i;
  sprintf(namefile, "%s_%s_dev.dat", nameout, what);
  file_out=fopen(namefile, "w");
  printf("Writing %s\n", namefile);

  fprintf(file_out, "# Squared deviation\n# Pred Obs\n");
  for(i=0; i<N; i++)
    fprintf(file_out, "%.4f %.4f\n", Fluct_pred[i], Fluct_obs[i]);
  fclose(file_out);
  return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0xf0(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0x235ca(%rip), %rsi     # 0x8235e
movb $0x0, %al
callq 0x1200
leaq -0xf0(%rbp), %rdi
leaq 0x1d5c9(%rip), %rsi     # 0x7c372
callq 0x11b0
movq %rax, -0xf8(%rbp)
leaq -0xf0(%rbp), %rsi
leaq 0x1872b(%rip), %rdi     # 0x774ee
movb $0x0, %al
callq 0x10d0
movq -0xf8(%rbp), %rdi
leaq 0x23594(%rip), %rsi     # 0x8236c
movb $0x0, %al
callq 0x1150
movl $0x0, -0xfc(%rbp)
movl -0xfc(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5ee42
movq -0xf8(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0xfc(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x10(%rbp), %rax
movslq -0xfc(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
cvtss2sd %xmm1, %xmm1
leaq 0x23562(%rip), %rsi     # 0x8238c
movb $0x2, %al
callq 0x1150
movl -0xfc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xfc(%rbp)
jmp 0x5ede9
movq -0xf8(%rbp), %rdi
callq 0x10a0
xorl %eax, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopl (%rax)