LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0xaf160
movq -0x70(%rbp), %rdi
callq 0xae590
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x110c34
leaq -0x40(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xea8e0
jmp 0x110ab7
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x110b0f
movq -0x70(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0xae5c0
movq %rax, -0x88(%rbp)
jmp 0x110ad5
movq -0x88(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x110b34
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0xaf390
jmp 0x110c54
movq -0x70(%rbp), %rax
movq 0x90(%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x98(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0xa0(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
movsd -0x40(%rbp), %xmm5
movsd -0x38(%rbp), %xmm6
mulsd %xmm6, %xmm0
mulsd %xmm5, %xmm1
addsd %xmm0, %xmm1
movsd 0x10(%rax), %xmm0
movsd -0x30(%rbp), %xmm4
mulsd %xmm4, %xmm0
addsd %xmm1, %xmm0
movsd 0x18(%rax), %xmm2
movsd 0x20(%rax), %xmm1
mulsd %xmm6, %xmm1
mulsd %xmm5, %xmm2
addsd %xmm1, %xmm2
movsd 0x28(%rax), %xmm1
mulsd %xmm4, %xmm1
addsd %xmm2, %xmm1
movsd 0x30(%rax), %xmm3
movsd 0x38(%rax), %xmm2
mulsd %xmm6, %xmm2
mulsd %xmm5, %xmm3
addsd %xmm2, %xmm3
movsd 0x40(%rax), %xmm2
mulsd %xmm4, %xmm2
addsd %xmm3, %xmm2
leaq -0x68(%rbp), %rdi
callq 0xea8e0
jmp 0x110bc1
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x110bff
movq -0x80(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0xae5c0
movq %rax, -0x98(%rbp)
jmp 0x110bdf
movq -0x98(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
movq -0x60(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x58(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x110c24
movq -0x80(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, 0x90(%rax)
movq -0x60(%rbp), %rcx
movq %rcx, 0x98(%rax)
movq -0x58(%rbp), %rcx
movq %rcx, 0xa0(%rax)
jmp 0x110c26
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x110a92
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x110c47
movq -0x80(%rbp), %rdi
callq 0xaf390
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x58f0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x50(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
callq 0x10090
movq -0x48(%rbp), %rdi
movl %eax, -0xc(%rbp)
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xea8e0
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x110d00
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
movslq -0x10(%rbp), %rsi
callq 0x101d0
movq -0x58(%rbp), %rdi
movslq (%rax), %rsi
callq 0xae5c0
movq -0x48(%rbp), %rsi
movq %rax, %rdx
leaq -0x28(%rbp), %rdi
callq 0xeae50
movq -0x48(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x110c9d
movq -0x48(%rbp), %rsi
cvtsi2sdl -0xc(%rbp), %xmm1
movsd 0xe133f(%rip), %xmm0    # 0x1f2050
divsd %xmm1, %xmm0
leaq -0x40(%rbp), %rdi
callq 0xea9f0
movq -0x48(%rbp), %rcx
movq -0x50(%rbp), %rax
movq -0x40(%rbp), %rdx
movq %rdx, (%rcx)
movq -0x38(%rbp), %rdx
movq %rdx, 0x8(%rcx)
movq -0x30(%rbp), %rdx
movq %rdx, 0x10(%rcx)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
leaq 0x30(%rbp), %rcx
movq %rcx, -0x18(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movb $0x0, -0x1(%rbp)
movl (%rax), %eax
cmpl 0x4(%rcx), %eax
jne 0x110dbd
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
cmpl (%rcx), %eax
jne 0x110dbd
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
addl 0x10(%rcx), %eax
cmpl $0x0, %eax
jne 0x110dbb
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
addl 0x14(%rcx), %eax
cmpl $0x0, %eax
jne 0x110dbb
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
addl 0x18(%rcx), %eax
cmpl $0x0, %eax
jne 0x110dbb
movb $0x1, -0x1(%rbp)
jmp 0x110dbd
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xaf160
movq -0x68(%rbp), %rdi
callq 0xae590
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x110fb4
movq -0x68(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xae5c0
movq %rax, -0x88(%rbp)
jmp 0x110f48
movq -0x70(%rbp), %rdx
movq -0x88(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xeae50
jmp 0x110f5e
movq -0x80(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xae5c0
movq %rax, -0x90(%rbp)
jmp 0x110f74
movq -0x90(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x110f26
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0xaf390
jmp 0x111013
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rsi
addq $0x90, %rsi
leaq -0x60(%rbp), %rdi
callq 0xeae50
jmp 0x110fce
movq -0x80(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, 0x90(%rax)
movq -0x58(%rbp), %rcx
movq %rcx, 0x98(%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0xa0(%rax)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x111006
movq -0x80(%rbp), %rdi
callq 0xaf390
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x58f0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x10090
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jne 0x111062
movq -0x58(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x107f0
jmp 0x1110f5
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x58(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x10090
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x1110f3
movq -0x58(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x111110
movq -0x58(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xeec0
movq -0x68(%rbp), %rdi
movl -0xc(%rbp), %esi
incl %esi
movq -0x18(%rbp), %rdx
callq 0x111020
jmp 0x1110b9
leaq -0x38(%rbp), %rdi
callq 0xec80
movq -0x58(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x111110
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x111068
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xec80
jmp 0x1110fb
jmp 0x1110f5
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
callq 0x10090
movl %eax, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xea8e0
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x111e17
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x101d0
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0xae5c0
movq %rax, %rdx
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xeae50
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x111db9
cvtsi2sdl -0x10(%rbp), %xmm1
movsd 0xe022c(%rip), %xmm0    # 0x1f2050
divsd %xmm1, %xmm0
leaq -0x60(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xea9f0
movq -0x60(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x90(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x98(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0xa0(%rax)
testb $0x1, -0x9(%rbp)
je 0x111e95
movsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movsd -0x18(%rbp), %xmm2
leaq 0xeb440(%rip), %rdi     # 0x1fd2ce
movb $0x3, %al
callq 0x5070
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x4(%rbp), %rsi
callq 0xfff0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x10040
movq -0x10(%rbp), %rdi
callq 0xaf420
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x111fc4
movq -0x10(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0xaf0e0
movq (%rax), %rcx
movq %rcx, -0x4c(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x44(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x3c(%rbp)
movl 0x18(%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x4c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x4(%rbp), %ecx
movb %al, -0x71(%rbp)
jne 0x111f52
movq -0x18(%rbp), %rdi
movslq -0x48(%rbp), %rsi
callq 0xfff0
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x101a0
xorb $-0x1, %al
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x111f5b
jmp 0x111f6b
movl -0x48(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x111ea0
movl -0x48(%rbp), %ecx
xorl %eax, %eax
cmpl -0x4(%rbp), %ecx
movb %al, -0x72(%rbp)
jne 0x111f9b
movq -0x18(%rbp), %rdi
movslq -0x4c(%rbp), %rsi
callq 0xfff0
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x101a0
xorb $-0x1, %al
movb %al, -0x72(%rbp)
movb -0x72(%rbp), %al
testb $0x1, %al
jne 0x111fa4
jmp 0x111fb4
movl -0x4c(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x111ea0
jmp 0x111fb6
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x111eec
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0xada60
movl $0xfffffffe, -0x10(%rbp) # imm = 0xFFFFFFFE
cmpl $0x2, -0x10(%rbp)
jg 0x114f42
movl $0xfffffffe, -0x14(%rbp) # imm = 0xFFFFFFFE
cmpl $0x2, -0x14(%rbp)
jg 0x114f32
movl $0xfffffffe, -0x18(%rbp) # imm = 0xFFFFFFFE
cmpl $0x2, -0x18(%rbp)
jg 0x114f22
movq -0x48(%rbp), %rax
cvtsi2sdl -0x10(%rbp), %xmm2
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
addsd %xmm2, %xmm0
cvtsi2sdl -0x14(%rbp), %xmm2
addsd %xmm2, %xmm1
movsd 0x10(%rax), %xmm2
cvtsi2sdl -0x18(%rbp), %xmm3
addsd %xmm3, %xmm2
leaq -0x30(%rbp), %rdi
callq 0xea8e0
jmp 0x114eef
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xafc20
jmp 0x114efe
jmp 0x114f00
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x114eb1
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x12210
jmp 0x114f5f
jmp 0x114f24
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x114ea0
jmp 0x114f34
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x114e8f
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x114f55
movq -0x58(%rbp), %rdi
callq 0x12210
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x58f0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x51c0
movb %al, -0xa(%rbp)
movsbl -0xa(%rbp), %ecx
movsbl -0x9(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0xb(%rbp)
je 0x11527c
movsbl -0xa(%rbp), %eax
cmpl $-0x1, %eax
setne %al
movb %al, -0xb(%rbp)
movb -0xb(%rbp), %al
testb $0x1, %al
jne 0x115285
jmp 0x115293
movq -0x8(%rbp), %rdi
callq 0x51c0
movb %al, -0xa(%rbp)
jmp 0x11525e
movsbl -0xa(%rbp), %eax
cmpl $-0x1, %eax
jne 0x1152bc
movsbl -0x9(%rbp), %esi
movsbl -0x9(%rbp), %edx
leaq 0xe8827(%rip), %rdi     # 0x1fdad2
movb $0x0, %al
callq 0x5070
movl $0x1, %edi
callq 0x67c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm1
movq -0x8(%rbp), %rax
movsd (%rax), %xmm2
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
mulsd 0x8(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x53f0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm1
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm1
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x10(%rbp), %xmm1
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq -0x90(%rbp), %r9
leaq -0x38(%rbp), %rax
movq %rax, (%rsp)
callq 0x1153e0
leaq -0x90(%rbp), %rdi
movq -0x30(%rbp), %rsi
movsd -0x38(%rbp), %xmm0
leaq -0x40(%rbp), %rdx
callq 0x1163a0
movsd -0x40(%rbp), %xmm0
movaps 0xdb6de(%rip), %xmm1    # 0x1f2080
pand %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0xdb695(%rip), %xmm0    # 0x1f2048
mulsd -0x40(%rbp), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
divsd %xmm1, %xmm0
movaps 0xdb6b8(%rip), %xmm1    # 0x1f2080
pand %xmm1, %xmm0
callq 0x53f0
movq 0x10(%rbp), %rax
movsd %xmm0, (%rax)
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x3c0, %rdi            # imm = 0x3C0
callq 0xae470
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x1172c0
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x18(%rbp), %rdi
addq $0x3c0, %rdi            # imm = 0x3C0
movslq -0x24(%rbp), %rsi
callq 0xae4a0
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x18(%rbp), %rdi
addq $0x3c0, %rdi            # imm = 0x3C0
movslq -0x24(%rbp), %rsi
callq 0xae4a0
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
addq $0x3c0, %rdi            # imm = 0x3C0
movslq -0x24(%rbp), %rsi
callq 0xae4a0
movq -0x60(%rbp), %rdi
movsd -0x58(%rbp), %xmm0
movsd -0x50(%rbp), %xmm1
movsd -0x48(%rbp), %xmm2
movsd -0x40(%rbp), %xmm3
movsd -0x38(%rbp), %xmm4
movsd 0x10(%rax), %xmm5
callq 0x97720
movsd %xmm0, -0x20(%rbp)
movsd 0xe05c5(%rip), %xmm0    # 0x1f7868
ucomisd -0x20(%rbp), %xmm0
jbe 0x1172b0
movb $0x0, -0x1(%rbp)
jmp 0x1172c4
jmp 0x1172b2
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1171c7
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0xae590
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x1173ca
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x18(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0xae5c0
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0xae5c0
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0xae5c0
movq -0x68(%rbp), %rdi
movsd -0x60(%rbp), %xmm0
movsd -0x58(%rbp), %xmm1
movsd -0x50(%rbp), %xmm2
movsd -0x48(%rbp), %xmm3
movsd -0x40(%rbp), %xmm4
movsd 0x10(%rax), %xmm5
callq 0x97720
movsd %xmm0, -0x28(%rbp)
movsd 0xe04b3(%rip), %xmm0    # 0x1f7860
ucomisd -0x28(%rbp), %xmm0
jbe 0x1173ba
movb $0x1, -0x1(%rbp)
jmp 0x1173ce
jmp 0x1173bc
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1172eb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
callq 0x94ed0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
callq 0x94f40
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x94f00
testb $0x1, %al
jne 0x16fa9f
jmp 0x16fae3
leaq -0x28(%rbp), %rdi
callq 0x94f70
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0x16fac0
leaq -0x28(%rbp), %rdi
callq 0x94f70
movl 0x4(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x16facd
movq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0xd1b0
jmp 0x16facf
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xb3e80
jmp 0x16fa7b
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x673f0
movq %rax, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xea8e0
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
callq 0x163b0
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x67420
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x67650
testb $0x1, %al
jne 0x1705f5
jmp 0x1706a5
leaq -0x20(%rbp), %rdi
callq 0x170ae0
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0xa0(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x170ae0
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x98(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x170ae0
movsd -0xa0(%rbp), %xmm0
movsd -0x98(%rbp), %xmm1
movsd 0x18(%rax), %xmm2
leaq -0x58(%rbp), %rdi
callq 0xea8e0
movq -0x10(%rbp), %rsi
leaq -0x70(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0xeae50
movq -0x10(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
movq -0x68(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x60(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x170ae0
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0xd1b0
leaq -0x20(%rbp), %rdi
callq 0x676e0
jmp 0x1705ce
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movsd 0x8199b(%rip), %xmm0    # 0x1f2050
divsd (%rax), %xmm0
leaq -0x88(%rbp), %rdi
callq 0xea9f0
movq -0x10(%rbp), %rax
movq -0x88(%rbp), %rcx
movq %rcx, (%rax)
movq -0x80(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x78(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x101719(%rip), %rdi    # 0x272fc0
leaq 0x8d951(%rip), %rsi     # 0x1ff1ff
callq 0x5540
movq %rax, %rdi
leaq 0x87d68(%rip), %rsi     # 0x1f9625
callq 0x5540
movq -0x10(%rbp), %rdi
callq 0x592f0
cmpq $0x1, %rax
jne 0x1718d6
jmp 0x1719f2
movq -0x10(%rbp), %rdi
callq 0x592f0
cmpq $0x2, %rax
jne 0x17197a
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x59310
movq %rax, %rdi
leaq 0x8d90e(%rip), %rsi     # 0x1ff20f
xorl %eax, %eax
movl %eax, %edx
callq 0x59f0
cmpq $-0x1, %rax
jne 0x17195a
movq 0x1016d9(%rip), %rdi    # 0x272ff0
leaq 0x8d8f6(%rip), %rsi     # 0x1ff214
callq 0x5540
movq %rax, %rdi
leaq 0x87cf8(%rip), %rsi     # 0x1f9625
callq 0x5540
movq %rax, %rdi
leaq 0x899de(%rip), %rsi     # 0x1fb31a
callq 0x5540
movq %rax, %rdi
leaq 0x87cda(%rip), %rsi     # 0x1f9625
callq 0x5540
movl $0x1, %edi
callq 0x67c0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x59310
movq %rax, %rdi
callq 0x5200
movq %rax, %rdi
callq 0x46120
jmp 0x1719f0
movq 0x10166f(%rip), %rdi    # 0x272ff0
leaq 0x8d900(%rip), %rsi     # 0x1ff288
callq 0x5540
movq -0x10(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x592f0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x5160
movq %rax, %rdi
leaq 0x8d905(%rip), %rsi     # 0x1ff2b9
callq 0x5540
movq %rax, %rdi
leaq 0x87c62(%rip), %rsi     # 0x1f9625
callq 0x5540
movq %rax, %rdi
leaq 0x89948(%rip), %rsi     # 0x1fb31a
callq 0x5540
movq %rax, %rdi
leaq 0x87c44(%rip), %rsi     # 0x1f9625
callq 0x5540
movl $0x1, %edi
callq 0x67c0
jmp 0x1719f2
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x592f0
cmpq $0x1, %rax
jne 0x171a20
jmp 0x171b3c
movq -0x10(%rbp), %rdi
callq 0x592f0
cmpq $0x2, %rax
jne 0x171ac4
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x59310
movq %rax, %rdi
leaq 0x8d87e(%rip), %rsi     # 0x1ff2c9
xorl %eax, %eax
movl %eax, %edx
callq 0x59f0
cmpq $-0x1, %rax
jne 0x171aa4
movq 0x10158f(%rip), %rdi    # 0x272ff0
leaq 0x8d867(%rip), %rsi     # 0x1ff2cf
callq 0x5540
movq %rax, %rdi
leaq 0x87bae(%rip), %rsi     # 0x1f9625
callq 0x5540
movq %rax, %rdi
leaq 0x89894(%rip), %rsi     # 0x1fb31a
callq 0x5540
movq %rax, %rdi
leaq 0x87b90(%rip), %rsi     # 0x1f9625
callq 0x5540
movl $0x1, %edi
callq 0x67c0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x59310
movq %rax, %rdi
callq 0x5200
movq %rax, %rdi
callq 0x463f0
jmp 0x171b3a
movq 0x101525(%rip), %rdi    # 0x272ff0
leaq 0x8d876(%rip), %rsi     # 0x1ff348
callq 0x5540
movq -0x10(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x592f0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x5160
movq %rax, %rdi
leaq 0x8d877(%rip), %rsi     # 0x1ff375
callq 0x5540
movq %rax, %rdi
leaq 0x87b18(%rip), %rsi     # 0x1f9625
callq 0x5540
movq %rax, %rdi
leaq 0x897fe(%rip), %rsi     # 0x1fb31a
callq 0x5540
movq %rax, %rdi
leaq 0x87afa(%rip), %rsi     # 0x1f9625
callq 0x5540
movl $0x1, %edi
callq 0x67c0
jmp 0x171b3c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movb 0xc20(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x17271f
movq 0x100981(%rip), %rdi    # 0x272fc0
leaq 0x8cf7c(%rip), %rsi     # 0x1ff5c2
callq 0x5540
movq %rax, %rdi
leaq 0x86fd0(%rip), %rsi     # 0x1f9625
callq 0x5540
movq -0x10(%rbp), %rax
testb $0x1, 0x968(%rax)
je 0x1726af
movq -0x10(%rbp), %rsi
movq %rsi, %rdx
addq $0x8c0, %rdx            # imm = 0x8C0
movq %rsi, %rcx
addq $0x938, %rcx            # imm = 0x938
movb 0x969(%rsi), %al
movq %rsi, %r9
addq $0x950, %r9             # imm = 0x950
movl $0x1, %edi
andb $0x1, %al
movzbl %al, %r8d
callq 0x6950
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xc10(%rax)
jmp 0x1726f2
movq -0x10(%rbp), %rsi
movq %rsi, %rdx
addq $0x8c0, %rdx            # imm = 0x8C0
movq %rsi, %rcx
addq $0x938, %rcx            # imm = 0x938
movb 0x969(%rsi), %al
movq %rsi, %r9
addq $0x950, %r9             # imm = 0x950
xorl %edi, %edi
andb $0x1, %al
movzbl %al, %r8d
callq 0x6950
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xc18(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0xc20(%rax)
movq 0x1008bc(%rip), %rdi    # 0x272fc0
leaq 0x8ced6(%rip), %rsi     # 0x1ff5e1
callq 0x5540
movq %rax, %rdi
leaq 0x86f0b(%rip), %rsi     # 0x1f9625
callq 0x5540
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x172610
movq -0x38(%rbp), %rsi
movq %rsi, %rdi
addq $0x990, %rdi            # imm = 0x990
movq %rsi, %rdx
addq $0x460, %rdx            # imm = 0x460
movb 0x96d(%rsi), %cl
movq 0xc10(%rsi), %r8
movq %rsi, %r9
addq $0x8c0, %r9             # imm = 0x8C0
movq %rsi, %r10
addq $0x950, %r10            # imm = 0x950
movq %rsi, %rax
addq $0x938, %rax            # imm = 0x938
andb $0x1, %cl
movzbl %cl, %ecx
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xfe8d0
movq -0x38(%rbp), %rdi
addq $0x990, %rdi            # imm = 0x990
movsd -0x10(%rbp), %xmm0
callq 0xfe990
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0xd3a(%rax)
jne 0x1727e6
movq -0x30(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movl -0x14(%rbp), %esi
callq 0x7a480
movq -0x38(%rbp), %rax
movb $0x1, 0xd3a(%rax)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x7abc0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movb 0xd3a(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x172856
movq 0x1007ab(%rip), %rdi    # 0x272ff0
leaq 0x8cdb4(%rip), %rsi     # 0x1ff600
callq 0x5540
jmp 0x1729ac
movq -0x88(%rbp), %rax
movb 0xd3c(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x17299e
movq -0x88(%rbp), %rsi
movq %rsi, %rax
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
addq $0xc90, %rsi            # imm = 0xC90
leaq -0x28(%rbp), %rdi
callq 0xedd0
movq -0x88(%rbp), %rsi
addq $0xca8, %rsi            # imm = 0xCA8
leaq -0x40(%rbp), %rdi
callq 0xeec0
jmp 0x1728b6
movq -0x88(%rbp), %rsi
addq $0xcc0, %rsi            # imm = 0xCC0
leaq -0x68(%rbp), %rdi
callq 0xedd0
jmp 0x1728cf
movq -0x88(%rbp), %rsi
addq $0xcd8, %rsi            # imm = 0xCD8
leaq -0x80(%rbp), %rdi
callq 0xeec0
jmp 0x1728e8
movq -0x90(%rbp), %rsi
movq -0x98(%rbp), %rdi
movq -0x88(%rbp), %rax
movsd 0xc70(%rax), %xmm0
leaq -0x28(%rbp), %rdx
leaq -0x40(%rbp), %rcx
leaq -0x68(%rbp), %r8
leaq -0x80(%rbp), %r9
callq 0x791f0
jmp 0x17291c
leaq -0x80(%rbp), %rdi
callq 0xec80
leaq -0x68(%rbp), %rdi
callq 0xefe0
leaq -0x40(%rbp), %rdi
callq 0xec80
leaq -0x28(%rbp), %rdi
callq 0xefe0
jmp 0x17299e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x172993
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x17298a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x172981
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xec80
leaq -0x68(%rbp), %rdi
callq 0xefe0
leaq -0x40(%rbp), %rdi
callq 0xec80
leaq -0x28(%rbp), %rdi
callq 0xefe0
jmp 0x1729b5
movq -0x88(%rbp), %rax
movb $0x1, 0xd3c(%rax)
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x58f0
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb 0xd3a(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1729fd
movq 0x100601(%rip), %rdi    # 0x272ff0
leaq 0x8cc32(%rip), %rsi     # 0x1ff628
callq 0x5540
jmp 0x172a2d
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movb 0xd3b(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x172a22
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf5270
movq -0x20(%rbp), %rax
movb $0x1, 0xd3b(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x172610
movq -0x38(%rbp), %rsi
movq %rsi, %rdi
addq $0x990, %rdi            # imm = 0x990
movq %rsi, %rdx
addq $0x460, %rdx            # imm = 0x460
movb 0x96d(%rsi), %cl
movq 0xc10(%rsi), %r8
movq %rsi, %r9
addq $0x8c0, %r9             # imm = 0x8C0
movq %rsi, %r10
addq $0x950, %r10            # imm = 0x950
movq %rsi, %rax
addq $0x938, %rax            # imm = 0x938
andb $0x1, %cl
movzbl %cl, %ecx
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xfe8d0
movq -0x38(%rbp), %rdi
addq $0x990, %rdi            # imm = 0x990
movsd -0x10(%rbp), %xmm0
callq 0xfe990
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0xe08(%rax)
jne 0x172c76
movq -0x30(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movl -0x14(%rbp), %esi
callq 0x824f0
movq -0x38(%rbp), %rax
movb $0x1, 0xe08(%rax)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x832d0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x172610
movq -0x68(%rbp), %rsi
movq %rsi, %rdi
addq $0x990, %rdi            # imm = 0x990
movq %rsi, %rdx
addq $0x460, %rdx            # imm = 0x460
movb 0x96d(%rsi), %cl
movq 0xc10(%rsi), %r8
movq %rsi, %r9
addq $0x8c0, %r9             # imm = 0x8C0
movq %rsi, %r10
addq $0x950, %r10            # imm = 0x950
movq %rsi, %rax
addq $0x938, %rax            # imm = 0x938
andb $0x1, %cl
movzbl %cl, %ecx
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xfe8d0
movq -0x68(%rbp), %rdi
addq $0x990, %rdi            # imm = 0x990
movsd -0x10(%rbp), %xmm0
callq 0xfe990
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x172e9a
movq -0x68(%rbp), %rdi
addq $0x990, %rdi            # imm = 0x990
movsd -0x18(%rbp), %xmm0
callq 0x100830
movq -0x68(%rbp), %rdi
addq $0x990, %rdi            # imm = 0x990
movq -0x28(%rbp), %rsi
callq 0x100da0
jmp 0x172efe
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rax
addq $0x990, %rax            # imm = 0x990
movq %rax, -0x80(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x5220
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x100ce0
jmp 0x172ec8
leaq -0x50(%rbp), %rdi
callq 0x5300
movq -0x68(%rbp), %rdi
addq $0x990, %rdi            # imm = 0x990
movq -0x28(%rbp), %rsi
callq 0x100da0
jmp 0x172efe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5300
jmp 0x172f07
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x58f0
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x172610
movq -0x78(%rbp), %rsi
movq %rsi, %rdi
addq $0x990, %rdi            # imm = 0x990
movq %rdi, -0x70(%rbp)
movq %rsi, %rdx
addq $0x460, %rdx            # imm = 0x460
movq 0xc10(%rsi), %r8
movq %rsi, %r9
addq $0x8c0, %r9             # imm = 0x8C0
movq %rsi, %r10
addq $0x950, %r10            # imm = 0x950
movq %rsi, %r11
addq $0x938, %r11            # imm = 0x938
movzbl 0x96d(%rsi), %ecx
movq %rsp, %rax
movq %r11, 0x8(%rax)
movq %r10, (%rax)
andl $0x1, %ecx
callq 0xfe8d0
movq -0x70(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0xfe990
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x5900
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x47530
jmp 0x172fc9
movq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x100d50
jmp 0x172fd8
leaq -0x40(%rbp), %rdi
callq 0x5300
leaq -0x41(%rbp), %rdi
callq 0x55d0
movq -0x78(%rbp), %rdi
addq $0x990, %rdi            # imm = 0x990
movq -0x18(%rbp), %rsi
callq 0x100da0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x17302a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5300
leaq -0x41(%rbp), %rdi
callq 0x55d0
movq -0x50(%rbp), %rdi
callq 0x58f0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
callq 0x50b0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
ucomisd (%rax), %xmm0
jbe 0x173c91
movq -0x8(%rbp), %rax
movsd 0x7ee1b(%rip), %xmm0    # 0x1f2aa0
addsd (%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm0
movsd -0x10(%rbp), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x53f0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
callq 0x50b0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
ucomisd 0x8(%rax), %xmm0
jbe 0x173cf7
movq -0x8(%rbp), %rax
movsd 0x82947(%rip), %xmm0    # 0x1f6630
addsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)