LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/networkstorage.cc
// Function: getNodeID(Point, ATOM_NETWORK*, VORONOI_NETWORK*)
int getNodeID(Point pt, ATOM_NETWORK *atmnet, VORONOI_NETWORK *vornet){
    double minDist = DBL_MAX;
    int minID = -1;
    for(unsigned int i = 0; i < vornet->nodes.size(); i++){
        VOR_NODE curNode = vornet->nodes.at(i);
        double dist = atmnet->calcDistanceXYZ(pt[0], pt[1], pt[2], curNode.x, curNode.y, curNode.z);
        if(dist < threshold)
            return i;
        else {
            if(dist < minDist){
                minDist = dist;
                minID = i;
            }
        }
    }
    
    cerr << "Warning : When identifying Voronoi node, the distance exceeded the threshold of " << threshold << "\n"
    << "Occurred during analysis of " << atmnet->name << "\n"
    << "Closest node was within " << minDist << "\n"
    << "Proceeding with analysis" << "\n";
    return minID;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa0(%rsp), %r15
leaq 0x48(%rsi), %r13
movsd 0xbe25d(%rip), %xmm0    # 0x1016e8
movsd %xmm0, 0x10(%rsp)
pushq $-0x1
popq %r12
xorl %ebp, %ebp
movl %ebp, %esi
movq 0x50(%r14), %rax
subq 0x48(%r14), %rax
sarq $0x6, %rax
cmpq %rsi, %rax
jbe 0x43580
movq %r13, %rdi
callq 0xa848
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0xa86a
movq %r15, %rdi
xorl %esi, %esi
callq 0x63c78
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq %r15, %rdi
pushq $0x1
popq %rsi
callq 0x63c78
movsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %r15, %rdi
pushq $0x2
popq %rsi
callq 0x63c78
movsd (%rax), %xmm2
movsd 0x28(%rsp), %xmm3
movsd 0x30(%rsp), %xmm4
movsd 0x38(%rsp), %xmm5
movq %rbx, %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
callq 0x3f636
movapd %xmm0, %xmm2
movsd 0xbdcbb(%rip), %xmm0    # 0x1011e8
ucomisd %xmm2, %xmm0
movsd %xmm2, 0x18(%rsp)
ja 0x43557
movsd 0x10(%rsp), %xmm1
ucomisd %xmm2, %xmm1
cmoval %ebp, %r12d
movapd %xmm2, %xmm0
minsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x4355b
movl %ebp, 0xc(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xb290
incl %ebp
movsd 0xbdc79(%rip), %xmm0    # 0x1011e8
ucomisd 0x18(%rsp), %xmm0
jbe 0x43497
jmp 0x43628
movq 0x10ca69(%rip), %rdi    # 0x14fff0
leaq 0xbebc1(%rip), %rsi     # 0x10214f
callq 0x4480
movsd 0xbdc4d(%rip), %xmm0    # 0x1011e8
movq %rax, %rdi
callq 0x46c0
leaq 0xbefd4(%rip), %r14     # 0x10257e
movq %rax, %rdi
movq %r14, %rsi
callq 0x4480
leaq 0xbebe4(%rip), %rsi     # 0x1021a0
movq %rax, %rdi
callq 0x4480
addq $0x320, %rbx            # imm = 0x320
movq %rax, %rdi
movq %rbx, %rsi
callq 0x43f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x4480
leaq 0xbebd5(%rip), %rsi     # 0x1021bd
movq %rax, %rdi
callq 0x4480
movq %rax, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x46c0
movq %rax, %rdi
movq %r14, %rsi
callq 0x4480
leaq 0xbebc6(%rip), %rsi     # 0x1021d6
movq %rax, %rdi
callq 0x4480
movq %rax, %rdi
movq %r14, %rsi
callq 0x4480
movl %r12d, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xb290
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/networkstorage.cc
// Function: apply_symmetry_operator(MOLECULE, int, int, ATOM_NETWORK*)
MOLECULE apply_symmetry_operator(MOLECULE orig, int sym_op, int sym_ID, ATOM_NETWORK *underlying_net) {
  MOLECULE rot = orig;
  int num_atom = orig.atoms_xyz.size();
  for(int i=0; i<num_atom+1; i++) {
    XYZ pos;
    if(i<num_atom) pos = orig.atoms_xyz.at(i); else pos = orig.com; //handle the centre of mass too!
    XYZ abc_pos = underlying_net->xyz_to_abc_returning_XYZ(pos);
    XYZ new_pos = underlying_net->abc_to_xyz_returning_XYZ(GetEquivalentPositions(sym_ID, &abc_pos).at(sym_op));
    if(i<num_atom) rot.atoms_xyz.at(i) = new_pos; else rot.com = new_pos; //handle the centre of mass too!
  }
  return rot;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, %r14
movl %ecx, 0x14(%rsp)
movl %edx, %ebx
movq %rsi, %r13
movq %rdi, %r15
callq 0x4ba0a
movq 0x8(%r13), %rax
subq (%r13), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movl $0x90, %r12d
movq %r13, 0x18(%rsp)
leaq (%r12,%r13), %rcx
movq %rcx, 0x28(%rsp)
movslq %ebx, %rcx
movq %rcx, 0x20(%rsp)
movq %r15, 0x8(%rsp)
addq %r15, %r12
movslq %eax, %rbx
xorl %r13d, %r13d
leaq 0x80(%rsp), %r15
leaq 0x68(%rsp), %rbp
cmpq %rbx, %r13
jg 0x47285
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
leaq 0x30(%rsp), %rdi
callq 0x6402e
movq 0x28(%rsp), %rax
cmpq %rbx, %r13
jge 0x47202
movq 0x18(%rsp), %rdi
movq %r13, %rsi
callq 0x4b6d6
movq 0x10(%rax), %rcx
movq %rcx, 0x40(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x30(%rsp)
movq %r15, %rdi
movq %r14, %rsi
leaq 0x30(%rsp), %rdx
callq 0x3e082
movq %rbp, %rdi
movl 0x14(%rsp), %esi
movq %r15, %rdx
callq 0x7a2a1
movq %rbp, %rdi
movq 0x20(%rsp), %rsi
callq 0x4b6d6
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3f1b2
movq %rbp, %rdi
callq 0xb132
movq %r12, %rax
cmpq %rbx, %r13
jge 0x4726c
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x4b6d6
movq 0x60(%rsp), %rcx
movq %rcx, 0x10(%rax)
movups 0x50(%rsp), %xmm0
movups %xmm0, (%rax)
incq %r13
jmp 0x471cf
movq 0x8(%rsp), %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x472a2
jmp 0x472a2
jmp 0x472a2
movq %rax, %rbx
jmp 0x472b4
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xb132
movq 0x8(%rsp), %rdi
callq 0x4bb60
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/networkstorage.cc
// Function: parse_group(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>>>>*, int, ATOM_NETWORK*)
void parse_group(vector<string> *token, int first_index, ATOM_NETWORK *cell) {
  bool verbose = false;
  string sym_name = token->at(first_index+0);
  if(verbose) printf("parsed group name %s\n", sym_name.c_str());
  int sym_ID = get_sym_ID(sym_name);
  if(verbose) printf("\ti.e. group ID %d\n", sym_ID);
  cell->sym_ID = sym_ID;
  cell->sym_name = sym_name;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movslq %esi, %rsi
callq 0x4bb9a
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x45d0
movq %rsp, %rdi
movq %r14, %rsi
callq 0x45d0
movq %rsp, %rdi
callq 0xc0087
movl %eax, %ebp
movq %rsp, %rdi
callq 0x4210
movl %ebp, 0x438(%rbx)
addq $0x440, %rbx            # imm = 0x440
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x4270
leaq 0x20(%rsp), %rdi
callq 0x4210
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4210
jmp 0x47b8d
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4210
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/networkstorage.cc
// Function: parse_node(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>>>>*, int, ATOM_NETWORK*, int*)
void parse_node(vector<string> *token, int first_index, ATOM_NETWORK *cell, int *atom_index) {
  bool verbose = false;
  VERTEX v(convertToDouble(token->at(first_index+2)), convertToDouble(token->at(first_index+3)), convertToDouble(token->at(first_index+4)));
  if(verbose) printf("parsed node labelled %d at %.3f %.3f %.3f\n", convertToInt(token->at(first_index+0)), v.abc.x, v.abc.y, v.abc.z);
  v.expected_edges = convertToInt(token->at(first_index+1)); //this many edges are expected, but note that with this file format, the edges only come once all nodes are read and, in all likelihood, are not given exhaustively
  cell->vertices.push_back(v);
  cell->vertex_symmetry_operators.push_back(0); //the vertices read from file are the basic ones, before any symmetry operator (or you could say after operator 0, which does nothing)
  cell->vertex_basic_indices.push_back((*atom_index));
  (*atom_index)++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %r15
leal 0x2(%r12), %eax
movslq %eax, %rsi
callq 0x4bb9a
movq %rax, %rdi
callq 0x38473
movsd %xmm0, 0x8(%rsp)
leal 0x3(%r12), %eax
movslq %eax, %rsi
movq %r15, %rdi
callq 0x4bb9a
movq %rax, %rdi
callq 0x38473
movsd %xmm0, (%rsp)
leal 0x4(%r12), %eax
movslq %eax, %rsi
movq %r15, %rdi
callq 0x4bb9a
movq %rax, %rdi
callq 0x38473
movaps %xmm0, %xmm2
leaq 0x18(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x75d1c
incl %r12d
movslq %r12d, %rsi
movq %r15, %rdi
callq 0x4bb9a
movq %rax, %rdi
callq 0x38503
leaq 0x18(%rsp), %rsi
movl %eax, 0x18(%rsi)
leaq 0x3c0(%r14), %rdi
callq 0x4bed0
leaq 0x420(%r14), %rdi
leaq 0x14(%rsp), %rsi
andl $0x0, (%rsi)
callq 0x10324
addq $0x408, %r14            # imm = 0x408
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9434
incl (%rbx)
leaq 0x18(%rsp), %rdi
callq 0xb1ba
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x48134
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xb1ba
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voronoicell.cc
// Function: VOR_FACE::getNodes()
vector< pair<int,Point> > VOR_FACE::getNodes(){
  vector< pair<int,Point> > results = vector< pair<int,Point> > ();
  for(unsigned int i = 0; i < orderedVertices.size(); i++){
    results.push_back(pair<int,Point> (nodeIDs[i], orderedVertices[i]));
  }
  return results;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %r13d, %r13d
pushq $0x18
popq %rbp
leaq 0x8(%rsp), %r15
movl %r13d, %r13d
movq (%r14), %rcx
movq 0x8(%r14), %rax
subq %rcx, %rax
cqto
idivq %rbp
cmpq %r13, %rax
jbe 0x4e727
movq 0x18(%r14), %rax
imulq $0x18, %r13, %rdx
movl (%rax,%r13,4), %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rcx,%rdx), %rax
movq %rax, 0x10(%r12)
movups (%rcx,%rdx), %xmm0
movups %xmm0, (%r12)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x37456
incl %r13d
jmp 0x4e6dd
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x371b8
movq %r14, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voronoicell.cc
// Function: VOR_FACE::getEdgeCoords()
vector< pair<Point, Point> > VOR_FACE::getEdgeCoords() {
  vector< pair<Point, Point> > results = vector< pair<Point,Point> > ();
  for(unsigned int i = 0; i < orderedVertices.size() - 1; i++){
    Point curPt = orderedVertices[i];
    Point nextPt = orderedVertices[i+1];
    results.push_back(pair<Point,Point> (curPt,nextPt));
  }
  results.push_back(pair<Point,Point> (orderedVertices[orderedVertices.size() - 1],orderedVertices[0]));
  return results;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
pushq $0x1
popq %r13
pushq $0x18
popq %rbp
movq %rsp, %r15
leal -0x1(%r13), %esi
movq (%r14), %rcx
movq 0x8(%r14), %rax
subq %rcx, %rax
cqto
idivq %rbp
decq %rax
cmpq %rsi, %rax
jbe 0x4e7e9
imulq $0x18, %rsi, %rax
movq 0x10(%rcx,%rax), %rdx
movq %rdx, 0x60(%rsp)
movups (%rcx,%rax), %xmm0
movaps %xmm0, 0x50(%rsp)
movl %r13d, %eax
imulq $0x18, %rax, %rax
movq 0x10(%rcx,%rax), %rsi
movq %rsi, 0x40(%rsp)
movups (%rcx,%rax), %xmm1
movaps %xmm1, 0x30(%rsp)
movq %rdx, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %rsi, 0x10(%r12)
movups %xmm1, (%r12)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x511d0
incl %r13d
jmp 0x4e77a
imulq $0x18, %rax, %rax
movq 0x10(%rcx,%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x10(%rsi)
movups (%rcx,%rax), %xmm0
movaps %xmm0, (%rsi)
movups (%rcx), %xmm0
movups %xmm0, 0x18(%rsi)
movq 0x10(%rcx), %rax
movq %rax, 0x28(%rsi)
movq %rbx, %rdi
callq 0x511d0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4e82b
movq %rax, %r14
movq %rbx, %rdi
callq 0x51194
movq %r14, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voronoicell.cc
// Function: VOR_CELL::VOR_CELL()
VOR_CELL::VOR_CELL(){
  faces = vector<VOR_FACE> ();
  numVertices = 0;
  vertexIDs = map<Point, int, bool(*)(Point,Point)> (pointIsLess);
  idMappings = map<int,int> ();
  reverseIDMappings = map<int, vector<int> > ();
  vertexCoords = map<int,Point> ();
  edgeConnections = vector< set<int> > ();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r13
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %r12
andq $0x0, 0x20(%rdi)
leaq 0x28(%rdi), %rax
andl $0x0, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movq %rax, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
leaq 0x58(%rdi), %rax
andl $0x0, 0x58(%rdi)
andq $0x0, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movq %rax, 0x70(%rdi)
andq $0x0, 0x78(%rdi)
leaq 0x88(%rdi), %rax
andl $0x0, 0x88(%rdi)
andq $0x0, 0x90(%rdi)
movq %rax, 0x98(%rdi)
movq %rax, 0xa0(%rdi)
andq $0x0, 0xa8(%rdi)
leaq 0x50(%rdi), %rbp
andl $0x0, 0xb8(%rdi)
leaq 0x80(%rdi), %r15
andq $0x0, 0xc0(%rdi)
leaq 0xb0(%rdi), %r14
leaq 0xb8(%rdi), %rax
movq %rax, 0xc8(%rdi)
movq %rax, 0xd0(%rdi)
leaq 0xe0(%rdi), %rax
movq %rax, 0x8(%rsp)
movups %xmm0, 0xe8(%rdi)
movups %xmm0, 0xd8(%rdi)
leaq 0x10(%rsp), %rbx
movaps %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rbx, %rsi
callq 0xd556
movq %rbx, %rdi
callq 0xb4b6
andl $0x0, 0x18(%r13)
leaq 0x153aa(%rip), %rax     # 0x63f1c
movq %rax, (%rbx)
leaq 0x18(%rsp), %r13
andl $0x0, (%r13)
andq $0x0, 0x8(%r13)
movq %r13, 0x10(%r13)
movq %r13, 0x18(%r13)
andq $0x0, 0x20(%r13)
leaq 0x10(%rsp), %rbx
movq %r12, %rdi
movq %rbx, %rsi
callq 0xd5a8
movq %rbx, %rdi
callq 0xb5f6
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %r13, 0x18(%rbx)
movq %r13, 0x20(%rbx)
andq $0x0, 0x28(%rbx)
leaq 0x10(%rsp), %rbx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xd62a
movq %rbx, %rdi
callq 0xaf66
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %r13, 0x18(%rbx)
movq %r13, 0x20(%rbx)
andq $0x0, 0x28(%rbx)
leaq 0x10(%rsp), %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xd6a6
movq %rbx, %rdi
callq 0xb592
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %r13, 0x18(%rbx)
movq %r13, 0x20(%rbx)
andq $0x0, 0x28(%rbx)
leaq 0x10(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd722
movq %rbx, %rdi
callq 0xb53a
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
leaq 0x10(%rsp), %rbx
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xd79e
movq %rbx, %rdi
callq 0xb494
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voronoicell.cc
// Function: VOR_CELL::addNode(int, Point)
void VOR_CELL::addNode(int nodeID, Point coord){
  if(vertexIDs.find(coord) == vertexIDs.end()){
    idMappings.insert(pair<int,int> (numVertices, nodeID));
    
    map<int, vector<int> >::iterator revMap = reverseIDMappings.find(nodeID);      
    if(revMap == reverseIDMappings.end()){
      vector<int> newList = vector<int> ();
      newList.push_back(numVertices);
      reverseIDMappings.insert(pair<int, vector<int> > (nodeID, newList));
    }
    else {
      revMap->second.push_back(numVertices);
    }
    vertexIDs.insert(pair<Point,int> (coord, numVertices));
    vertexCoords.insert(pair<int,Point> (numVertices, coord));
    edgeConnections.push_back(set<int>());
    numVertices++;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x90(%rsp), %r15
movl %esi, 0xc(%rsp)
leaq 0x20(%rdi), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x513a4
leaq 0x28(%rbx), %rcx
cmpq %rcx, %rax
jne 0x4edd4
leaq 0x50(%rbx), %rdi
leaq 0x18(%rbx), %r14
movl 0x18(%rbx), %eax
leaq 0x10(%rsp), %rsi
movl %eax, (%rsi)
movl %ebp, 0x4(%rsi)
callq 0xf6e0
leaq 0x80(%rbx), %r13
leaq 0xc(%rsp), %rsi
movq %r13, %rdi
callq 0x51472
leaq 0x88(%rbx), %rcx
cmpq %rcx, %rax
je 0x4ecf4
addq $0x28, %rax
movq %rax, %rdi
movq %r14, %rsi
callq 0x9434
jmp 0x4ed44
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %r14, %rsi
callq 0x9434
movl 0xc(%rsp), %eax
leaq 0x18(%rsp), %rbp
movl %eax, -0x8(%rbp)
leaq 0x40(%rsp), %rsi
movq %rbp, %rdi
callq 0xa6ce
leaq 0x10(%rsp), %rsi
movq %r13, %rdi
callq 0x514c4
movq %rbp, %rdi
callq 0xb290
leaq 0x40(%rsp), %rdi
callq 0xb290
movq 0x10(%r15), %rax
leaq 0x10(%rsp), %r13
movq %rax, 0x10(%r13)
movups (%r15), %xmm0
movaps %xmm0, (%r13)
movl 0x18(%rbx), %eax
movl %eax, 0x18(%r13)
movq %r12, %rdi
movq %r13, %rsi
callq 0x51634
leaq 0xb0(%rbx), %rdi
movl 0x18(%rbx), %eax
movl %eax, (%r13)
movups (%r15), %xmm0
movups %xmm0, 0x8(%r13)
movq 0x10(%r15), %rax
movq %rax, 0x18(%r13)
leaq 0x10(%rsp), %rsi
callq 0x51810
addq $0xe0, %rbx
leaq 0x18(%rsp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x51958
leaq 0x10(%rsp), %rdi
callq 0xafbe
incl (%r14)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rbp, %rdi
callq 0xb290
jmp 0x4edf5
jmp 0x4edf2
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xb290
jmp 0x4ee0e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xafbe
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voronoicell.cc
// Function: VOR_CELL::addFace(VOR_FACE)
void VOR_CELL::addFace(VOR_FACE face) {
  faces.push_back(face);
  vector< pair<int,Point> > nodes = face.getNodes();
  for(unsigned int i = 0; i < nodes.size(); i++){
    pair<int, Point> node = nodes[i];
    addNode(node.first, node.second);
  }
  vector< pair<Point, Point> > edges= face.getEdgeCoords();
  for(unsigned int i = 0; i < edges.size(); i++){
    pair<Point,Point> coord = edges[i];
    addEdge(coord.first, coord.second);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x510c8
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x4e6ae
xorl %r15d, %r15d
movl %r15d, %r15d
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
cmpq %r15, %rcx
jbe 0x4f0ac
movq %r15, %rcx
shlq $0x5, %rcx
movl (%rax,%rcx), %esi
movq 0x18(%rax,%rcx), %rdx
movq %rdx, 0x70(%rsp)
movups 0x8(%rax,%rcx), %xmm0
movaps %xmm0, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x60(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x4ec6e
incl %r15d
jmp 0x4f055
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x4e74c
xorl %r14d, %r14d
leaq 0x98(%rsp), %r15
pushq $0x30
popq %r12
movl %r14d, %r14d
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
subq %rcx, %rax
cqto
idivq %r12
cmpq %r14, %rax
jbe 0x4f13d
imulq $0x30, %r14, %rax
movups (%rcx,%rax), %xmm0
movups 0x10(%rcx,%rax), %xmm1
movups 0x20(%rcx,%rax), %xmm2
movaps %xmm2, 0xa0(%rsp)
movaps %xmm1, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movq 0x10(%r15), %rdx
movq %rdx, 0x28(%rsp)
movups (%r15), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x10(%rcx,%rax), %rdx
movq %rdx, 0x10(%rsp)
movups (%rcx,%rax), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x4ee16
incl %r14d
jmp 0x4f0c8
leaq 0x30(%rsp), %rdi
callq 0x51194
leaq 0x48(%rsp), %rdi
callq 0x371b8
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x4f171
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x51194
jmp 0x4f174
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x371b8
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voronoicell.cc
// Function: VOR_CELL::getNodeCoords(int)
vector<Point> VOR_CELL::getNodeCoords(int nodeID){
  map<int, vector<int> >::iterator iter = reverseIDMappings.find(nodeID);
  if(iter == reverseIDMappings.end()){
    cerr << "Error: Node #" << nodeID << " isn't in this Voronoi cell." << "\n";
    cerr << "Cell contains these nodes: "; 
    map<int, vector<int> >::iterator nIter = reverseIDMappings.begin();
    while(nIter != reverseIDMappings.end()){
      cerr << nIter->first << " ";
      nIter++;
    }
    cerr << "\n";
    cerr << "Exiting..." << "\n";
    exit(1);
  }
  vector<int> vertexIDs = iter->second;
  vector<Point> coords = vector<Point> ();
  for(unsigned int i = 0; i < vertexIDs.size(); i++){
    coords.push_back(vertexCoords.find(vertexIDs[i])->second);
  }
  return coords;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %rsi
movl %edx, (%rsi)
leaq 0x80(%rbx), %rdi
callq 0x51472
movq %rax, %r15
leaq 0x88(%rbx), %rax
cmpq %rax, %r15
je 0x4f232
addq $0x28, %r15
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0xa6ce
addq $0xb0, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
xorl %r15d, %r15d
movl %r15d, %r15d
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r15, %rcx
jbe 0x4f219
leaq (%rax,%r15,4), %rsi
movq %rbx, %rdi
callq 0x51c4c
addq $0x28, %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x2468e
incl %r15d
jmp 0x4f1e0
leaq 0x10(%rsp), %rdi
callq 0xb290
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x100db7(%rip), %r14    # 0x14fff0
leaq 0xb11d2(%rip), %rsi     # 0x100412
movq %r14, %rdi
callq 0x4480
movl 0xc(%rsp), %esi
movq %rax, %rdi
callq 0x4760
leaq 0xb4029(%rip), %rsi     # 0x103284
movq %rax, %rdi
callq 0x4480
leaq 0xb3314(%rip), %rsi     # 0x10257e
movq %rax, %rdi
callq 0x4480
leaq 0xb4028(%rip), %rsi     # 0x1032a1
movq %r14, %rdi
callq 0x4480
movq 0x98(%rbx), %r12
leaq 0xb5283(%rip), %rbx     # 0x104512
cmpq %r15, %r12
je 0x4f2b9
movl 0x20(%r12), %esi
movq %r14, %rdi
callq 0x4760
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4480
movq %r12, %rdi
callq 0x4300
movq %rax, %r12
jmp 0x4f28f
movq 0x100d30(%rip), %rbx    # 0x14fff0
leaq 0xb32b7(%rip), %r14     # 0x10257e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4480
leaq 0xb4349(%rip), %rsi     # 0x103622
movq %rbx, %rdi
callq 0x4480
movq %rax, %rdi
movq %r14, %rsi
callq 0x4480
pushq $0x1
popq %rdi
callq 0x524c
movq %rax, %rbx
movq %r14, %rdi
callq 0xb83e
leaq 0x10(%rsp), %rdi
callq 0xb290
movq %rbx, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voronoicell.cc
// Function: VOR_CELL::writeVMDFilled(std::basic_fstream<char, std::char_traits<char>>&, int)
void VOR_CELL::writeVMDFilled(fstream &output, int n){
  output << "set faces(" << n << ") {" << "\n"
	 << "{color $faceColors(" << n << ") }" << "\n";
  for(unsigned int i = 0; i < faces.size(); i++){
    faces[i].writeVMDFilled(output);
  }
  output << "}" << "\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsi), %rbx
leaq 0xb3f8d(%rip), %rsi     # 0x1032bd
movq %rbx, %rdi
callq 0x4480
movq %rax, %rdi
movl %ebp, %esi
callq 0x4760
leaq 0xb402f(%rip), %rsi     # 0x103378
movq %rax, %rdi
callq 0x4480
leaq 0xb3226(%rip), %r12     # 0x10257e
movq %rax, %rdi
movq %r12, %rsi
callq 0x4480
leaq 0xb3f5e(%rip), %rsi     # 0x1032c8
movq %rax, %rdi
callq 0x4480
movq %rax, %rdi
movl %ebp, %esi
callq 0x4760
leaq 0xb3f59(%rip), %rsi     # 0x1032dc
movq %rax, %rdi
callq 0x4480
movq %rax, %rdi
movq %r12, %rsi
callq 0x4480
xorl %eax, %eax
pushq $0x30
popq %r12
movl %eax, %r13d
movq (%r15), %rdi
movq 0x8(%r15), %rax
subq %rdi, %rax
cqto
idivq %r12
cmpq %r13, %rax
jbe 0x4f3c8
imulq $0x30, %r13, %rax
addq %rax, %rdi
movq %r14, %rsi
callq 0x4e83e
leal 0x1(%r13), %eax
jmp 0x4f39c
leaq 0xb3f0f(%rip), %rsi     # 0x1032de
movq %rbx, %rdi
callq 0x4480
leaq 0xb31a0(%rip), %rsi     # 0x10257e
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4480
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voronoicell.cc
// Function: VOR_CELL::getVoronoiCells(std::vector<VOR_CELL, std::allocator<VOR_CELL>>*, std::vector<std::vector<VOR_FACE, std::allocator<VOR_FACE>>, std::allocator<std::vector<VOR_FACE, std::allocator<VOR_FACE>>>>, ATOM_NETWORK*, VORONOI_NETWORK*)
void VOR_CELL::getVoronoiCells(vector<VOR_CELL> *cells, vector< vector<VOR_FACE> > faceInfo,
  ATOM_NETWORK *atmnet, VORONOI_NETWORK *vornet){
  cells->clear();
  for(unsigned int i = 0; i < faceInfo.size(); i++){
    VOR_CELL newCell;
    for(unsigned int j = 0; j < faceInfo[i].size(); j++)
      newCell.addFace(faceInfo[i][j]);
    cells->push_back(newCell);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rsi, %rbx
movq %rdi, (%rsp)
callq 0xb9a6
xorl %r13d, %r13d
leaq 0x40(%rsp), %r15
pushq $0x30
popq %rbp
leaq 0x10(%rsp), %r12
movl %r13d, %r13d
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
cmpq %r13, %rax
jbe 0x4f88a
movq %r15, %rdi
callq 0x4ea74
xorl %r14d, %r14d
movq %r13, 0x8(%rsp)
imulq $0x18, %r13, %r13
movl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r13), %rsi
movq 0x8(%rax,%r13), %rax
subq %rsi, %rax
cqto
idivq %rbp
cmpq %r14, %rax
jbe 0x4f869
imulq $0x30, %r14, %rax
addq %rax, %rsi
movq %r12, %rdi
callq 0xc87a
movq %r15, %rdi
movq %r12, %rsi
callq 0x4f02c
movq %r12, %rdi
callq 0xa71c
incl %r14d
jmp 0x4f826
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x51142
movq %r15, %rdi
callq 0xb450
movq 0x8(%rsp), %r13
incl %r13d
jmp 0x4f7fb
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4f8ad
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xa71c
jmp 0x4f8b0
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xb450
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voronoicell.cc
// Function: BASIC_VCELL::removeOverlappedNodes(int, ATOM_NETWORK*, double)
void BASIC_VCELL::removeOverlappedNodes(int atomID, ATOM_NETWORK *atmnet, double r_probe){
  vector<int> newIDs;
  vector<Point> newCoords;
  ATOM center = atmnet->atoms[atomID];
  for(unsigned int i = 0; i < nodeCoords.size(); i++){
    Point node  = nodeCoords[i];
    if(calcEuclideanDistance(node[0], node[1], node[2], center.x, center.y, center.z) >= 
		(center.radius + r_probe)){
      newIDs.push_back(nodeIDs[i]);
      newCoords.push_back(nodeCoords[i]);
    }
  }
  nodeIDs = newIDs; 
  nodeCoords = newCoords;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movsd %xmm0, 0x38(%rsp)
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movapd %xmm0, 0x20(%rsp)
andq $0x0, 0x30(%rsp)
movapd %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movslq %esi, %rax
imulq $0x98, %rax, %rsi
addq 0x2f0(%rdx), %rsi
leaq 0x70(%rsp), %rdi
callq 0xa75c
leaq 0x18(%rbx), %r14
xorl %ebp, %ebp
leaq 0x50(%rsp), %r15
pushq $0x2
popq %r12
movl %ebp, %ebp
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cmpq %rbp, %rax
jbe 0x4fadd
imulq $0x18, %rbp, %r13
movq 0x10(%rcx,%r13), %rax
movq %rax, 0x60(%rsp)
movupd (%rcx,%r13), %xmm0
movapd %xmm0, 0x50(%rsp)
movq %r15, %rdi
xorl %esi, %esi
callq 0x63c78
movsd (%rax), %xmm0
movsd %xmm0, 0x48(%rsp)
movq %r15, %rdi
pushq $0x1
popq %rsi
callq 0x63c78
movsd (%rax), %xmm0
movsd %xmm0, 0x40(%rsp)
movq %r15, %rdi
movl %r12d, %esi
callq 0x63c78
movsd (%rax), %xmm2
movsd 0x70(%rsp), %xmm3
movsd 0x78(%rsp), %xmm4
movsd 0x80(%rsp), %xmm5
movsd 0x48(%rsp), %xmm0
movsd 0x40(%rsp), %xmm1
callq 0x64934
movsd 0xa0(%rsp), %xmm1
addsd 0x38(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jb 0x4fad6
leaq (,%rbp,4), %rsi
addq (%r14), %rsi
leaq 0x20(%rsp), %rdi
callq 0x9434
addq (%rbx), %r13
movq %rsp, %rdi
movq %r13, %rsi
callq 0x2468e
incl %ebp
jmp 0x4fa09
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0xc178
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xc08e
leaq 0x70(%rsp), %rdi
callq 0xa808
movq %rsp, %rdi
callq 0xb83e
leaq 0x20(%rsp), %rdi
callq 0xb290
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x4fb37
jmp 0x4fb2a
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xa808
movq %rsp, %rdi
callq 0xb83e
leaq 0x20(%rsp), %rdi
callq 0xb290
movq %rbx, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voronoicell.cc
// Function: BASIC_VCELL::writeToVMD(std::basic_fstream<char, std::char_traits<char>>&, int)
void BASIC_VCELL::writeToVMD(fstream &output, int n){
  output << "set nodecells(" << n <<") {" << "\n";
  
  // Iterate over all nodes in the cell
  for(unsigned int i = 0; i < nodeCoords.size(); i++){
    Point curPoint = nodeCoords[i];
    int nodeID = nodeIDs[i];
    output << "{color $nodeColors(" << nodeID << ") }" << "\n"; 
    output << "{sphere {" << curPoint[0] << " " << curPoint[1] << " " << curPoint[2]
           << "} radius $nodeRadii(" << nodeID << ") resolution $sphere_resolution}" << "\n";
  }
  output << "}" << "\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %rax
movq %rdi, %r14
addq $0x10, %rax
leaq 0xb37e7(%rip), %rsi     # 0x10335a
movq %rax, 0x8(%rsp)
movq %rax, %rdi
callq 0x4480
movq %rax, %rdi
movl %ebp, %esi
callq 0x4760
leaq 0xb37e7(%rip), %rsi     # 0x103378
movq %rax, %rdi
callq 0x4480
leaq 0xb29de(%rip), %rsi     # 0x10257e
movq %rax, %rdi
callq 0x4480
xorl %eax, %eax
movl %eax, %r13d
movq (%r14), %rcx
movq 0x8(%r14), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cmpq %r13, %rax
jbe 0x4fce1
imulq $0x18, %r13, %rax
movq 0x10(%rcx,%rax), %rdx
movq %rdx, 0x20(%rsp)
movups (%rcx,%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x18(%r14), %rax
movl (%rax,%r13,4), %ebp
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
leaq 0xb36f8(%rip), %rsi     # 0x1032ee
callq 0x4480
movq %rax, %rdi
movl %ebp, %esi
callq 0x4760
movq %rax, %rdi
leaq 0xb36cd(%rip), %rsi     # 0x1032dc
callq 0x4480
movq %rax, %rdi
leaq 0xb2960(%rip), %rsi     # 0x10257e
callq 0x4480
movq %rbx, %rdi
leaq 0xb0826(%rip), %rsi     # 0x100453
callq 0x4480
movq %rax, %r15
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x63c78
movsd (%rax), %xmm0
movq %r15, %rdi
callq 0x46c0
movq %rax, %rdi
leaq 0xb48b8(%rip), %r12     # 0x104512
movq %r12, %rsi
callq 0x4480
movq %rax, %r15
movq %rbx, %rdi
pushq $0x1
popq %rsi
callq 0x63c78
movsd (%rax), %xmm0
movq %r15, %rdi
callq 0x46c0
movq %rax, %rdi
movq %r12, %rsi
callq 0x4480
movq %rax, %r15
movq %rbx, %rdi
pushq $0x2
popq %rsi
callq 0x63c78
movsd (%rax), %xmm0
movq %r15, %rdi
callq 0x46c0
movq %rax, %rdi
leaq 0xb3657(%rip), %rsi     # 0x103302
callq 0x4480
movq %rax, %rdi
movl %ebp, %esi
callq 0x4760
movq %rax, %rdi
leaq 0xb3653(%rip), %rsi     # 0x103317
callq 0x4480
movq %rax, %rdi
leaq 0xb28ab(%rip), %rsi     # 0x10257e
callq 0x4480
leal 0x1(%r13), %eax
jmp 0x4fbaa
leaq 0xb35f6(%rip), %rsi     # 0x1032de
movq 0x8(%rsp), %rdi
callq 0x4480
leaq 0xb2885(%rip), %rsi     # 0x10257e
movq %rax, %rdi
callq 0x4480
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/channel.cc
// Function: PORE::PORE()
PORE::PORE(){
    nodes = vector<DIJKSTRA_NODE> ();
    connections = vector<CONN> ();
    unitCells = vector<DELTA_POS> ();
    ucNodes = vector< vector<int> > ();
    dimensionality = 0;
    basis[0][0]=0;basis[0][1]=0;basis[0][2]=0;
    basis[1][0]=0;basis[1][1]=0;basis[1][2]=0;
    basis[2][0]=0;basis[2][1]=0;basis[2][2]=0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x38(%rdi), %rax
andl $0x0, 0x38(%rdi)
andq $0x0, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movq %rax, 0x50(%rdi)
leaq 0x60(%rdi), %r13
leaq 0x78(%rdi), %r12
leaq 0x90(%rdi), %r15
leaq 0xa8(%rdi), %r14
addq $0xc0, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x88(%rbx)
movups %xmm0, 0x98(%rbx)
movups %xmm0, 0xa8(%rbx)
andq $0x0, 0xb8(%rbx)
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0x6402e
leaq 0xd8(%rbx), %rdi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0x6402e
leaq 0xf0(%rbx), %rdi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0x6402e
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbp
movaps %xmm0, (%rbp)
andq $0x0, 0x10(%rbp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x2ac56
movq %rbp, %rdi
callq 0xae22
xorps %xmm0, %xmm0
movaps %xmm0, (%rbp)
andq $0x0, 0x10(%rbp)
leaq 0x10(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x2b9e2
movq %r13, %rdi
callq 0xaf14
xorps %xmm0, %xmm0
movaps %xmm0, (%r13)
andq $0x0, 0x10(%r13)
leaq 0x10(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x57c78
movq %r12, %rdi
callq 0xb758
xorps %xmm0, %xmm0
movaps %xmm0, (%r12)
andq $0x0, 0x10(%r12)
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x57cca
movq %r15, %rdi
callq 0xad7e
xorps %xmm0, %xmm0
movups %xmm0, 0x118(%rbx)
movups %xmm0, 0x108(%rbx)
andq $0x0, 0x128(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x8(%rsp)
leaq 0x30(%rbx), %rbp
movq %r14, %rdi
callq 0xad7e
movq %r15, %rdi
callq 0xb758
movq %r12, %rdi
callq 0xaf14
movq %r13, %rdi
callq 0xae22
movq %rbp, %rdi
callq 0xaf66
movq %rbx, %rdi
callq 0xaf66
movq 0x8(%rsp), %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/channel.cc
// Function: PORE::nodeIds()
vector <int> PORE::nodeIds(){
    vector <int> list;
    
    for(unsigned int i=0; i<reverseIDMappings.size(); i++)
    {
        list.push_back(reverseIDMappings.find(i)->second);
    };
    return list;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x30(%rsi), %r15
xorl %ebp, %ebp
leaq 0xc(%rsp), %r12
movl %ebp, %eax
cmpq %rax, 0x58(%r14)
jbe 0x52cc2
movl %ebp, 0xc(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x10996
addq $0x24, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9434
incl %ebp
jmp 0x52c98
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xb290
movq %r14, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/channel.cc
// Function: PORE::findChannelsAndPockets(VORONOI_NETWORK*, double, std::vector<bool, std::allocator<bool>>*, std::vector<PORE, std::allocator<PORE>>*)
void PORE::findChannelsAndPockets(VORONOI_NETWORK *vornet, double minRadius,
                                  vector<bool> *infoStorage, vector<PORE> *pores)
{
    //Remove edges that don't allow the provided particle diameter to
    //pass freely
    //VORONOI_NETWORK newNetwork;
    //pruneVoronoiNetwork(vornet, &newNetwork, minRadius);
    VORONOI_NETWORK newNetwork = vornet->prune(minRadius);
    
    //Build graph data structure
    DIJKSTRA_NETWORK dnet;
    DIJKSTRA_NETWORK::buildDijkstraNetwork(&newNetwork, &dnet);
    findChannelsAndPockets(&dnet, infoStorage, pores);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x8(%rsp), %rdx
movsd %xmm0, (%rdx)
leaq 0x70(%rsp), %rdi
callq 0x410b0
leaq 0x10(%rsp), %rdi
callq 0x3d70e
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3d7e6
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x52ce6
leaq 0x10(%rsp), %rdi
callq 0xae22
leaq 0x70(%rsp), %rdi
callq 0xa95c
addq $0xe8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x53742
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xae22
leaq 0x70(%rsp), %rdi
callq 0xa95c
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/channel.cc
// Function: ReconstructorComparator::compare(std::pair<int, DELTA_POS>, std::pair<int, DELTA_POS>)
bool ReconstructorComparator::compare(pair<int,DELTA_POS> p1, pair<int,DELTA_POS> p2) {
    bool p1Current = p1.second.equals(currentPos);
    bool p2Current = p2.second.equals(currentPos);
    if(p1Current && p2Current)
        return false;
    else if (p1Current)
        return false;
    else if (p2Current)
        return true;
    else{
        bool foundP1 = (positions.find(p1.second) != positions.end());
        bool foundP2 = (positions.find(p2.second) != positions.end());
        if(foundP1)
            return false;
        else
            return foundP2;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x14(%rsp), %r15
movq %rsi, -0x4(%r15)
movq %rdx, 0x4(%r15)
leaq 0x4(%rsp), %r14
movq %rcx, -0x4(%r14)
movq %r8, 0x4(%r14)
movq (%rdi), %rsi
movl 0x8(%rdi), %edx
movq %r15, %rdi
callq 0x3d332
movl %eax, %ebp
movq (%rbx), %rsi
movl 0x8(%rbx), %edx
movq %r14, %rdi
callq 0x3d332
movl %eax, %ecx
movl %ebp, %eax
xorb $0x1, %al
testb %bpl, %bpl
jne 0x54be2
testb %cl, %cl
jne 0x54be2
leaq 0x10(%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x587b4
addq $0x18, %rbx
cmpq %rbx, %rax
sete %bpl
movq %r12, %rdi
movq %r14, %rsi
callq 0x587b4
cmpq %rbx, %rax
setne %al
andb %bpl, %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/channel.cc
// Function: CHANNEL::CHANNEL(PORE*)
CHANNEL::CHANNEL(PORE *p){
    nodes = p->nodes;
    connections = p->connections;
    unitCells = p->unitCells;
    ucNodes = p->ucNodes;
    dimensionality = p->dimensionality;
    basis[0][0]=p->basis[0][0];basis[0][1]=p->basis[0][1];basis[0][2]=p->basis[0][2];
    basis[1][0]=p->basis[1][0];basis[1][1]=p->basis[1][1];basis[1][2]=p->basis[1][2];
    basis[2][0]=p->basis[2][0];basis[2][1]=p->basis[2][1];basis[2][2]=p->basis[2][2];
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5203c
leaq 0x60(%r14), %rsi
leaq 0x60(%rbx), %rdi
callq 0x2a87e
leaq 0x78(%r14), %rsi
leaq 0x78(%rbx), %rdi
callq 0x2a600
movl $0x90, %edi
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0x5781a
movl $0xa8, %edi
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0x57902
movl 0x108(%r14), %eax
movl %eax, 0x108(%rbx)
movl 0x10c(%r14), %eax
movl %eax, 0x10c(%rbx)
movl 0x110(%r14), %eax
movl %eax, 0x110(%rbx)
movl 0x114(%r14), %eax
movl %eax, 0x114(%rbx)
movl 0x118(%r14), %eax
movl %eax, 0x118(%rbx)
movl 0x11c(%r14), %eax
movl %eax, 0x11c(%rbx)
movl 0x120(%r14), %eax
movl %eax, 0x120(%rbx)
movl 0x124(%r14), %eax
movl %eax, 0x124(%rbx)
movl 0x128(%r14), %eax
movl %eax, 0x128(%rbx)
movl 0x12c(%r14), %eax
movl %eax, 0x12c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xb718
movq %r14, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/channel.cc
// Function: CHANNEL::findChannels(DIJKSTRA_NETWORK*, std::vector<bool, std::allocator<bool>>*, std::vector<CHANNEL, std::allocator<CHANNEL>>*)
void CHANNEL::findChannels(DIJKSTRA_NETWORK *dnet, vector<bool> *infoStorage,
                           vector<CHANNEL> *channels)
{
    
    vector <PORE> pores;
    findChannelsAndPockets(dnet, infoStorage, &pores);
    for(unsigned int i = 0; i<pores.size(); i++)
    {
        if(pores[i].dimensionality>0) channels->push_back(CHANNEL(&pores[i]));
    };
    pores.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rdx, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
callq 0x52ce6
xorl %r15d, %r15d
movl $0x130, %r12d           # imm = 0x130
leaq 0x18(%rsp), %r14
movl %r15d, %r15d
movq (%rsp), %rsi
movq 0x8(%rsp), %rax
subq %rsi, %rax
cqto
idivq %r12
cmpq %r15, %rax
jbe 0x55b2f
imulq $0x130, %r15, %rax      # imm = 0x130
cmpl $0x0, 0x108(%rsi,%rax)
jle 0x55b2a
addq %rax, %rsi
movq %r14, %rdi
callq 0x559c8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5928a
movq %r14, %rdi
callq 0xb718
incl %r15d
jmp 0x55ae2
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x579e0
movq %rbx, %rdi
callq 0xac66
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x55b62
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xb718
jmp 0x55b65
movq %rax, %rbx
movq %rsp, %rdi
callq 0xac66
movq %rbx, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/channel.cc
// Function: CHANNEL::findChannels(VORONOI_NETWORK*, double, std::vector<bool, std::allocator<bool>>*, std::vector<CHANNEL, std::allocator<CHANNEL>>*)
void CHANNEL::findChannels(VORONOI_NETWORK *vornet, double minRadius,
                           vector<bool> *infoStorage, vector<CHANNEL> *channels)
{
    vector <PORE> pores;
    findChannelsAndPockets(vornet, minRadius, infoStorage, &pores);
    for(unsigned int i = 0; i<pores.size(); i++)
    {
        if(pores[i].dimensionality>0) channels->push_back(CHANNEL(&pores[i]));
    };
    pores.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rdx, %rbx
xorps %xmm1, %xmm1
movq %rsp, %rdx
movaps %xmm1, (%rdx)
andq $0x0, 0x10(%rdx)
callq 0x536c2
xorl %r15d, %r15d
movl $0x130, %r12d           # imm = 0x130
leaq 0x18(%rsp), %r14
movl %r15d, %r15d
movq (%rsp), %rsi
movq 0x8(%rsp), %rax
subq %rsi, %rax
cqto
idivq %r12
cmpq %r15, %rax
jbe 0x55bf5
imulq $0x130, %r15, %rax      # imm = 0x130
cmpl $0x0, 0x108(%rsi,%rax)
jle 0x55bf0
addq %rax, %rsi
movq %r14, %rdi
callq 0x559c8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5928a
movq %r14, %rdi
callq 0xb718
incl %r15d
jmp 0x55ba8
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x579e0
movq %rbx, %rdi
callq 0xac66
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x55c28
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xb718
jmp 0x55c2b
movq %rax, %rbx
movq %rsp, %rdi
callq 0xac66
movq %rbx, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/channel.cc
// Function: CHANNEL::findBoundingAtoms(ATOM_NETWORK*, std::vector<BASIC_VCELL, std::allocator<BASIC_VCELL>>&, std::vector<int, std::allocator<int>>&)
void CHANNEL::findBoundingAtoms(ATOM_NETWORK *atmnet, vector<BASIC_VCELL> &vcells,
                                vector<int> &atomIDs)
{
    atomIDs.clear();
    
    for(unsigned int i = 0; i < vcells.size(); i++){
        BASIC_VCELL cell = vcells[i];
        for(int j = 0; j < cell.getNumNodes(); j++){
            if(idMappings.find(cell.getNodeID(j)) != idMappings.end()){
                atomIDs.push_back(i);
                break;
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x10(%rsp)
movq %rdi, %r15
movq (%rcx), %rax
cmpq %rax, 0x8(%rcx)
je 0x55c5f
movq %rax, 0x8(%rcx)
movq %rcx, 0x8(%rsp)
leaq 0x8(%r15), %rbx
xorl %r14d, %r14d
leaq 0x18(%rsp), %r12
leaq 0x4(%rsp), %r13
movl %r14d, %ecx
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rax
subq %rsi, %rax
cqto
pushq $0x30
popq %rdi
idivq %rdi
cmpq %rcx, %rax
jbe 0x55cf0
imulq $0x30, %rcx, %rax
addq %rax, %rsi
movq %r12, %rdi
callq 0xbf58
xorl %ebp, %ebp
movq %r12, %rdi
callq 0x4f970
cmpl %eax, %ebp
jge 0x55ce3
movq %r12, %rdi
movl %ebp, %esi
callq 0x4f99e
movl %eax, 0x4(%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x10996
incl %ebp
cmpq %rbx, %rax
je 0x55ca5
movl %r14d, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x10324
movq %r12, %rdi
callq 0xb3d4
incl %r14d
jmp 0x55c75
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x55d03
jmp 0x55d03
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xb3d4
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/channel.cc
// Function: CHANNEL::findFreeIncludedSphereDiameter()
pair<double, pair<double,double> > CHANNEL::findFreeIncludedSphereDiameter(){
    
    pair<double, pair<double,double> > maxdidfdif;
    maxdidfdif.first=0;
    maxdidfdif.second.first=0;
    maxdidfdif.second.second=0;
    
    
    for(int i=0;i<nodes.size();i++)
    {
        // loop over all the nodes in the current channel
        if(i==0) {
            maxdidfdif = findFreeIncludedSphereDiameterforNode(i, maxdidfdif);
        }
        else
        {
            pair<double, pair<double,double> > didfdif = findFreeIncludedSphereDiameterforNode(i, maxdidfdif);
            if(didfdif.second.first > maxdidfdif.second.first) maxdidfdif.second = didfdif.second;
            if(didfdif.first > maxdidfdif.first) maxdidfdif.first = didfdif.first;
        };
    };
    
    return maxdidfdif;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
xorpd %xmm1, %xmm1
xorl %r15d, %r15d
pushq $0x48
popq %r13
leaq 0x20(%rsp), %r12
xorpd %xmm2, %xmm2
movq 0x68(%r14), %rax
subq 0x60(%r14), %rax
cqto
idivq %r13
cmpq %r15, %rax
jbe 0x55e81
testq %r15, %r15
je 0x55e3f
movapd %xmm1, 0x50(%rsp)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %edx
movapd %xmm2, 0x40(%rsp)
callq 0x55e92
movapd 0x40(%rsp), %xmm2
movsd 0x28(%rsp), %xmm0
ucomisd %xmm2, %xmm0
jbe 0x55e23
movsd %xmm0, 0x8(%rbx)
movsd 0x30(%rsp), %xmm1
movsd %xmm1, 0x10(%rbx)
movapd %xmm0, %xmm2
movsd 0x20(%rsp), %xmm0
movapd 0x50(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x55e79
movsd %xmm0, (%rbx)
movapd %xmm0, %xmm1
jmp 0x55e79
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x55e92
movapd 0x20(%rsp), %xmm1
movupd %xmm1, (%rbx)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x10(%rbx)
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
incq %r15
jmp 0x55db8
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/channel.cc
// Function: PORE::getIncludedSphereDiameter()
double PORE::getIncludedSphereDiameter(){
    
    double maxdi;
    
    for(unsigned int i=0; i<nodes.size(); i++)
    {
        if(i==0)
        {
            maxdi = nodes.at(i).max_radius;
        }
        else{
            if(nodes.at(i).max_radius > maxdi) maxdi = nodes.at(i).max_radius;
        };
    };
    
    maxdi=maxdi*2.0;
    
    return maxdi;
    
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x60(%rdi), %r14
xorl %r15d, %r15d
pushq $0x48
popq %r12
movl %r15d, %r15d
movq 0x68(%rbx), %rax
subq 0x60(%rbx), %rax
cqto
idivq %r12
cmpq %r15, %rax
jbe 0x565b3
movq %r14, %rdi
movq %r15, %rsi
callq 0xabe2
movsd 0x38(%rax), %xmm0
testq %r15, %r15
je 0x565a9
ucomisd (%rsp), %xmm0
jbe 0x565ae
movq %r14, %rdi
movq %r15, %rsi
callq 0xabe2
movsd 0x38(%rax), %xmm0
movsd %xmm0, (%rsp)
incl %r15d
jmp 0x56568
movsd (%rsp), %xmm0
addsd %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq