LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Luthaf[P]zeopp/networkstorage.cc
// Function: ATOM_NETWORK::print(std::ostream&)
void ATOM_NETWORK::print(ostream &out){
    out << "Name: " << name << "\n"
    << "A: " << a <<"     B: " << b << "     C: " << c << "\n"
    << "Alpha: " << alpha <<"     Beta: " << beta << "     Gamma: " << gamma
    << "\n";
    out << "v_a: "; v_a.print();
    out << "v_b: "; v_b.print();
    out << "v_c: "; v_c.print();
    out << "Number of atoms: " << numAtoms << "\n";
    for(int i = 0; i<numAtoms; i++)
        atoms.at(i).print();
}

// 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)
movq -0x10(%rbp), %rdi
leaq 0x1612dd(%rip), %rsi    # 0x1f7a70
callq 0x5540
movq -0x20(%rbp), %rsi
movq %rax, %rdi
addq $0x320, %rsi            # imm = 0x320
callq 0x5480
movq %rax, %rdi
leaq 0x162e70(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, %rdi
leaq 0x16086e(%rip), %rsi    # 0x1f7032
callq 0x5540
movq %rax, %rdi
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x161293(%rip), %rsi    # 0x1f7a77
callq 0x5540
movq %rax, %rdi
movq -0x20(%rbp), %rax
movsd 0x10(%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x16127c(%rip), %rsi    # 0x1f7a80
callq 0x5540
movq %rax, %rdi
movq -0x20(%rbp), %rax
movsd 0x18(%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x162e01(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, %rdi
leaq 0x161256(%rip), %rsi    # 0x1f7a89
callq 0x5540
movq %rax, %rdi
movq -0x20(%rbp), %rax
movsd 0x20(%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x16123e(%rip), %rsi    # 0x1f7a91
callq 0x5540
movq %rax, %rdi
movq -0x20(%rbp), %rax
movsd 0x28(%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x16122a(%rip), %rsi    # 0x1f7a9d
callq 0x5540
movq %rax, %rdi
movq -0x20(%rbp), %rax
movsd 0x30(%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x162d92(%rip), %rsi    # 0x1f9625
callq 0x5540
movq -0x10(%rbp), %rdi
leaq 0x161207(%rip), %rsi    # 0x1f7aaa
callq 0x5540
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
movq 0x1dc709(%rip), %rsi    # 0x272fc0
callq 0xea920
movq -0x10(%rbp), %rdi
leaq 0x1611e9(%rip), %rsi    # 0x1f7ab0
callq 0x5540
movq -0x20(%rbp), %rdi
addq $0x50, %rdi
movq 0x1dc6e5(%rip), %rsi    # 0x272fc0
callq 0xea920
movq -0x10(%rbp), %rdi
leaq 0x1611cb(%rip), %rsi    # 0x1f7ab6
callq 0x5540
movq -0x20(%rbp), %rdi
addq $0x68, %rdi
movq 0x1dc6c1(%rip), %rsi    # 0x272fc0
callq 0xea920
movq -0x10(%rbp), %rdi
leaq 0x1611ad(%rip), %rsi    # 0x1f7abc
callq 0x5540
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl 0x110(%rax), %esi
callq 0x58d0
movq %rax, %rdi
leaq 0x162cf5(%rip), %rsi    # 0x1f9625
callq 0x5540
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x110(%rcx), %eax
jge 0x96979
movq -0x20(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movslq -0x14(%rbp), %rsi
callq 0xf090
movq %rax, %rdi
movq 0x1dc657(%rip), %rsi    # 0x272fc0
callq 0x95730
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9693c
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Luthaf[P]zeopp/networkstorage.cc
// Function: ATOM_NETWORK::abc_to_xyz(double, double, double) const
const Point ATOM_NETWORK::abc_to_xyz(double a, double b, double c) const {
    //Point xyzCoords;
    /*
     xyzCoords.x = a*cell->v_a.x+b*cell->v_b.x+c*cell->v_c.x;
     xyzCoords.y = a*cell->v_a.y+b*cell->v_b.y+c*cell->v_c.y;
     xyzCoords.z = a*cell->v_a.z+b*cell->v_b.z+c*cell->v_c.z;
     if(fabs(xyzCoords.x) < 0.00001) xyzCoords.x = 0;
     if(fabs(xyzCoords.y) < 0.00001) xyzCoords.y = 0;
     if(fabs(xyzCoords.z) < 0.00001) xyzCoords.z = 0;
     */
    
    // Use only non-zero elements in computation
    double xt = a*v_a.x+b*v_b.x+c*v_c.x;
    double yt = b*v_b.y+c*v_c.y;
    double zt = c*v_c.z;
    return Point(xt, yt, zt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rsi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd -0x10(%rbp), %xmm1
movsd 0x38(%rax), %xmm2
movsd -0x18(%rbp), %xmm0
mulsd 0x50(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
movsd 0x68(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x58(%rax), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd 0x70(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
mulsd 0x78(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
callq 0xe9c70
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Luthaf[P]zeopp/networkstorage.cc
// Function: ATOM_NETWORK::xyz_to_abc(double, double, double) const
const Point ATOM_NETWORK::xyz_to_abc(double xi, double yi, double zi) const{
    //Point abcCoords;
    /*
     abcCoords.x = x*cell->invUCVectors[0][0]+y*cell->invUCVectors[0][1]+z*cell->invUCVectors[0][2];
     abcCoords.y = x*cell->invUCVectors[1][0]+y*cell->invUCVectors[1][1]+z*cell->invUCVectors[1][2];
     abcCoords.z = x*cell->invUCVectors[2][0]+y*cell->invUCVectors[2][1]+z*cell->invUCVectors[2][2];
     if(fabs(abcCoords.x) < 0.0001) abcCoords.x = 0;
     if(fabs(abcCoords.y) < 0.0001) abcCoords.y = 0;
     if(fabs(abcCoords.z) < 0.0001) abcCoords.z = 0;
     */
    
    // Use only non-zero elements in computation
    double xt = xi*invUCVectors[0][0]+yi*invUCVectors[0][1]+zi*invUCVectors[0][2];
    double yt = yi*invUCVectors[1][1]+zi*invUCVectors[1][2];
    double zt = zi*invUCVectors[2][2];
    return Point(xt, yt, zt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rsi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd -0x10(%rbp), %xmm1
movsd 0xc8(%rax), %xmm2
movsd -0x18(%rbp), %xmm0
mulsd 0xd0(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
movsd 0xd8(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0xe8(%rax), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd 0xf0(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
mulsd 0x108(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
callq 0xe9c70
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Luthaf[P]zeopp/networkstorage.cc
// Function: get_unit_edge_length(ATOM_NETWORK*)
double get_unit_edge_length(ATOM_NETWORK *c) {
  int num_v = c->vertices.size();
  double unit_edge_length = -1;
  for(int i=0; i<num_v; i++) {
    VERTEX v = c->vertices.at(i);
    int num_e = v.edges.size();
    XYZ v_xyz = c->abc_to_xyz_returning_XYZ(v.abc);
    for(int j=0; j<num_e; j++) {
      XYZ e_xyz = c->abc_to_xyz_returning_XYZ(v.edges.at(j));
      double edge_length = (e_xyz-v_xyz).magnitude();
      if(unit_edge_length<0) unit_edge_length = edge_length;
      else if(fabs(unit_edge_length-edge_length)>DISTANCE_TOLERANCE) {
        printf("ERROR: found a basic edge length of %.3f which is sufficiently different to the previous length of %.3f; at the moment, nets with more than one edge length are not handled\n", edge_length, unit_edge_length);
        exit(EXIT_FAILURE);
      }
    }
  }
  return unit_edge_length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x3c0, %rdi            # imm = 0x3C0
callq 0xae470
movl %eax, -0xc(%rbp)
movsd 0x15b28e(%rip), %xmm0   # 0x1f2778
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x976ad
movq -0x8(%rbp), %rdi
addq $0x3c0, %rdi            # imm = 0x3C0
movslq -0x1c(%rbp), %rsi
callq 0xae4a0
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0xae4e0
leaq -0x70(%rbp), %rdi
callq 0xae590
movq -0x100(%rbp), %rdx
movl %eax, -0x94(%rbp)
movq -0x8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x97310
jmp 0x97554
movl $0x0, -0xc0(%rbp)
movl -0xc0(%rbp), %eax
cmpl -0x94(%rbp), %eax
jge 0x97693
movq -0x8(%rbp), %rax
movq %rax, -0x110(%rbp)
leaq -0x70(%rbp), %rdi
movslq -0xc0(%rbp), %rsi
callq 0xae5c0
movq %rax, -0x108(%rbp)
jmp 0x97594
movq -0x108(%rbp), %rdx
movq -0x110(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x97310
jmp 0x975b0
leaq -0xf8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0xeadf0
jmp 0x975cc
leaq -0xf8(%rbp), %rdi
callq 0xe9240
movsd %xmm0, -0x118(%rbp)
jmp 0x975e2
movsd -0x118(%rbp), %xmm0
movsd %xmm0, -0xe0(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x9762e
movsd -0xe0(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x9767d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x12650
jmp 0x976bb
movsd -0x18(%rbp), %xmm0
subsd -0xe0(%rbp), %xmm0
movaps 0x15aa3e(%rip), %xmm1   # 0x1f2080
pand %xmm1, %xmm0
movsd 0x16021a(%rip), %xmm1   # 0x1f7868
ucomisd %xmm1, %xmm0
jbe 0x9767b
movsd -0xe0(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
leaq 0x160486(%rip), %rdi    # 0x1f7aee
movb $0x2, %al
callq 0x5070
jmp 0x97671
movl $0x1, %edi
callq 0x67c0
jmp 0x9767d
jmp 0x9767f
movl -0xc0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc0(%rbp)
jmp 0x9755e
leaq -0x90(%rbp), %rdi
callq 0x12650
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x974f6
movsd -0x18(%rbp), %xmm0
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x58f0
nopw (%rax,%rax)
// File: Luthaf[P]zeopp/networkstorage.cc
// Function: ATOM_NETWORK::getClosestPointInABC(double, double, double, double, double, double)
const XYZ ATOM_NETWORK::getClosestPointInABC(double x1, double y1, double z1, double x2, double y2, double z2){
    Point abcCoordStatic = xyz_to_abc(x1, y1, z1);
    Point abcCoordMobile = xyz_to_abc(x2, y2, z2);
    XYZ answer;
    getDistCalc().closest_periodic_image(abcCoordStatic[0], abcCoordStatic[1], abcCoordStatic[2],
                                         abcCoordMobile[0], abcCoordMobile[1], abcCoordMobile[2],
                                         answer.x, answer.y, answer.z);
    return answer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x110(%rbp)
movq %rdi, -0x118(%rbp)
movq %rsi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movsd %xmm4, -0x30(%rbp)
movsd %xmm5, -0x38(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x108(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movsd -0x20(%rbp), %xmm2
leaq -0x50(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x97360
movq -0x108(%rbp), %rsi
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
leaq -0x68(%rbp), %rdi
callq 0x97360
movq -0x110(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xea8e0
movq -0x108(%rbp), %rsi
leaq -0xe0(%rbp), %rdi
callq 0x96bf0
movq -0x100(%rbp), %rdi
xorl %esi, %esi
callq 0xe9d70
movq %rax, -0xf8(%rbp)
jmp 0x97bb3
movq -0xf8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x128(%rbp)
leaq -0x50(%rbp), %rdi
movl $0x1, %esi
callq 0xe9d70
movq %rax, -0x120(%rbp)
jmp 0x97bdd
movq -0x120(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x138(%rbp)
leaq -0x50(%rbp), %rdi
movl $0x2, %esi
callq 0xe9d70
movq %rax, -0x130(%rbp)
jmp 0x97c07
movq -0x130(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x148(%rbp)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
callq 0xe9d70
movq %rax, -0x140(%rbp)
jmp 0x97c2e
movq -0x140(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x158(%rbp)
leaq -0x68(%rbp), %rdi
movl $0x1, %esi
callq 0xe9d70
movq %rax, -0x150(%rbp)
jmp 0x97c58
movq -0x150(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x168(%rbp)
leaq -0x68(%rbp), %rdi
movl $0x2, %esi
callq 0xe9d70
movq %rax, -0x160(%rbp)
jmp 0x97c82
movq -0x110(%rbp), %rsi
movsd -0x168(%rbp), %xmm4
movsd -0x158(%rbp), %xmm3
movsd -0x148(%rbp), %xmm2
movsd -0x138(%rbp), %xmm1
movsd -0x128(%rbp), %xmm0
movq -0x160(%rbp), %rax
movsd (%rax), %xmm5
movq %rsi, %rdx
addq $0x8, %rdx
movq %rsi, %rcx
addq $0x10, %rcx
leaq -0xe0(%rbp), %rdi
callq 0xd7df0
jmp 0x97cd8
leaq -0xe0(%rbp), %rdi
callq 0x122d0
movq -0x118(%rbp), %rax
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x122d0
movq -0xe8(%rbp), %rdi
callq 0x58f0
nop
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
addl $0x0, %eax
movslq %eax, %rsi
callq 0xaf450
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x5220
testb $0x1, -0x19(%rbp)
je 0xa789d
leaq -0x40(%rbp), %rdi
callq 0x5200
movq %rax, %rsi
leaq 0x152191(%rip), %rdi    # 0x1f9a12
xorl %eax, %eax
callq 0x5070
jmp 0xa788a
jmp 0xa789d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xa7930
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5220
jmp 0xa78ac
leaq -0x70(%rbp), %rdi
callq 0x16d830
movl %eax, -0x74(%rbp)
jmp 0xa78ba
leaq -0x70(%rbp), %rdi
callq 0x5300
movl -0x74(%rbp), %eax
movl %eax, -0x50(%rbp)
testb $0x1, -0x19(%rbp)
je 0xa78fb
movl -0x50(%rbp), %esi
leaq 0x15214f(%rip), %rdi    # 0x1f9a28
xorl %eax, %eax
callq 0x5070
jmp 0xa78e2
jmp 0xa78fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x5300
jmp 0xa7930
movl -0x50(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x438(%rax)
movq -0x18(%rbp), %rdi
addq $0x440, %rdi            # imm = 0x440
leaq -0x40(%rbp), %rsi
callq 0x5060
jmp 0xa791e
leaq -0x40(%rbp), %rdi
callq 0x5300
addq $0x80, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x5300
movq -0x48(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x11(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x52a0
movq -0x50(%rbp), %rdi
callq 0x84df0
movl $0x0, -0x18(%rbp)
movq -0x58(%rbp), %rdi
movl -0x18(%rbp), %eax
movq %rax, -0x68(%rbp)
callq 0x17c60
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0xbb8d8
movq -0x58(%rbp), %rdi
addq $0x18, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0xed60
movq -0x58(%rbp), %rdi
movq %rax, -0x70(%rbp)
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x5c150
movq -0x70(%rbp), %rsi
movq %rax, %rdx
leaq -0x38(%rbp), %rdi
callq 0x84e40
jmp 0xbb8a5
movq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x84e10
jmp 0xbb8b4
jmp 0xbb8b6
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xbb853
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x84e80
jmp 0xbb8f5
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xbb8eb
movq -0x50(%rbp), %rdi
callq 0x84e80
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x58f0
nop
// File: 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
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xc8(%rbp)
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
movb $0x0, -0x11(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x52a0
movq -0xc8(%rbp), %rdi
callq 0xbf6a0
movl $0x0, -0x18(%rbp)
movq -0xd0(%rbp), %rdi
movl -0x18(%rbp), %eax
movq %rax, -0xe0(%rbp)
callq 0x17c60
movq %rax, %rcx
movq -0xe0(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0xbba19
movq -0xd0(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x5c150
movq -0xd0(%rbp), %rdi
movq 0x10(%rax), %rcx
movq %rcx, -0x20(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0x30(%rbp)
movl -0x18(%rbp), %eax
incl %eax
movl %eax, %esi
callq 0x5c150
movq 0x10(%rax), %rcx
movq %rcx, -0x40(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0x50(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0xbf6f0
jmp 0xbb9d4
movq -0xc8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xbf6c0
jmp 0xbb9e6
jmp 0xbb9e8
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xbb952
movq -0xc8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
callq 0xbf740
jmp 0xbbaa1
movq -0xd0(%rbp), %rdi
callq 0x17c60
movq -0xd0(%rbp), %rdi
movq %rax, %rsi
decq %rsi
callq 0x5c150
movq -0xd0(%rbp), %rdi
movq %rax, -0xe8(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x5c150
movq -0xe8(%rbp), %rsi
movq %rax, %rdx
leaq -0xc0(%rbp), %rdi
callq 0xbf6f0
jmp 0xbba66
movq -0xc8(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0xbf6c0
jmp 0xbba7b
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xbba91
movq -0xc8(%rbp), %rdi
callq 0xbf740
movq -0xd8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x58f0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x128(%rbp)
movq %rdi, %rax
movq %rax, -0x160(%rbp)
callq 0xbf7a0
movq -0x128(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x158(%rbp)
callq 0xbf7c0
movq -0x128(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x150(%rbp)
callq 0xf6b0
movq -0x128(%rbp), %rdi
subq $-0x80, %rdi
movq %rdi, -0x148(%rbp)
callq 0xbf7e0
movq -0x128(%rbp), %rdi
addq $0xb0, %rdi
movq %rdi, -0x140(%rbp)
callq 0xbf800
movq -0x128(%rbp), %rdi
addq $0xe0, %rdi
movq %rdi, -0x138(%rbp)
callq 0x655d0
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0xbf7a0
movq -0x130(%rbp), %rsi
movq -0x128(%rbp), %rdi
callq 0x1dc30
movq -0x130(%rbp), %rdi
callq 0x13c30
movq -0x128(%rbp), %rax
movl $0x0, 0x18(%rax)
leaq 0x2e7cb(%rip), %rax     # 0xea630
movq %rax, -0x58(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0xbf820
movq -0x120(%rbp), %rdx
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xbf840
jmp 0xbbe8f
movq -0x160(%rbp), %rdi
addq $0x20, %rdi
leaq -0x50(%rbp), %rsi
callq 0x1dc60
leaq -0x50(%rbp), %rdi
callq 0x13c10
leaq -0x59(%rbp), %rdi
callq 0xbf8c0
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x52a0
leaq -0xa0(%rbp), %rdi
callq 0xf6b0
movq -0x160(%rbp), %rdi
addq $0x50, %rdi
leaq -0xa0(%rbp), %rsi
callq 0x1dc90
leaq -0xa0(%rbp), %rdi
callq 0xf860
leaq -0xd0(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x52a0
leaq -0xd0(%rbp), %rdi
callq 0xbf7e0
movq -0x160(%rbp), %rdi
addq $0x80, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x1dcc0
leaq -0xd0(%rbp), %rdi
callq 0x13bf0
leaq -0x100(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x52a0
leaq -0x100(%rbp), %rdi
callq 0xbf800
movq -0x160(%rbp), %rdi
addq $0xb0, %rdi
leaq -0x100(%rbp), %rsi
callq 0x1dcf0
leaq -0x100(%rbp), %rdi
callq 0x13bd0
leaq -0x118(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x52a0
leaq -0x118(%rbp), %rdi
callq 0x655d0
movq -0x160(%rbp), %rdi
addq $0xe0, %rdi
leaq -0x118(%rbp), %rsi
callq 0x1dd20
leaq -0x118(%rbp), %rdi
callq 0x13b70
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x59(%rbp), %rdi
callq 0xbf8c0
movq -0x138(%rbp), %rdi
callq 0x13b70
movq -0x140(%rbp), %rdi
callq 0x13bd0
movq -0x148(%rbp), %rdi
callq 0x13bf0
movq -0x150(%rbp), %rdi
callq 0xf860
movq -0x158(%rbp), %rdi
callq 0x13c10
movq -0x128(%rbp), %rdi
callq 0x13c30
movq -0x68(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rsi, -0x118(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0xbfc00
movq -0x118(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xbb810
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq %rax, -0x128(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x84600
movq %rax, %rcx
movq -0x128(%rbp), %rax
cmpq %rcx, %rax
jae 0xbc7a1
movl -0x2c(%rbp), %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0x84620
movq -0x120(%rbp), %rdi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movaps %xmm1, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movl -0x50(%rbp), %esi
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
movups -0x48(%rbp), %xmm0
movaps %xmm0, -0x70(%rbp)
movq -0x60(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movaps -0x70(%rbp), %xmm0
movups %xmm0, (%rax)
callq 0xbc040
jmp 0xbc783
jmp 0xbc785
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xbc711
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xbc8e2
movq -0x118(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0xbb900
jmp 0xbc7b6
movl $0x0, -0x9c(%rbp)
movl -0x9c(%rbp), %eax
movq %rax, -0x130(%rbp)
leaq -0x98(%rbp), %rdi
callq 0xbfc70
movq %rax, %rcx
movq -0x130(%rbp), %rax
cmpq %rcx, %rax
jae 0xbc8c4
movl -0x9c(%rbp), %eax
movl %eax, %esi
leaq -0x98(%rbp), %rdi
callq 0xbfca0
movq -0x120(%rbp), %rdi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movaps %xmm2, -0xb0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm0, -0xd0(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0xe0(%rbp)
movaps -0xd0(%rbp), %xmm0
movaps %xmm0, -0xf0(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0x100(%rbp)
movups -0xb8(%rbp), %xmm0
movaps %xmm0, -0x110(%rbp)
movq -0x100(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x28(%rax)
movaps -0x110(%rbp), %xmm0
movups %xmm0, 0x18(%rax)
movq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
movaps -0xf0(%rbp), %xmm0
movups %xmm0, (%rax)
callq 0xbc390
jmp 0xbc894
jmp 0xbc896
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9c(%rbp)
jmp 0xbc7c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0xbf740
jmp 0xbc8e2
leaq -0x98(%rbp), %rdi
callq 0xbf740
leaq -0x28(%rbp), %rdi
callq 0x84e80
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x84e80
movq -0x78(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq 0x13e400(%rip), %rsi    # 0x1fafda
callq 0x5540
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x58d0
movq %rax, %rdi
leaq 0x13e4a1(%rip), %rsi    # 0x1fb095
callq 0x5540
movq %rax, %rdi
leaq 0x13ca22(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, %rdi
leaq 0x13e3d3(%rip), %rsi    # 0x1fafe5
callq 0x5540
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x58d0
movq %rax, %rdi
leaq 0x13e3cd(%rip), %rsi    # 0x1faff9
callq 0x5540
movq %rax, %rdi
leaq 0x13c9ea(%rip), %rsi    # 0x1f9625
callq 0x5540
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %eax
movq %rax, -0x28(%rbp)
callq 0x19e90
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0xbcc88
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0xbfdb0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xbbab0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xbcc47
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq 0x13e364(%rip), %rsi    # 0x1faffb
callq 0x5540
movq %rax, %rdi
leaq 0x13c97f(%rip), %rsi    # 0x1f9625
callq 0x5540
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rsi, -0x170(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x15be0
movl $0x0, -0x24(%rbp)
movq -0x170(%rbp), %rdi
movl -0x24(%rbp), %eax
movq %rax, -0x178(%rbp)
callq 0xbfeb0
movq %rax, %rcx
movq -0x178(%rbp), %rax
cmpq %rcx, %rax
jae 0xbd31f
leaq -0x120(%rbp), %rdi
callq 0xbbd70
movl $0x0, -0x124(%rbp)
movq -0x170(%rbp), %rdi
movl -0x124(%rbp), %eax
movq %rax, -0x180(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0xbfee0
movq %rax, %rdi
callq 0x19e90
movq %rax, %rcx
movq -0x180(%rbp), %rax
cmpq %rcx, %rax
jae 0xbd2e5
movq -0x170(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0xbfee0
movq %rax, %rdi
movl -0x124(%rbp), %eax
movl %eax, %esi
callq 0xbfdb0
movq %rax, %rsi
leaq -0x158(%rbp), %rdi
callq 0x1a3e0
jmp 0xbd27c
leaq -0x120(%rbp), %rdi
leaq -0x158(%rbp), %rsi
callq 0xbc6d0
jmp 0xbd291
leaq -0x158(%rbp), %rdi
callq 0xefb0
movl -0x124(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x124(%rbp)
jmp 0xbd211
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
jmp 0xbd311
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
leaq -0x158(%rbp), %rdi
callq 0xefb0
jmp 0xbd311
movq -0x8(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0xbff00
jmp 0xbd2f7
leaq -0x120(%rbp), %rdi
callq 0x13b00
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xbd1d2
leaq -0x120(%rbp), %rdi
callq 0x13b00
jmp 0xbd328
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
movq -0x160(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq 0x13d8ad(%rip), %rsi    # 0x1fb077
callq 0x5540
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x58d0
movq %rax, %rdi
leaq 0x13d8b1(%rip), %rsi    # 0x1fb095
callq 0x5540
movq %rax, %rdi
leaq 0x13be32(%rip), %rsi    # 0x1f9625
callq 0x5540
movl $0x0, -0x18(%rbp)
movq -0x40(%rbp), %rdi
movl -0x18(%rbp), %eax
movq %rax, -0x48(%rbp)
callq 0x17c60
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0xbd96a
movq -0x40(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x5c150
movq -0x40(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0xed60
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq 0x13d7a1(%rip), %rsi    # 0x1fb00b
callq 0x5540
movq %rax, %rdi
movl -0x34(%rbp), %esi
callq 0x58d0
movq %rax, %rdi
leaq 0x13d775(%rip), %rsi    # 0x1faff9
callq 0x5540
movq %rax, %rdi
leaq 0x13bd92(%rip), %rsi    # 0x1f9625
callq 0x5540
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq 0x138c34(%rip), %rsi    # 0x1f64db
callq 0x5540
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0xe9d70
movq -0x60(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x13e9dc(%rip), %rsi    # 0x1fc2ae
callq 0x5540
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0xe9d70
movq -0x58(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x13e9ae(%rip), %rsi    # 0x1fc2ae
callq 0x5540
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0xe9d70
movq -0x50(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x13d6f1(%rip), %rsi    # 0x1fb01f
callq 0x5540
movq %rax, %rdi
movl -0x34(%rbp), %esi
callq 0x58d0
movq %rax, %rdi
leaq 0x13d6ec(%rip), %rsi    # 0x1fb034
callq 0x5540
movq %rax, %rdi
leaq 0x13bcce(%rip), %rsi    # 0x1f9625
callq 0x5540
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xbd7ff
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq 0x13d682(%rip), %rsi    # 0x1faffb
callq 0x5540
movq %rax, %rdi
leaq 0x13bc9d(%rip), %rsi    # 0x1f9625
callq 0x5540
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
callq 0xf6b0
movq -0x80(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0xa8(%rbp)
callq 0xf6b0
movq -0x80(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0xa0(%rbp)
callq 0x64310
movq -0x80(%rbp), %rdi
addq $0x78, %rdi
movq %rdi, -0x98(%rbp)
callq 0x64770
movq -0x80(%rbp), %rdi
addq $0x90, %rdi
movq %rdi, -0x90(%rbp)
callq 0x658a0
movq -0x80(%rbp), %rdi
addq $0xa8, %rdi
movq %rdi, -0x88(%rbp)
callq 0x10580
movq -0x80(%rbp), %rdi
addq $0xc0, %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xea8e0
jmp 0xc405b
movq -0xb0(%rbp), %rdi
addq $0xd8, %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xea8e0
jmp 0xc4079
movq -0xb0(%rbp), %rdi
addq $0xf0, %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xea8e0
jmp 0xc4097
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x52a0
leaq -0x30(%rbp), %rdi
callq 0x64310
movq -0xb0(%rbp), %rdi
addq $0x60, %rdi
leaq -0x30(%rbp), %rsi
callq 0x64330
leaq -0x30(%rbp), %rdi
callq 0x10e40
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x52a0
leaq -0x48(%rbp), %rdi
callq 0x64770
movq -0xb0(%rbp), %rdi
addq $0x78, %rdi
leaq -0x48(%rbp), %rsi
callq 0x6c840
leaq -0x48(%rbp), %rdi
callq 0x11230
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x52a0
leaq -0x60(%rbp), %rdi
callq 0x658a0
movq -0xb0(%rbp), %rdi
addq $0x90, %rdi
leaq -0x60(%rbp), %rsi
callq 0xcd110
leaq -0x60(%rbp), %rdi
callq 0x14c80
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x52a0
leaq -0x78(%rbp), %rdi
callq 0x10580
movq -0xb0(%rbp), %rdi
addq $0xa8, %rdi
leaq -0x78(%rbp), %rsi
callq 0xcd140
leaq -0x78(%rbp), %rdi
callq 0x108b0
movq -0xb0(%rbp), %rax
movl $0x0, 0x108(%rax)
movl $0x0, 0x10c(%rax)
movl $0x0, 0x110(%rax)
movl $0x0, 0x114(%rax)
movl $0x0, 0x118(%rax)
movl $0x0, 0x11c(%rax)
movl $0x0, 0x120(%rax)
movl $0x0, 0x124(%rax)
movl $0x0, 0x128(%rax)
movl $0x0, 0x12c(%rax)
addq $0xb0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x108b0
movq -0x90(%rbp), %rdi
callq 0x14c80
movq -0x98(%rbp), %rdi
callq 0x11230
movq -0xa0(%rbp), %rdi
callq 0x10e40
movq -0xa8(%rbp), %rdi
callq 0xf860
movq -0x80(%rbp), %rdi
callq 0xf860
movq -0x10(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xd0d0
movl $0x0, -0x18(%rbp)
movq -0x40(%rbp), %rdi
movl -0x18(%rbp), %eax
movq %rax, -0x58(%rbp)
addq $0x30, %rdi
callq 0x10400
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0xc5597
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x102e0
movq %rax, -0x60(%rbp)
jmp 0xc5550
movq -0x60(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x10350
movq -0x50(%rbp), %rdi
movq %rax, %rsi
addq $0x4, %rsi
callq 0xd1b0
jmp 0xc5573
jmp 0xc5575
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xc5513
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xec80
jmp 0xc55b4
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xc55aa
movq -0x50(%rbp), %rdi
callq 0xec80
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x58f0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x98(%rbp), %rdi
leaq -0x10(%rbp), %rdx
callq 0x9ab40
leaq -0xf8(%rbp), %rdi
callq 0x94790
jmp 0xc677e
leaq -0x98(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0x948c0
jmp 0xc6793
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0xf8(%rbp), %rdi
callq 0xc55c0
jmp 0xc67a9
leaq -0xf8(%rbp), %rdi
callq 0xf840
leaq -0x98(%rbp), %rdi
callq 0xf8a0
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
jmp 0xc67fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0xf840
leaq -0x98(%rbp), %rdi
callq 0xf8a0
movq -0x100(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x14(%rbp)
movq %rdx, -0xc(%rbp)
movq %rcx, -0x24(%rbp)
movq %r8, -0x1c(%rbp)
movq %rdi, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x14(%rbp), %rdi
addq $0x4, %rdi
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x50(%rbp), %rsi
movl -0x48(%rbp), %edx
callq 0x94040
movb %al, %cl
movq -0xa8(%rbp), %rax
andb $0x1, %cl
movb %cl, -0x31(%rbp)
leaq -0x24(%rbp), %rdi
addq $0x4, %rdi
movq (%rax), %rcx
movq %rcx, -0x60(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
movl -0x58(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x70(%rbp), %rsi
movl -0x68(%rbp), %edx
callq 0x94040
andb $0x1, %al
movb %al, -0x51(%rbp)
testb $0x1, -0x31(%rbp)
je 0xc8791
testb $0x1, -0x51(%rbp)
je 0xc8791
movb $0x0, -0x1(%rbp)
jmp 0xc885f
testb $0x1, -0x31(%rbp)
je 0xc87a0
movb $0x0, -0x1(%rbp)
jmp 0xc885f
testb $0x1, -0x51(%rbp)
je 0xc87af
movb $0x1, -0x1(%rbp)
jmp 0xc885f
movq -0xa8(%rbp), %rdi
addq $0x10, %rdi
leaq -0x14(%rbp), %rsi
addq $0x4, %rsi
callq 0xcd7b0
movq -0xa8(%rbp), %rdi
movq %rax, -0x80(%rbp)
addq $0x10, %rdi
callq 0x65ee0
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x65eb0
movq -0xa8(%rbp), %rdi
andb $0x1, %al
movb %al, -0x71(%rbp)
addq $0x10, %rdi
leaq -0x24(%rbp), %rsi
addq $0x4, %rsi
callq 0xcd7b0
movq -0xa8(%rbp), %rdi
movq %rax, -0x98(%rbp)
addq $0x10, %rdi
callq 0x65ee0
movq %rax, -0xa0(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x65eb0
andb $0x1, %al
movb %al, -0x89(%rbp)
testb $0x1, -0x71(%rbp)
je 0xc8854
movb $0x0, -0x1(%rbp)
jmp 0xc885f
movb -0x89(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xc3fb0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
addq $0x60, %rdi
callq 0x67730
jmp 0xc9a64
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x78, %rsi
addq $0x78, %rdi
callq 0x661c0
jmp 0xc9a7b
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x90, %rsi
addq $0x90, %rdi
callq 0xcde00
jmp 0xc9a98
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0xa8, %rsi
addq $0xa8, %rdi
callq 0xce050
jmp 0xc9ab5
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x108(%rcx), %ecx
movl %ecx, 0x108(%rax)
movq -0x10(%rbp), %rcx
movl 0x10c(%rcx), %ecx
movl %ecx, 0x10c(%rax)
movq -0x10(%rbp), %rcx
movl 0x110(%rcx), %ecx
movl %ecx, 0x110(%rax)
movq -0x10(%rbp), %rcx
movl 0x114(%rcx), %ecx
movl %ecx, 0x114(%rax)
movq -0x10(%rbp), %rcx
movl 0x118(%rcx), %ecx
movl %ecx, 0x118(%rax)
movq -0x10(%rbp), %rcx
movl 0x11c(%rcx), %ecx
movl %ecx, 0x11c(%rax)
movq -0x10(%rbp), %rcx
movl 0x120(%rcx), %ecx
movl %ecx, 0x120(%rax)
movq -0x10(%rbp), %rcx
movl 0x124(%rcx), %ecx
movl %ecx, 0x124(%rax)
movq -0x10(%rbp), %rcx
movl 0x128(%rcx), %ecx
movl %ecx, 0x128(%rax)
movq -0x10(%rbp), %rcx
movl 0x12c(%rcx), %ecx
movl %ecx, 0x12c(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x14c10
movq -0x18(%rbp), %rdi
callq 0x58f0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x178(%rbp)
callq 0x10210
movq -0x178(%rbp), %rdx
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc55c0
jmp 0xc9bbd
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
movq %rax, -0x180(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10230
movq %rax, %rcx
movq -0x180(%rbp), %rax
cmpq %rcx, %rax
jae 0xc9c86
movl -0x40(%rbp), %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x10260
cmpl $0x0, 0x108(%rax)
jle 0xc9c76
movq -0x18(%rbp), %rax
movq %rax, -0x188(%rbp)
movl -0x40(%rbp), %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x10260
movq %rax, %rsi
leaq -0x170(%rbp), %rdi
callq 0xc9a30
jmp 0xc9c2b
movq -0x188(%rbp), %rdi
leaq -0x170(%rbp), %rsi
callq 0xce2a0
jmp 0xc9c40
leaq -0x170(%rbp), %rdi
callq 0x86880
jmp 0xc9c76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xc9ca1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x170(%rbp), %rdi
callq 0x86880
jmp 0xc9ca1
jmp 0xc9c78
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0xc9bc4
leaq -0x30(%rbp), %rdi
callq 0xce2d0
leaq -0x30(%rbp), %rdi
callq 0x10520
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x10520
movq -0x38(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x180(%rbp)
callq 0x10210
movq -0x180(%rbp), %rdx
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rsi
callq 0xc6740
jmp 0xc9d07
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
movq %rax, -0x188(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x10230
movq %rax, %rcx
movq -0x188(%rbp), %rax
cmpq %rcx, %rax
jae 0xc9dd0
movl -0x48(%rbp), %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
callq 0x10260
cmpl $0x0, 0x108(%rax)
jle 0xc9dc0
movq -0x20(%rbp), %rax
movq %rax, -0x190(%rbp)
movl -0x48(%rbp), %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
callq 0x10260
movq %rax, %rsi
leaq -0x178(%rbp), %rdi
callq 0xc9a30
jmp 0xc9d75
movq -0x190(%rbp), %rdi
leaq -0x178(%rbp), %rsi
callq 0xce2a0
jmp 0xc9d8a
leaq -0x178(%rbp), %rdi
callq 0x86880
jmp 0xc9dc0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xc9deb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x178(%rbp), %rdi
callq 0x86880
jmp 0xc9deb
jmp 0xc9dc2
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0xc9d0e
leaq -0x38(%rbp), %rdi
callq 0xce2d0
leaq -0x38(%rbp), %rdi
callq 0x10520
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x10520
movq -0x40(%rbp), %rdi
callq 0x58f0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rdi
callq 0x163b0
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16550
movq %rax, %rcx
movq -0xa0(%rbp), %rax
cmpq %rcx, %rax
jae 0xc9f7e
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x162f0
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0x17040
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movl %eax, -0xa8(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xbd460
movl %eax, -0xa4(%rbp)
jmp 0xc9e97
movl -0xa8(%rbp), %eax
movl -0xa4(%rbp), %ecx
cmpl %ecx, %eax
jge 0xc9f67
movq -0x98(%rbp), %rax
movq %rax, -0xb8(%rbp)
movl -0x5c(%rbp), %esi
leaq -0x58(%rbp), %rdi
callq 0xbd4d0
movl %eax, -0xac(%rbp)
jmp 0xc9ecd
movq -0xb8(%rbp), %rdi
movl -0xac(%rbp), %eax
movl %eax, -0x7c(%rbp)
leaq -0x7c(%rbp), %rsi
callq 0x102e0
movq %rax, -0xc0(%rbp)
jmp 0xc9eef
movq -0x98(%rbp), %rdi
movq -0xc0(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x658c0
movq %rax, -0x88(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xaed30
testb $0x1, %al
jne 0xc9f23
jmp 0xc9f57
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, -0x8c(%rbp)
leaq -0x8c(%rbp), %rsi
callq 0xffc0
jmp 0xc9f3e
jmp 0xc9f67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x138c0
jmp 0xc9f87
jmp 0xc9f59
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0xc9e7d
leaq -0x58(%rbp), %rdi
callq 0x138c0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc9e36
addq $0xc0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x58f0