LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/net.cc
// Function: rotate(MOLECULE, double (*) [3])
MOLECULE rotate(MOLECULE orig, double mat[3][3]) {
  MOLECULE rot = orig;
  int num_atom = orig.atoms_xyz.size();
  for(int i=0; i<num_atom+1; i++) {
    XYZ o;
    if(i<num_atom) o = orig.atoms_xyz.at(i); else o = orig.com; //handle the centre of mass too!
    XYZ n(
mat[0][0]*o.x + mat[0][1]*o.y + mat[0][2]*o.z,
mat[1][0]*o.x + mat[1][1]*o.y + mat[1][2]*o.z,
mat[2][0]*o.x + mat[2][1]*o.y + mat[2][2]*o.z);
    if(i<num_atom) rot.atoms_xyz.at(i) = n; else rot.com = n; //handle the centre of mass too!
  }
  return rot;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x4ba0a
movq 0x8(%r15), %rax
subq (%r15), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movl $0x90, %ebx
leaq (%r15,%rbx), %r13
movq %r12, 0x8(%rsp)
addq %r12, %rbx
movslq %eax, %rbp
xorl %r12d, %r12d
cmpq %rbp, %r12
jg 0x75f36
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
leaq 0x10(%rsp), %rdi
callq 0x6402e
movq %r13, %rax
cmpq %rbp, %r12
jge 0x75e76
movq %r15, %rdi
movq %r12, %rsi
callq 0x4b6d6
movq 0x10(%rax), %rcx
movq %rcx, 0x20(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm3
movsd 0x18(%rsp), %xmm4
movsd 0x8(%r14), %xmm0
mulsd %xmm4, %xmm0
movsd (%r14), %xmm1
mulsd %xmm3, %xmm1
addsd %xmm0, %xmm1
movsd 0x20(%rsp), %xmm2
movsd 0x10(%r14), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x20(%r14), %xmm1
mulsd %xmm4, %xmm1
movsd 0x18(%r14), %xmm5
mulsd %xmm3, %xmm5
addsd %xmm1, %xmm5
movsd 0x28(%r14), %xmm1
mulsd %xmm2, %xmm1
addsd %xmm5, %xmm1
mulsd 0x38(%r14), %xmm4
mulsd 0x30(%r14), %xmm3
addsd %xmm4, %xmm3
mulsd 0x40(%r14), %xmm2
addsd %xmm3, %xmm2
leaq 0x30(%rsp), %rdi
callq 0x6402e
movq %rbx, %rax
cmpq %rbp, %r12
jge 0x75f1d
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x4b6d6
movq 0x40(%rsp), %rcx
movq %rcx, 0x10(%rax)
movups 0x30(%rsp), %xmm0
movups %xmm0, (%rax)
incq %r12
jmp 0x75e44
movq 0x8(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x75f4c
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x4bb60
movq %r14, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/net.cc
// Function: get_mol_site_CoM(MOLECULE*)
XYZ get_mol_site_CoM(MOLECULE *mol) {
  int num_mol_sites_no_dummy = mol->sites.size();
  XYZ mol_CoM(0,0,0);
  for(int i=0; i<num_mol_sites_no_dummy; i++) {
    mol_CoM = mol_CoM+mol->atoms_xyz.at(mol->sites.at(i));
  }
  mol_CoM = mol_CoM.scale(1.0/num_mol_sites_no_dummy);
  return mol_CoM;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsi), %r15
movq 0x50(%rsi), %r13
subq 0x48(%rsi), %r13
shrq $0x2, %r13
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0x6402e
xorl %r12d, %r12d
testl %r13d, %r13d
movl $0x0, %ebp
movq %r13, 0x8(%rsp)
cmovgl %r13d, %ebp
leaq 0x10(%rsp), %r13
cmpq %r12, %rbp
je 0x75feb
movq %r15, %rdi
movq %r12, %rsi
callq 0xac00
movslq (%rax), %rsi
movq %r14, %rdi
callq 0x4b6d6
movq %r13, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x642d2
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x10(%rsp), %xmm0
movups %xmm0, (%rbx)
incq %r12
jmp 0x75fac
cvtsi2sdl 0x8(%rsp), %xmm1
movsd 0x8605f(%rip), %xmm0    # 0xfc058
divsd %xmm1, %xmm0
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x640ba
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/net.cc
// Function: matches(CONNECTION, CONNECTION)
bool matches(CONNECTION ci, CONNECTION cj) {
  bool match = false;
  if(ci.v1==cj.v2 && ci.v2==cj.v1) {
    if(ci.a+cj.a==0 && ci.b+cj.b==0 && ci.c+cj.c==0) match=true;
  }
  return match;
}

// Assembly:
movl 0x8(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jne 0x76063
leaq 0x28(%rsp), %rax
leaq 0x8(%rsp), %rcx
movl 0x4(%rcx), %edx
cmpl (%rax), %edx
jne 0x76063
movl 0x10(%rcx), %edx
addl 0x10(%rax), %edx
jne 0x76063
movl 0x14(%rcx), %edx
addl 0x14(%rax), %edx
jne 0x76063
movl 0x18(%rcx), %ecx
addl 0x18(%rax), %ecx
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/net.cc
// Function: translate(MOLECULE, XYZ)
MOLECULE translate(MOLECULE m, XYZ t) {
  MOLECULE new_m = m;
  int num_atoms = m.atoms_xyz.size();
  for(int i=0; i<num_atoms; i++) {
    XYZ new_pos = m.atoms_xyz.at(i)+t;
    new_m.atoms_xyz.at(i) = new_pos;
  }
  XYZ new_com = m.com+t;
  new_m.com = new_com;
  return new_m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %r15
callq 0x4ba0a
movq 0x8(%r14), %rax
subq (%r14), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movq %rax, %r12
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
movq %rsp, %rbp
cmpq %r13, %r12
je 0x761b3
movq %r14, %rdi
movq %r13, %rsi
callq 0x4b6d6
movq %rbp, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x642d2
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4b6d6
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movups (%rsp), %xmm0
movups %xmm0, (%rax)
incq %r13
jmp 0x76175
addq $0x90, %r14
movq %rsp, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x642d2
movq 0x10(%rsp), %rax
movq %rax, 0xa0(%rbx)
movups (%rsp), %xmm0
movups %xmm0, 0x90(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x761f3
movq %rax, %r14
movq %rbx, %rdi
callq 0x4bb60
movq %r14, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/net.cc
// Function: permute(std::vector<int, std::allocator<int>>, int, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>*)
void permute(vector<int> vec, int pos, vector< vector<int> > *out_vec) {
  if (pos == vec.size()) out_vec->push_back(vec);
  else {
    for (int j = pos; j < vec.size(); j++) {
      swap(&vec, pos, j);
      permute(vec, pos+1, out_vec);
      swap(&vec, pos, j); //backtrack
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movslq %esi, %r12
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
movq %rax, %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %r12, %rdx
jne 0x7624c
movq %rbx, %rdi
movq %r14, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xad52
movl %esi, %r15d
leal 0x1(%r15), %ebp
movq %rsp, %r13
subq %rcx, %rax
sarq $0x2, %rax
cmpq %r12, %rax
jbe 0x762aa
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0x762cc
movq %r13, %rdi
movq %r14, %rsi
callq 0xa6ce
movq %r13, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x76206
movq %r13, %rdi
callq 0xb290
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0x762cc
incq %r12
movq (%r14), %rcx
movq 0x8(%r14), %rax
jmp 0x76256
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xb290
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/net.cc
// Function: get_com(MOLECULE*)
void get_com(MOLECULE *m) {
  bool verbose = false;
  int num_sites = m->sites.size();
  XYZ com(0,0,0);
  for(int i=0; i<num_sites; i++) {
    int site_index = m->sites.at(i);
    //update centre of mass accordingly
    com = com + m->atoms_xyz.at(site_index);
  }
  //finalise centre of mass by normalising it
  com = com.scale(1.0/((double)num_sites));
  m->com = com;
  if(verbose) printf("DEBUG: centre of mass of this molecule is at %.3f %.3f %.3f\n", com.x, com.y, com.z);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
movq 0x50(%rdi), %r13
subq 0x48(%rdi), %r13
shrq $0x2, %r13
leaq 0x10(%rsp), %r15
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r15, %rdi
callq 0x6402e
xorl %r12d, %r12d
testl %r13d, %r13d
movl $0x0, %ebp
movq %r13, 0x8(%rsp)
cmovgl %r13d, %ebp
leaq 0x30(%rsp), %r13
cmpq %r12, %rbp
je 0x76a66
movq %r14, %rdi
movq %r12, %rsi
callq 0xac00
movslq (%rax), %rsi
movq %rbx, %rdi
callq 0x4b6d6
movq %r13, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x642d2
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0x30(%rsp), %xmm0
movaps %xmm0, 0x10(%rsp)
incq %r12
jmp 0x76a24
cvtsi2sdl 0x8(%rsp), %xmm1
movsd 0x855e4(%rip), %xmm0    # 0xfc058
divsd %xmm1, %xmm0
leaq 0x30(%rsp), %r14
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x640ba
movq 0x10(%r14), %rax
movq %rax, 0x10(%r15)
movups (%r14), %xmm0
movaps %xmm0, (%r15)
movq %rax, 0xa0(%rbx)
movups %xmm0, 0x90(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/net.cc
// Function: recursive_visit_vertices(int, std::vector<CONNECTION, std::allocator<CONNECTION>>*, std::vector<bool, std::allocator<bool>>*)
void recursive_visit_vertices(int this_v, vector<CONNECTION> *two_way_connections, vector<bool> *visited_vertex) {
  visited_vertex->at(this_v) = true;
  int num_c = two_way_connections->size();
  for(int i=0; i<num_c; i++) {
    CONNECTION c = two_way_connections->at(i);
    if(c.v1==this_v && !visited_vertex->at(c.v2)) recursive_visit_vertices(c.v2, two_way_connections, visited_vertex);
    if(c.v2==this_v && !visited_vertex->at(c.v1)) recursive_visit_vertices(c.v1, two_way_connections, visited_vertex);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movslq %edi, %rsi
movq %rdx, %rdi
callq 0xaba4
orq %rdx, (%rax)
movq 0x8(%r14), %rax
subq (%r14), %rax
pushq $0x1c
popq %rcx
cqto
idivq %rcx
xorl %r12d, %r12d
testl %eax, %eax
cmovlel %r12d, %eax
movq %rax, (%rsp)
cmpq %r12, (%rsp)
je 0x76b5a
movq %r14, %rdi
movq %r12, %rsi
callq 0x4b9ca
movslq (%rax), %r13
movslq 0x4(%rax), %r15
cmpl %ebp, %r13d
jne 0x76b32
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaba4
testq %rdx, (%rax)
jne 0x76b32
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x76aba
cmpl %ebp, %r15d
jne 0x76b55
movq %rbx, %rdi
movq %r13, %rsi
callq 0xaba4
testq %rdx, (%rax)
jne 0x76b55
movl %r13d, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x76aba
incq %r12
jmp 0x76af7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/net.cc
// Function: get_periodic_images_of_uc_abc_position(XYZ)
vector<XYZ> get_periodic_images_of_uc_abc_position(XYZ e_abc) {
  vector<XYZ> periodic_images;
  for(int i=-2; i<=2; i++) {
    for(int j=-2; j<=2; j++) {
      for(int k=-2; k<=2; k++) {
        XYZ image(e_abc.x+i, e_abc.y+j, e_abc.z+k);
        periodic_images.push_back(image);
      }
    }
  }
  return periodic_images;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movsd 0x80(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x88(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
pushq $-0x2
popq %rbp
movsd 0x90(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0x30(%rsp), %r14
movl %ebp, %r15d
cmpl $0x3, %r15d
je 0x78834
cvtsi2sd %r15d, %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movl %ebp, %r12d
cmpl $0x3, %r12d
je 0x7882f
cvtsi2sd %r12d, %xmm0
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movl %ebp, %r13d
cmpl $0x3, %r13d
je 0x7882a
cvtsi2sd %r13d, %xmm2
addsd 0x18(%rsp), %xmm2
movq %r14, %rdi
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
callq 0x6402e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4beaa
incl %r13d
jmp 0x787f5
incl %r12d
jmp 0x787db
incl %r15d
jmp 0x787c1
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xb132
movq %r14, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/net.cc
// Function: write_molecule(_IO_FILE*, MOLECULE*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, bool)
void write_molecule(FILE *rotmol, MOLECULE *rotated, string name, int vertex_ID, int sym_op, bool write_out_sites) {
  bool verbose = false;
  int num_atom = rotated->atoms_xyz.size();
  int num_atom_to_write = num_atom;
  int num_sites = rotated->sites.size();
  if(!write_out_sites) num_atom_to_write-=num_sites;
  fprintf(rotmol, "%d\n%s", num_atom_to_write, name.c_str());
  if(vertex_ID==-1 && sym_op==-1) { //obviously not a symmetry operation ...
    fprintf(rotmol,"\n");
  } else {
    fprintf(rotmol," - molecule rotated to align with basic vertex ID %d and symmetry operator %d\n", vertex_ID, sym_op);
  }
  for(int i=0; i<num_atom; i++) {
    bool write_this_one = true;
    if(!write_out_sites) {
      for(int j=0; j<num_sites && write_this_one; j++) {
        if(i==rotated->sites.at(j)) write_this_one = false;
      }
    }
    if(write_this_one) {
      fprintf(rotmol, "%s %.3f %.3f %.3f\n", rotated->atoms_type.at(i).c_str(), rotated->atoms_xyz.at(i).x, rotated->atoms_xyz.at(i).y, rotated->atoms_xyz.at(i).z);
    } else {
if(verbose) printf("DEBUG: not writing atom ID %d (%s) because it is a site\n", i, rotated->atoms_type.at(i).c_str());
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movl %ecx, %r15d
movq %rdx, %rcx
movq %rsi, %r14
movq %rdi, %r13
movq 0x8(%rsi), %rax
movq 0x50(%rsi), %rbx
subq (%rsi), %rax
pushq $0x18
popq %rsi
cqto
idivq %rsi
movq %rax, %r12
subq 0x48(%r14), %rbx
shrq $0x2, %rbx
xorl %eax, %eax
movl %r9d, 0x4(%rsp)
testl %r9d, %r9d
movl %ebx, %esi
cmovnel %eax, %esi
movl %r12d, %edx
subl %esi, %edx
movq (%rcx), %rcx
leaq 0x8a434(%rip), %rsi     # 0x102ce6
xorl %eax, %eax
callq 0x4610
movl %ebp, %eax
andl %r15d, %eax
cmpl $-0x1, %eax
movq %r13, 0x10(%rsp)
je 0x788e0
leaq 0x8cca1(%rip), %rsi     # 0x105570
movq %r13, %rdi
movl %r15d, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x4610
jmp 0x788eb
pushq $0xa
popq %rdi
movq %r13, %rsi
callq 0x4570
leaq 0x48(%r14), %r13
leaq 0x18(%r14), %rax
movq %rax, 0x8(%rsp)
movslq %ebx, %rbp
xorl %r15d, %r15d
testl %r12d, %r12d
cmovlel %r15d, %r12d
cmpq %r12, %r15
je 0x789b3
cmpb $0x0, 0x4(%rsp)
jne 0x7893e
movb $0x1, %al
xorl %ebx, %ebx
cmpq %rbp, %rbx
jge 0x7893a
testb $0x1, %al
je 0x7893a
movq %r13, %rdi
movq %rbx, %rsi
callq 0xac00
movl (%rax), %eax
cmpq %rax, %r15
setne %al
incq %rbx
jmp 0x78919
testb $0x1, %al
je 0x789ab
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x4bb9a
movq (%rax), %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4b6d6
movsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4b6d6
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4b6d6
movsd 0x10(%rax), %xmm2
movq 0x10(%rsp), %rdi
leaq 0x885a3(%rip), %rsi     # 0x100f38
movq %rbx, %rdx
movsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movb $0x3, %al
callq 0x4610
incq %r15
jmp 0x78905
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/net.cc
// Function: search_for_char(_IO_FILE*, char)
void search_for_char(FILE *f, char target) {
	char c = getc(f);
//printf("DEBUG: found %c with int value %d\n", c, (int)c);
	while(c!=target && c!=EOF) {
		c = getc(f);
//printf("DEBUG: found %c with int value %d\n", c, (int)c);
	}
	if(c==EOF) {
		printf("ERROR: The required character (%c, with int value %d) was not found in this file.\n", target, (int)target);
		exit(EXIT_FAILURE);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x41a0
movl %eax, %ecx
shll $0x18, %ecx
cmpl $0xff000000, %ecx       # imm = 0xFF000000
je 0x78a40
movsbl %al, %eax
cmpl %ebx, %eax
je 0x78a40
movq %r14, %rdi
jmp 0x78a22
cmpl $0xff000000, %ecx       # imm = 0xFF000000
je 0x78a50
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x8cb68(%rip), %rdi     # 0x1055bf
movl %ebx, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x4050
pushq $0x1
popq %rdi
callq 0x524c
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/rmsd.cc
// Function: normalize(double*)
void normalize(double a[3])
{
  double  b;

  b = sqrt((double)(a[0]*a[0] + a[1]*a[1] + a[2]*a[2]));
  a[0] /= b;
  a[1] /= b;
  a[2] /= b;
}

// Assembly:
movsd 0x10(%rdi), %xmm0
movupd (%rdi), %xmm1
movapd %xmm1, %xmm2
mulpd %xmm1, %xmm2
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
movapd %xmm1, %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
addsd %xmm3, %xmm2
sqrtsd %xmm2, %xmm2
divsd %xmm2, %xmm0
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
divpd %xmm2, %xmm1
movupd %xmm1, (%rdi)
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/rmsd.cc
// Function: diagonalize_symmetric(double (*) [3], double (*) [3], double*)
int diagonalize_symmetric(double matrix[3][3], 
                          double eigen_vec[3][3], 
                          double eigenval[3])
{
  int n_rot, i, j, k;
  double vec[3][3];
  double val; 
  
  if (!jacobi3(matrix, eigenval, vec, &n_rot)) 
  {
    printf("convergence failed\n");
    return (0);
  }

  /* sort solutions by eigenval */
  for (i=0; i<3; i++) 
  {
    k = i;
    val = eigenval[i];
    
    for (j=i+1; j<3; j++)
      if (eigenval[j] >= val)
      { 
        k = j;
        val = eigenval[k];
      }
       
    if (k != i) 
    {
      eigenval[k] = eigenval[i];
      eigenval[i] = val;
      for (j=0; j<3; j++) 
      {
        val = vec[j][i];
        vec[j][i] = vec[j][k];
        vec[j][k] = val;
      }
    }
  }

  /* transpose such that first index refers to solution index */
  for (i=0; i<3; i++)
    for (j=0; j<3; j++)
      eigen_vec[i][j] = vec[j][i];

  return (1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %rcx
movq %rdx, %rsi
movq %r15, %rdx
callq 0x78cb2
testl %eax, %eax
je 0x79271
pushq $0x1
popq %rax
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x79237
movsd (%r14,%rcx,8), %xmm0
movq %rax, %rsi
movl %ecx, %edx
movapd %xmm0, %xmm1
cmpq $0x3, %rsi
je 0x791e9
movsd (%r14,%rsi,8), %xmm2
ucomisd %xmm1, %xmm2
cmovael %esi, %edx
movapd %xmm1, %xmm3
cmpnlesd %xmm2, %xmm3
movapd %xmm3, %xmm4
andnpd %xmm2, %xmm4
andpd %xmm1, %xmm3
orpd %xmm4, %xmm3
incq %rsi
movapd %xmm3, %xmm1
jmp 0x791b4
movl %edx, %esi
cmpq %rsi, %rcx
jne 0x791fc
incq %rcx
incq %rax
addq $0x8, %r15
jmp 0x7919b
movslq %edx, %rdx
movsd %xmm0, (%r14,%rdx,8)
movsd %xmm1, (%r14,%rcx,8)
leaq (%rsp,%rdx,8), %rdx
addq $0x10, %rdx
xorl %esi, %esi
cmpq $0x48, %rsi
je 0x791f0
movsd (%r15,%rsi), %xmm0
movsd (%rdx,%rsi), %xmm1
movsd %xmm1, (%r15,%rsi)
movsd %xmm0, (%rdx,%rsi)
addq $0x18, %rsi
jmp 0x79215
leaq 0x10(%rsp), %rcx
xorl %edx, %edx
pushq $0x1
popq %rax
cmpq $0x3, %rdx
je 0x7927f
movq %rcx, %rsi
xorl %edi, %edi
cmpq $0x3, %rdi
je 0x79264
movsd (%rsi), %xmm0
movsd %xmm0, (%rbx,%rdi,8)
incq %rdi
addq $0x18, %rsi
jmp 0x7924c
incq %rdx
addq $0x18, %rbx
addq $0x8, %rcx
jmp 0x79241
leaq 0x8c557(%rip), %rdi     # 0x1057cf
callq 0x4670
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/rmsd.cc
// Function: calculate_rotation_rmsd(double (*) [3], double (*) [3], int, double*, double*, double (*) [3], double*)
void calculate_rotation_rmsd(double ref_xlist[][3],
                             double mov_xlist[][3], 
                             int n_list,
                             double mov_com[3],
                             double mov_to_ref[3],
                             double U[3][3],
                             double* rmsd)
{
  double Eo, residual;
  double R[3][3];
  
  setup_rotation(ref_xlist, mov_xlist, n_list, 
                 mov_com, mov_to_ref, R, &Eo);
  calculate_rotation_matrix(R, U, Eo, &residual);
  
  residual = fabs(residual); /* avoids the awkward case of -0.0 */
  *rmsd = sqrt( fabs((double) (residual)*2.0/((double)n_list)) ); 
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %r9, %r14
movl %edx, %ebx
movq 0xa0(%rsp), %r13
leaq 0x18(%rsp), %r12
movq %r12, (%rsp)
leaq 0x20(%rsp), %r15
movq %r15, %r9
callq 0x78ad8
movsd (%r12), %xmm0
leaq 0x10(%rsp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x79289
movsd (%r12), %xmm0
movapd 0x82a85(%rip), %xmm1    # 0xfc0a0
andpd %xmm1, %xmm0
addsd %xmm0, %xmm0
cvtsi2sd %ebx, %xmm2
divsd %xmm2, %xmm0
andpd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
movsd %xmm0, (%r13)
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/symmetry.cc
// Function: IsUniqueVertex(XYZ*, ATOM_NETWORK&)
bool IsUniqueVertex(XYZ *p, ATOM_NETWORK &cell) {
  double dist;
  for(int v=0; v<cell.vertices.size(); v++) {
//    dist=calcDistanceABC(p->x,p->y,p->z,cell.vertices.at(v).abc.x,cell.vertices.at(v).abc.y,cell.vertices.at(v).abc.z,&cell);
    dist=cell.calcDistanceABC(p->x,p->y,p->z,cell.vertices.at(v).abc.x,cell.vertices.at(v).abc.y,cell.vertices.at(v).abc.z);
    if(dist<DISTANCE_TOLERANCE) return false;
  }
  return true;  
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3c0(%rsi), %r15
xorl %eax, %eax
pushq $0x70
popq %rbp
movq %rax, %r12
movq 0x3c8(%rbx), %rax
subq 0x3c0(%rbx), %rax
cqto
idivq %rbp
movq %rax, %r13
cmpq %r12, %rax
jbe 0x79ccb
movsd (%r14), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%r14), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x10(%r14), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x4b63c
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x4b63c
movsd 0x8(%rax), %xmm0
movsd %xmm0, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x4b63c
movsd 0x10(%rax), %xmm5
movq %rbx, %rdi
movsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movsd 0x8(%rsp), %xmm3
movsd (%rsp), %xmm4
callq 0x3f440
leaq 0x1(%r12), %rax
movsd 0x87a07(%rip), %xmm1    # 0x1016c8
ucomisd %xmm0, %xmm1
jbe 0x79c10
cmpq %r12, %r13
setbe %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/symmetry.cc
// Function: IsEquivalent(XYZ*, std::vector<XYZ, std::allocator<XYZ>>*, ATOM_NETWORK&)
bool IsEquivalent(XYZ *p,vector <XYZ> *EqPos,ATOM_NETWORK &atomNet)
{
//cout << "EqPos vector side " << EqPos->size() << endl;
//cout << endl << endl;
  double dist;
  for(unsigned int pos=0; pos<EqPos->size(); pos++)
    {
    dist=atomNet.calcDistanceABC(p->x,p->y,p->z,EqPos->at(pos).x,EqPos->at(pos).y,EqPos->at(pos).z);
//cout << dist << " ";
    if(dist<TOLERANCE) return true;
    };
return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %eax, %eax
pushq $0x18
popq %rbp
movl %eax, %r12d
movq 0x8(%r14), %rax
subq (%r14), %rax
cqto
idivq %rbp
movq %rax, %r13
cmpq %r12, %rax
jbe 0x79db0
movsd (%r15), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%r15), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x10(%r15), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x4b6d6
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x4b6d6
movsd 0x8(%rax), %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x4b6d6
movsd 0x10(%rax), %xmm5
movq %rbx, %rdi
movsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movsd 0x8(%rsp), %xmm3
movsd (%rsp), %xmm4
callq 0x3f440
leal 0x1(%r12), %eax
movsd 0x8791a(%rip), %xmm1    # 0x1016c0
ucomisd %xmm0, %xmm1
jbe 0x79cfc
cmpq %r12, %r13
seta %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/cycle.cc
// Function: edge_finder(VORONOI_NETWORK const*, int, std::vector<int, std::allocator<int>>*)
void edge_finder(const VORONOI_NETWORK* vornet, int node_index, vector<int>* edge_indices)
{
    typedef vector<VOR_EDGE>::const_iterator VeCit;
    int i = 0;
    VeCit it = vornet->edges.begin();
    for (; it != vornet->edges.end(); ++i, ++it){
        if (it->from == node_index || it->to == node_index) 
            edge_indices->push_back(i);
    }
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq 0xc(%rsp), %r14
andl $0x0, (%r14)
movl %esi, %ebp
movq %rdi, %r15
movq 0x60(%rdi), %r12
xorl %eax, %eax
cmpq 0x68(%r15), %r12
je 0xc1b2f
cmpl %ebp, (%r12)
je 0xc1b14
cmpl %ebp, 0x4(%r12)
jne 0xc1b23
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9434
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
addq $0x28, %r12
jmp 0xc1b01
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/cycle.cc
// Function: compute_4cycle(VORONOI_NETWORK*, std::vector<CYCLE, std::allocator<CYCLE>>*, bool, int)
bool compute_4cycle(VORONOI_NETWORK* vornet, vector<CYCLE> *cycles,
                    bool weight_flag, int weight_range)
{
    //Build graph data structure
    DIJKSTRA_NETWORK dnet;
    DIJKSTRA_NETWORK::buildDijkstraNetwork(vornet, &dnet);
    return compute_4cycle(&dnet, cycles, weight_flag, weight_range);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x3d70e
movq %r14, %rdi
movq %r15, %rsi
callq 0x3d7e6
movq %rsp, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xc1b3c
movl %eax, %ebx
movq %rsp, %rdi
callq 0xae22
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xae22
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/cycle.cc
// Function: centroid(CYCLE const*, XYZ*, std::vector<int, std::allocator<int>>*)
void centroid(const CYCLE* const cycle, XYZ* center, vector<int>* node_ids)
{
    DnCit it = cycle->nodes.begin();
    //cout << "Length of nodes in the cycle: " << cycle->nodes.size() << endl;

    *center = XYZ(0,0,0);
    node_ids->clear();
    //cout << "Length of node_ids vector: " << node_ids->size() << endl;
    for (; it != cycle->nodes.end(); ++it) {
        XYZ new_pt (it->x, it->y, it->z);
        *center = *center + new_pt;
	node_ids->push_back(it->id);
    }
    //cout << "Length of node_ids vector: " << node_ids->size() << endl;

    *center = center->scale(1.0/cycle->length);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
leaq 0x20(%rsp), %r13
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r13, %rdi
callq 0x6402e
movq 0x10(%r13), %rax
movq %rax, 0x10(%rbx)
movups (%r13), %xmm0
movups %xmm0, (%rbx)
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
je 0xc206f
movq %rax, 0x8(%r15)
leaq 0x20(%rsp), %r13
leaq 0x8(%rsp), %rbp
cmpq 0x10(%r14), %r12
je 0xc20cc
movsd 0x8(%r12), %xmm0
movsd 0x10(%r12), %xmm1
movsd 0x18(%r12), %xmm2
movq %r13, %rdi
callq 0x6402e
movq %rbp, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x642d2
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0x9434
addq $0x48, %r12
jmp 0xc2079
movsd 0x39f84(%rip), %xmm0    # 0xfc058
divsd (%r14), %xmm0
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x640ba
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/cycle.cc
// Function: face_center(ATOM_NETWORK*, std::vector<XYZ, std::allocator<XYZ>>*)
void face_center(ATOM_NETWORK* atmnet, vector<XYZ>* face_centers)
{
    VORONOI_NETWORK vornet;
    vector<VOR_CELL> vcell;
    vector<BASIC_VCELL> bvcell;
    performVoronoiDecomp(true, atmnet, &vornet, &vcell, true, &bvcell);

    vector<VOR_CELL>::iterator vc_it;
    vector<VOR_FACE>::iterator vf_it;

    int vor_face_count = 0;
    int vor_cell_count = 0;

    for (vc_it = vcell.begin(); vc_it != vcell.end(); ++vc_it){
        for (vf_it = vc_it->faces.begin(); vf_it != vc_it->faces.end(); ++vf_it){
            ++vor_face_count;
            vector<int>::iterator iit;
            if (vf_it->nodeIDs.size() > 4) {
                continue;
            }
            vector<Point>::iterator ip_it;
            cout << "Orderd vertices in the face: " << endl;
            for (ip_it = vf_it->orderedVertices.begin(); ip_it != vf_it->orderedVertices.end(); ++ip_it){;
                //cout << "(";
                //ip_it->print(cout);
                //cout << ")  " ;
            }
            //cout <<  endl;
        }
    }
    cout << "VOR_FACE_COUNT " << vor_face_count << endl;
    vcell.clear();
    bvcell.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x4090e
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
andq $0x0, 0x10(%rcx)
leaq 0x20(%rsp), %r9
movaps %xmm0, (%r9)
andq $0x0, 0x10(%r9)
pushq $0x1
popq %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %edi, %r8d
callq 0x5827
xorl %ebx, %ebx
movq (%rsp), %r12
movq 0x8de5f(%rip), %r14     # 0x14ffc0
leaq 0x44088(%rip), %r15     # 0x1061f0
cmpq 0x8(%rsp), %r12
je 0xc21ac
movq (%r12), %r13
cmpq 0x8(%r12), %r13
je 0xc21a3
movq 0x20(%r13), %rax
subq 0x18(%r13), %rax
cmpq $0x10, %rax
ja 0xc219b
movq %r14, %rdi
movq %r15, %rsi
callq 0x4480
movq %rax, %rdi
callq 0x4230
addq $0x30, %r13
incl %ebx
jmp 0xc2173
addq $0xf8, %r12
jmp 0xc2168
movq 0x8de0d(%rip), %rdi     # 0x14ffc0
leaq 0x44054(%rip), %rsi     # 0x10620e
callq 0x4480
movq %rax, %rdi
movl %ebx, %esi
callq 0x4760
movq %rax, %rdi
callq 0x4230
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xb9a6
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xb99e
movq %r14, %rdi
callq 0xaa94
movq %rbx, %rdi
callq 0xaa72
leaq 0x38(%rsp), %rdi
callq 0xa95c
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xc2218
jmp 0xc2218
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xaa94
movq %rsp, %rdi
callq 0xaa72
leaq 0x38(%rsp), %rdi
callq 0xa95c
movq %rbx, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/arguments.cc
// Function: processFilename(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int, unsigned int)
string processFilename(vector<string> command, string name, string file_type, unsigned int num_args_1, unsigned int num_args_2){
    if(command.size() == (num_args_1 + 1)){
        return string(name).append(file_type);
    }
    else if (command.size() == (num_args_2 + 1)){
        return string(command[num_args_2]);
    }
    else {
        cerr << "Error: " << command[0] << " option accepts " << num_args_1 << " or " << num_args_2
        << " arguments but " << command.size() - 1 << " arguments were supplied. " << "\n"
        << "Exiting..." << "\n";
        //    exit(1);
        return "";
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %r8d, %r12d
movq %rcx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x5, %rax
leal 0x1(%r12), %ecx
cmpq %rcx, %rax
jne 0xc252a
movq %rsp, %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x45d0
movq %r14, %rdi
movq %r13, %rsi
callq 0x4850
movq %rbx, %rdi
movq %rax, %rsi
callq 0x45d0
movq %rsp, %rdi
callq 0x4210
jmp 0xc2611
movl %r9d, %r15d
leal 0x1(%r15), %ecx
cmpq %rcx, %rax
jne 0xc254d
movl %r15d, %eax
shlq $0x5, %rax
addq %rax, %rsi
movq %rbx, %rdi
callq 0x45d0
jmp 0xc2611
movq 0x8da9c(%rip), %rdi     # 0x14fff0
leaq 0x43cc3(%rip), %rsi     # 0x10621e
callq 0x4480
movq (%r14), %rsi
movq %rax, %rdi
callq 0x43f0
leaq 0x43cb4(%rip), %rsi     # 0x106226
movq %rax, %rdi
callq 0x4480
movl %r12d, %esi
movq %rax, %rdi
callq 0x42e0
leaq 0x43cab(%rip), %rsi     # 0x106237
movq %rax, %rdi
callq 0x4480
movl %r15d, %esi
movq %rax, %rdi
callq 0x42e0
leaq 0x43c96(%rip), %rsi     # 0x10623c
movq %rax, %rdi
callq 0x4480
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x5, %rsi
decq %rsi
movq %rax, %rdi
callq 0x42e0
leaq 0x43c81(%rip), %rsi     # 0x10624c
movq %rax, %rdi
callq 0x4480
leaq 0x3ffa4(%rip), %r14     # 0x10257e
movq %rax, %rdi
movq %r14, %rsi
callq 0x4480
leaq 0x41036(%rip), %rsi     # 0x103622
movq %rax, %rdi
callq 0x4480
movq %rax, %rdi
movq %r14, %rsi
callq 0x4480
leaq 0x3aded(%rip), %rsi     # 0xfd3f3
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x1b80e
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4210
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/arguments.cc
// Function: processRadialParameters(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
void processRadialParameters(vector<string> args){
    cout << "Loading radii. "<< "\n";
    if(args.size() == 1){
        //do nothing - radTable will have already been initialised by default
    }
    else if(args.size() == 2){
        if(args[1].find(".rad") == string::npos){
            cerr << "Error: If an argument is provided to -r, it must be a file of type .rad containing the types and radii of each atom" << "\n"
            << "Exiting..." << "\n";
            exit(1);
        }
        else{
            readRadTable((char *)args[1].c_str());
        }
    }
    else{
        cerr << "Error: -r option accepts at most 1 argument but " << args.size() - 1 << " were provided." << "\n"
        << "Exiting..." << "\n";
        exit(1);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8d980(%rip), %rdi     # 0x14ffc0
leaq 0x43c20(%rip), %rsi     # 0x106267
callq 0x4480
leaq 0x3ff2b(%rip), %rsi     # 0x10257e
movq %rax, %rdi
callq 0x4480
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
subq %rdi, %rax
sarq $0x5, %rax
cmpq $0x1, %rax
je 0xc269a
cmpq $0x2, %rax
jne 0xc269c
addq $0x20, %rdi
leaq 0x43bf7(%rip), %rsi     # 0x106277
xorl %edx, %edx
callq 0x4860
cmpq $-0x1, %rax
je 0xc26d1
movq (%rbx), %rax
movq 0x20(%rax), %rdi
popq %rbx
jmp 0x1ae89
popq %rbx
retq
movq 0x8d94d(%rip), %rdi     # 0x14fff0
leaq 0x43c46(%rip), %rsi     # 0x1062f0
callq 0x4480
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
sarq $0x5, %rsi
decq %rsi
movq %rax, %rdi
callq 0x4140
leaq 0x43c55(%rip), %rsi     # 0x106321
movq %rax, %rdi
jmp 0xc26df
movq 0x8d918(%rip), %rdi     # 0x14fff0
leaq 0x43b9d(%rip), %rsi     # 0x10627c
callq 0x4480
leaq 0x3fe93(%rip), %rbx     # 0x10257e
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4480
leaq 0x40f25(%rip), %rsi     # 0x103622
movq %rax, %rdi
callq 0x4480
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4480
pushq $0x1
popq %rdi
callq 0x524c
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/arguments.cc
// Function: processMassParameters(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
void processMassParameters(std::vector<std::string> args){
    if(args.size() == 1){
        //do nothing - massTable will have already been initialised by default
    }
    else if(args.size() == 2){
        if(args[1].find(".mass") == string::npos){
            cerr << "Error: If an argument is provided to -mass, it must be a file of type .mass containing the types and masses of each atom" << "\n"
            << "Exiting..." << "\n";
            exit(1);
        }
        else{
            readMassTable((char *)args[1].c_str());
        }
    }
    else{
        cerr << "Error: -mass option requires 1 argument but " << (args.size()-1) << " were supplied" << "\n"
        << "Exiting..." << "\n";
        exit(1);
    };
    
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rax
subq %rdi, %rax
sarq $0x5, %rax
cmpq $0x1, %rax
je 0xc275b
cmpq $0x2, %rax
jne 0xc275d
addq $0x20, %rdi
leaq 0x43bf0(%rip), %rsi     # 0x106331
xorl %edx, %edx
callq 0x4860
cmpq $-0x1, %rax
je 0xc2792
movq (%rbx), %rax
movq 0x20(%rax), %rdi
popq %rbx
jmp 0x1b022
popq %rbx
retq
movq 0x8d88c(%rip), %rdi     # 0x14fff0
leaq 0x43c45(%rip), %rsi     # 0x1063b0
callq 0x4480
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
sarq $0x5, %rsi
decq %rsi
movq %rax, %rdi
callq 0x4140
leaq 0x43c50(%rip), %rsi     # 0x1063dd
movq %rax, %rdi
jmp 0xc27a0
movq 0x8d857(%rip), %rdi     # 0x14fff0
leaq 0x43b97(%rip), %rsi     # 0x106337
callq 0x4480
leaq 0x3fdd2(%rip), %rbx     # 0x10257e
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4480
leaq 0x40e64(%rip), %rsi     # 0x103622
movq %rax, %rdi
callq 0x4480
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4480
pushq $0x1
popq %rdi
callq 0x524c
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/material.cc
// Function: MATERIAL::runVoroFlat()
void MATERIAL::runVoroFlat()
 {
 if(doneFlatVoroFlag == false) {
   // Perform the relevant Voronoi decomposition
   cout << "Starting Voronoi decomposition" << "\n";
   if(radial)
     rad_con = (container_periodic_poly *)performVoronoiDecomp(true, &atmnet, &vornet, cells, outputZvis, bvcells);
   else
     no_rad_con = (container_periodic *)performVoronoiDecomp (false, &atmnet, &vornet, cells, outputZvis, bvcells);

   doneFlatVoroFlag = true;
   cout << "Finished Voronoi decomposition" << "\n";
   };

 }

// Assembly:
cmpb $0x0, 0xc20(%rdi)
je 0xc2ef6
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8d0b8(%rip), %r14     # 0x14ffc0
leaq 0x4371b(%rip), %rsi     # 0x10662a
movq %r14, %rdi
callq 0x4480
leaq 0x3f660(%rip), %r15     # 0x10257e
movq %rax, %rdi
movq %r15, %rsi
callq 0x4480
movzbl 0x968(%rbx), %edi
leaq 0x8c0(%rbx), %rdx
leaq 0x938(%rbx), %rcx
movzbl 0x969(%rbx), %r8d
leaq 0x950(%rbx), %r9
movl %edi, %eax
xorb $0x1, %al
movzbl %al, %r12d
movq %rbx, %rsi
callq 0x52ae
movq %rax, 0xc10(%rbx,%r12,8)
movb $0x1, 0xc20(%rbx)
leaq 0x436d6(%rip), %rsi     # 0x106649
movq %r14, %rdi
callq 0x4480
movq %rax, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4480
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/material.cc
// Function: MATERIAL::AVcalc(double, int, std::ostream&, char*)
void MATERIAL::AVcalc(double r, int sampleDensity,ostream &output, char *filename){
  runVoroFlat();
  accessAnalysis.AccessibilityClassSetup(&atmnet, &orgAtomnet, highAccuracy, rad_con, &vornet, &bvcells, &cells);
  accessAnalysis.FindChannels(r);
  MATERIAL *pMaterial = this;
  if(!AVdoneFlag) NEWcalcAV(pMaterial, r, sampleDensity);
  AVdoneFlag = true;

  NEWcalcAVprint(pMaterial, output,filename); 
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %r15
callq 0xc2eec
leaq 0x990(%r15), %r12
leaq 0x460(%r15), %rdx
movzbl 0x96d(%r15), %ecx
movq 0xc10(%r15), %r8
leaq 0x8c0(%r15), %r9
leaq 0x950(%r15), %rax
leaq 0x938(%r15), %r10
movq %r12, %rdi
movq %r15, %rsi
pushq %r10
pushq %rax
callq 0x6f16a
popq %rax
popq %rcx
movq %r12, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x6f1c6
cmpb $0x0, 0xd3a(%r15)
jne 0xc301e
movq %r15, %rdi
movsd 0x8(%rsp), %xmm0
movl %ebp, %esi
callq 0x30d46
movb $0x1, 0xd3a(%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3130d
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/material.cc
// Function: MATERIAL::AVblockPockets(std::ostream&)
void MATERIAL::AVblockPockets(ostream &output){
  if(AVdoneFlag == false)
    {
    cerr << "Cannot execute blocking before AV run.\n";
    } else
    {
    if(AVblockDoneFlag == false) blockPockets(&atmnet, output, AVaxsPoints, AVaxsPointsChannelIDs, AVinaxsPoints, AVinaxsPointsPocketIDs, AVprobeRadius);
    AVblockDoneFlag = true;
    };
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
cmpb $0x0, 0xd3a(%rdi)
je 0xc3109
movq %rdi, %rbx
cmpb $0x0, 0xd3c(%rdi)
jne 0xc30fa
movq %rsi, %r14
leaq 0xc90(%rbx), %rsi
leaq 0x50(%rsp), %rdi
callq 0xa66e
leaq 0xca8(%rbx), %rsi
leaq 0x38(%rsp), %rdi
callq 0xa6ce
leaq 0xcc0(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0xa66e
leaq 0xcd8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0xa6ce
movsd 0xc70(%rbx), %xmm0
leaq 0x50(%rsp), %rdx
leaq 0x38(%rsp), %rcx
leaq 0x20(%rsp), %r8
leaq 0x8(%rsp), %r9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x303e0
leaq 0x8(%rsp), %rdi
callq 0xb290
leaq 0x20(%rsp), %rdi
callq 0xb83e
leaq 0x38(%rsp), %rdi
callq 0xb290
leaq 0x50(%rsp), %rdi
callq 0xb83e
movb $0x1, 0xd3c(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq 0x8cee0(%rip), %rdi     # 0x14fff0
leaq 0x43551(%rip), %rsi     # 0x106668
addq $0x68, %rsp
popq %rbx
popq %r14
jmp 0x4480
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb290
jmp 0xc3135
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xb83e
jmp 0xc3144
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xb290
jmp 0xc3153
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xb83e
movq %rbx, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/material.cc
// Function: MATERIAL::AVcalcPoreSizeDistr(std::ostream&)
void MATERIAL::AVcalcPoreSizeDistr(ostream &output){
  if(AVdoneFlag == false)
    {
    cerr << "Cannot execute PSD before AV run.\n";
    } else
    {
    MATERIAL *pMaterial = this;
    if(AVPSDdoneFlag == false) NEWcalcPoreSizeDistr(pMaterial, output);
    AVPSDdoneFlag = true;
    };
  }

// Assembly:
cmpb $0x0, 0xd3a(%rdi)
je 0xc318d
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0xd3b(%rdi)
jne 0xc3184
movq %rbx, %rdi
callq 0x698b6
movb $0x1, 0xd3b(%rbx)
popq %rbx
retq
movq 0x8ce5c(%rip), %rdi     # 0x14fff0
leaq 0x434f5(%rip), %rsi     # 0x106690
jmp 0x4480
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/material.cc
// Function: MATERIAL::ASAcalc(double, int, std::ostream&, char*)
void MATERIAL::ASAcalc(double r, int sampleDensity, ostream &output, char *filename){
  runVoroFlat();
  accessAnalysis.AccessibilityClassSetup(&atmnet, &orgAtomnet, highAccuracy, rad_con, &vornet, &bvcells, &cells);
  accessAnalysis.FindChannels(r);
  MATERIAL *pMaterial = this;
  if(!ASAdoneFlag) NEWcalcASA(pMaterial, r, sampleDensity);
  ASAdoneFlag = true;

  NEWcalcASAprint(pMaterial, output,filename);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %r15
callq 0xc2eec
leaq 0x990(%r15), %r12
leaq 0x460(%r15), %rdx
movzbl 0x96d(%r15), %ecx
movq 0xc10(%r15), %r8
leaq 0x8c0(%r15), %r9
leaq 0x950(%r15), %rax
leaq 0x938(%r15), %r10
movq %r12, %rdi
movq %r15, %rsi
pushq %r10
pushq %rax
callq 0x6f16a
popq %rax
popq %rcx
movq %r12, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x6f1c6
cmpb $0x0, 0xe08(%r15)
jne 0xc333e
movq %r15, %rdi
movsd 0x8(%rsp), %xmm0
movl %ebp, %esi
callq 0x35937
movb $0x1, 0xe08(%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x36262
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/material.cc
// Function: MATERIAL::PLDcalc(double, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::ostream&, char*)
void MATERIAL::PLDcalc(double r, double seg_r, string seg_file, ostream &output, char *filename){
  runVoroFlat();
  accessAnalysis.AccessibilityClassSetup(&atmnet, &orgAtomnet, highAccuracy, rad_con, &vornet, &bvcells, &cells);
  accessAnalysis.FindChannels(r);

  if(seg_r > 0)
    { // segment the network based on provide radii of void
    accessAnalysis.calculatePLDbasedOnRadius(seg_r);
    accessAnalysis.reportPLD(output);
    } else
    { // segment the network based on provided segment definitions from a file
    accessAnalysis.calculatePLDbasedOnFile(seg_file);
    accessAnalysis.reportPLD(output);    
    };
/*
  MATERIAL *pMaterial = this;
  if(!ASAdoneFlag) NEWcalcASA(pMaterial, r, sampleDensity);
  ASAdoneFlag = true;
  NEWcalcASAprint(pMaterial, output,filename);
*/
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdi, %r12
callq 0xc2eec
leaq 0x990(%r12), %r14
leaq 0x460(%r12), %rdx
movzbl 0x96d(%r12), %ecx
movq 0xc10(%r12), %r8
leaq 0x8c0(%r12), %r9
leaq 0x950(%r12), %rax
leaq 0x938(%r12), %r10
movq %r14, %rdi
movq %r12, %rsi
pushq %r10
pushq %rax
callq 0x6f16a
popq %rax
popq %rcx
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x6f1c6
movsd 0x10(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xc34b6
movq %r14, %rdi
callq 0x703e6
movq %r14, %rdi
movq %rbx, %rsi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7078a
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x45d0
movq %r14, %rdi
movq %r12, %rsi
callq 0x70708
leaq 0x18(%rsp), %rdi
callq 0x4210
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7078a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4210
movq %rbx, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/material.cc
// Function: MATERIAL::PLDcalcFromMolecules(double, std::ostream&, char*)
void MATERIAL::PLDcalcFromMolecules(double r, ostream &output, char *filename){
  runVoroFlat();
  accessAnalysis.AccessibilityClassSetup(&atmnet, &orgAtomnet, highAccuracy, rad_con, &vornet, &bvcells, &cells);
  accessAnalysis.FindChannels(r);

  accessAnalysis.calculatePLDbasedOnMoleculesPresent(filename);
  accessAnalysis.reportPLD(output);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movsd %xmm0, 0x10(%rsp)
movq %rdi, %r12
callq 0xc2eec
leaq 0x990(%r12), %r14
leaq 0x460(%r12), %rdx
movzbl 0x96d(%r12), %ecx
movq 0xc10(%r12), %r8
leaq 0x8c0(%r12), %r9
leaq 0x950(%r12), %rax
leaq 0x938(%r12), %r10
movq %r14, %rdi
movq %r12, %rsi
pushq %r10
pushq %rax
callq 0x6f16a
popq %rax
popq %rcx
movq %r14, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x6f1c6
leaq 0x18(%rsp), %r12
leaq 0xf(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x1b80e
movq %r14, %rdi
movq %r12, %rsi
callq 0x7075a
leaq 0x18(%rsp), %rdi
callq 0x4210
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7078a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4210
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/OMS.cc
// Function: TransformToSpherical(double*)
void TransformToSpherical(double *TargetMolecule)
{

	double x_coord, y_coord, z_coord;
	double Aux;
	
	// Save the coordinates in order to avoid overwritting
	x_coord = TargetMolecule[X_COORD];
	y_coord = TargetMolecule[Y_COORD];
	z_coord = TargetMolecule[Z_COORD];

	

	// Calculate the phi coordinate (interval [0, 2*PI] )
	TargetMolecule[PHI_COORD] = atan2(y_coord, x_coord);
	if (TargetMolecule[PHI_COORD] < 0)
		TargetMolecule[PHI_COORD] = 2*PI + TargetMolecule[PHI_COORD]; 

	// Calcuate the theta coordinate (interval [0, PI] )
	Aux = sqrt( x_coord*x_coord + y_coord*y_coord );
	TargetMolecule[THETA_COORD] = atan2(Aux, z_coord);
	if (TargetMolecule[THETA_COORD] < 0)
		TargetMolecule[THETA_COORD] = PI + TargetMolecule[THETA_COORD]; 
	
	

	// Calculate the radius (not really necessary)
	//SphericalCoordinates[R_COORD] = sqrt

}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movsd (%rdi), %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x8(%rdi), %xmm2
movsd %xmm2, 0x8(%rsp)
movsd 0x10(%rdi), %xmm0
movsd %xmm0, 0x18(%rsp)
movapd %xmm2, %xmm0
callq 0x4090
movsd 0x38d8f(%rip), %xmm1    # 0xfcaf8
addsd %xmm0, %xmm1
xorpd %xmm3, %xmm3
movapd %xmm0, %xmm2
cmpltsd %xmm3, %xmm2
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
orpd %xmm1, %xmm2
movlpd %xmm2, (%rbx)
movsd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x4090
movsd 0x3c7f7(%rip), %xmm1    # 0x1005b0
addsd %xmm0, %xmm1
movapd %xmm0, %xmm2
cmpltsd 0x3c516(%rip), %xmm2    # 0x1002e0
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
orpd %xmm1, %xmm2
movlpd %xmm2, 0x8(%rbx)
addq $0x20, %rsp
popq %rbx
retq