LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/graphstorage.cc
// Function: DIJKSTRA_NETWORK::filterDnetEdges(std::vector<int, std::allocator<int>>, VORONOI_NETWORK*, DIJKSTRA_NETWORK*)
void DIJKSTRA_NETWORK::filterDnetEdges(vector<int> nodeIDs,
                                       VORONOI_NETWORK *origVornet,
                                       DIJKSTRA_NETWORK *newDnet){
    //VORONOI_NETWORK newVorNet;
    //VORONOI_NETWORK::filterVornetEdges(nodeIDs, origVornet, &newVorNet);
    VORONOI_NETWORK newVorNet = origVornet->filterEdges(nodeIDs);
    DIJKSTRA_NETWORK::buildDijkstraNetwork(&newVorNet, newDnet);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0xe886
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x55766
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x511c6
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x50fc8
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x511ed
movq 0x88(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq 0x60(%rsp), %rdi
callq 0xf1b8
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xeab8
jmp 0x5122c
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5122c
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/networkstorage.cc
// Function: ATOM::ATOM()
ATOM::ATOM() {
  type = "";
  label = "";
  radius = 0;
  charge = 0; //because this is not always provided, a default value of zero is set
  keep = true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r15
leaq 0x40(%rdi), %rbx
leaq 0x50(%rdi), %r14
movq %r14, 0x40(%rdi)
xorl %eax, %eax
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x60(%rdi), %r12
leaq 0x70(%rdi), %r13
movq %r13, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movb %al, 0x70(%rdi)
leaq 0xfed1c(%rip), %rcx     # 0x150383
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x4670
movq 0x68(%r15), %rdx
leaq 0xfed02(%rip), %rcx     # 0x150383
movq %r12, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x4670
xorl %eax, %eax
movq %rax, 0x30(%r15)
movq %rax, 0x88(%r15)
movb $0x1, 0x90(%r15)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x516c5
movq (%r13), %rsi
incq %rsi
callq 0x4470
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e7b
movq %r15, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/networkstorage.cc
// Function: ATOM::ATOM(XYZ, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double)
ATOM::ATOM(XYZ xyz, string s, double r) {
  x = xyz.x;
  y = xyz.y;
  z = xyz.z;
  type = s;
  label = s;
  radius = r;
  charge = 0;
  keep = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rsi, %r12
movq %rdi, %r15
leaq 0x40(%rdi), %rbx
leaq 0x50(%rdi), %r14
movq %r14, 0x40(%rdi)
xorl %eax, %eax
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x60(%rdi), %r13
leaq 0x70(%rdi), %rbp
movq %rbp, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movb %al, 0x70(%rdi)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, (%rdi)
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x10(%rdi)
movq %rbx, %rdi
callq 0x4240
movq %r13, %rdi
movq %r12, %rsi
callq 0x4240
movsd (%rsp), %xmm0
movsd %xmm0, 0x30(%r15)
movq $0x0, 0x88(%r15)
movb $0x1, 0x90(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r13), %rdi
cmpq %rbp, %rdi
je 0x5178e
movq (%rbp), %rsi
incq %rsi
callq 0x4470
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e8f
movq %r15, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/networkstorage.cc
// Function: ATOM::ATOM(XYZ, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double)
ATOM::ATOM(XYZ xyz, string s, string l, double r) {
  x = xyz.x;
  y = xyz.y;
  z = xyz.z;
  type = s;
  label = l;
  radius = r;
  charge = 0;
  keep = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rdx, %r12
movq %rdi, %r15
leaq 0x40(%rdi), %rbx
leaq 0x50(%rdi), %r14
movq %r14, 0x40(%rdi)
xorl %eax, %eax
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x60(%rdi), %r13
leaq 0x70(%rdi), %rbp
movq %rbp, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movb %al, 0x70(%rdi)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, (%rdi)
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x10(%rdi)
movq %rbx, %rdi
callq 0x4240
movq %r13, %rdi
movq %r12, %rsi
callq 0x4240
movsd (%rsp), %xmm0
movsd %xmm0, 0x30(%r15)
movq $0x0, 0x88(%r15)
movb $0x1, 0x90(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r13), %rdi
cmpq %rbp, %rdi
je 0x51858
movq (%rbp), %rsi
incq %rsi
callq 0x4470
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4ea3
movq %r15, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/networkstorage.cc
// Function: ATOM_NETWORK::update_atom_fractional_coords()
void ATOM_NETWORK::update_atom_fractional_coords() {
  for(int i=0; i<numAtoms; i++) {
    XYZ xyz(atoms.at(i).x, atoms.at(i).y, atoms.at(i).z);
    XYZ abc = trans_to_origuc(xyz_to_abc_returning_XYZ(xyz));
    atoms.at(i).a_coord = abc.x;
    atoms.at(i).b_coord = abc.y;
    atoms.at(i).c_coord = abc.z;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
cmpl $0x0, 0x110(%rdi)
jle 0x51af5
movq %rdi, %r14
xorl %ebp, %ebp
movabsq $-0x79435e50d79435e5, %r15 # imm = 0x86BCA1AF286BCA1B
leaq 0x50(%rsp), %r12
leaq 0x20(%rsp), %r13
xorl %ebx, %ebx
movq 0x2f0(%r14), %rax
movq 0x2f8(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %r15, %rdx
cmpq %rbx, %rdx
jbe 0x51b04
movsd (%rax,%rbp), %xmm0
movsd 0x8(%rax,%rbp), %xmm1
movsd 0x10(%rax,%rbp), %xmm2
leaq 0x38(%rsp), %rdi
callq 0x85982
movsd 0x38(%rsp), %xmm0
movsd 0x40(%rsp), %xmm1
movsd 0x48(%rsp), %xmm2
movq %r12, %rdi
movq %r14, %rsi
callq 0x53240
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x50(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r13, %rdi
callq 0x84ece
movq 0x2f0(%r14), %rax
movq 0x2f8(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %r15, %rdx
cmpq %rbx, %rdx
jbe 0x51b04
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rax,%rbp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x20(%rax,%rbp)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x28(%rax,%rbp)
incq %rbx
movslq 0x110(%r14), %rax
addq $0x98, %rbp
cmpq %rax, %rbx
jl 0x51a24
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xfdb9a(%rip), %rdi     # 0x14f6a5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4630
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/networkstorage.cc
// Function: ATOM_NETWORK::make(double, double, double, double, double, double)
void ATOM_NETWORK::make(double a0, double b0, double c0, double alpha0, double beta0, double gamma0){
  a = a0;
  b = b0;
  c = c0;
  alpha = alpha0;
  beta = beta0;
  gamma = gamma0;
  initialize();
}

// Assembly:
movsd %xmm0, 0x8(%rdi)
movsd %xmm1, 0x10(%rdi)
movsd %xmm2, 0x18(%rdi)
movsd %xmm3, 0x20(%rdi)
movsd %xmm4, 0x28(%rdi)
movsd %xmm5, 0x30(%rdi)
jmp 0x521f4
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/networkstorage.cc
// Function: ATOM_NETWORK::make(XYZ, XYZ, XYZ)
void ATOM_NETWORK::make(XYZ va, XYZ vb, XYZ vc) {
  v_a = va;
  v_b = vb;
  v_c = vc;
  a = v_a.magnitude();
  b = v_b.magnitude();
  c = v_c.magnitude();
  alpha = 360.0*v_b.angle_between(v_c)/(2.0*PI);
  beta = 360.0*v_a.angle_between(v_c)/(2.0*PI);
  gamma = 360.0*v_a.angle_between(v_b)/(2.0*PI);
  initMatrices();
  distanceCalculator = MIN_PER_DISTANCE(v_a.x, v_b.x, v_b.y, v_c.x, v_c.y, v_c.z);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
movq 0xb0(%rsp), %rax
movq %rax, 0x48(%rdi)
movaps 0xa0(%rsp), %xmm0
movups %xmm0, 0x38(%rdi)
leaq 0x50(%rdi), %r15
movups 0xb8(%rsp), %xmm0
movups %xmm0, 0x50(%rdi)
movq 0xc8(%rsp), %rax
movq %rax, 0x60(%rdi)
leaq 0x68(%rdi), %r12
movapd 0xd0(%rsp), %xmm0
movupd %xmm0, 0x68(%rdi)
movq 0xe0(%rsp), %rax
movq %rax, 0x78(%rdi)
movq %r14, %rdi
callq 0x84e36
movsd %xmm0, 0x8(%rbx)
movq %r15, %rdi
callq 0x84e36
movsd %xmm0, 0x10(%rbx)
movq %r12, %rdi
callq 0x84e36
movsd %xmm0, 0x18(%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0x85c30
mulsd 0xfd5d0(%rip), %xmm0    # 0x14fab0
divsd 0xfd5d0(%rip), %xmm0    # 0x14fab8
movsd %xmm0, 0x20(%rbx)
movq %r14, %rdi
movq %r12, %rsi
callq 0x85c30
mulsd 0xfd5b0(%rip), %xmm0    # 0x14fab0
divsd 0xfd5b0(%rip), %xmm0    # 0x14fab8
movsd %xmm0, 0x28(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x85c30
mulsd 0xfd590(%rip), %xmm0    # 0x14fab0
divsd 0xfd590(%rip), %xmm0    # 0x14fab8
movsd %xmm0, 0x30(%rbx)
movq %rbx, %rdi
callq 0x52604
movsd 0x38(%rbx), %xmm0
movsd 0x50(%rbx), %xmm1
movsd 0x58(%rbx), %xmm2
movsd 0x68(%rbx), %xmm3
movsd 0x70(%rbx), %xmm4
movsd 0x78(%rbx), %xmm5
movq %rsp, %r14
movq %r14, %rdi
callq 0x789c0
leaq 0x340(%rbx), %rdi
movq %r14, %rsi
callq 0x12d52
leaq 0x358(%rbx), %rdi
leaq 0x18(%rsp), %rsi
callq 0x12d52
leaq 0x370(%rbx), %rdi
leaq 0x30(%rsp), %r14
movq %r14, %rsi
callq 0x12d52
movups 0x18(%r14), %xmm0
movups 0x28(%r14), %xmm1
movups 0x38(%r14), %xmm2
movups %xmm2, 0x3a8(%rbx)
movups %xmm1, 0x398(%rbx)
movups %xmm0, 0x388(%rbx)
movq (%r14), %rdi
testq %rdi, %rdi
je 0x525cb
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x525e2
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x525f8
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/networkstorage.cc
// Function: ATOM_NETWORK::initMatrices()
void ATOM_NETWORK::initMatrices(){
    ucVectors[0][0] = v_a.x; ucVectors[1][0] = v_a.y; ucVectors[2][0] = v_a.z;
    ucVectors[0][1] = v_b.x; ucVectors[1][1] = v_b.y; ucVectors[2][1] = v_b.z;
    ucVectors[0][2] = v_c.x; ucVectors[1][2] = v_c.y; ucVectors[2][2] = v_c.z;
    valid = tryInvertMatrix(ucVectors,invUCVectors);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x80, %rdi
movsd 0x38(%rbx), %xmm0
movsd 0x40(%rbx), %xmm1
movsd %xmm0, 0x80(%rbx)
movsd %xmm1, 0x98(%rbx)
movsd 0x48(%rbx), %xmm0
movsd %xmm0, 0xb0(%rbx)
movsd 0x50(%rbx), %xmm0
movsd %xmm0, 0x88(%rbx)
movsd 0x58(%rbx), %xmm0
movsd %xmm0, 0xa0(%rbx)
movsd 0x60(%rbx), %xmm0
movsd %xmm0, 0xb8(%rbx)
movsd 0x68(%rbx), %xmm0
movsd %xmm0, 0x90(%rbx)
movsd 0x70(%rbx), %xmm0
movsd %xmm0, 0xa8(%rbx)
movsd 0x78(%rbx), %xmm0
movsd %xmm0, 0xc0(%rbx)
leaq 0xc8(%rbx), %rsi
callq 0x8528b
movb %al, 0x3b8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x102222(%rip), %rsi    # 0x1548d0
movl $0x6, %edx
movq %r14, %rdi
callq 0x44e0
movq 0x320(%rbx), %rsi
movq 0x328(%rbx), %rdx
movq %r14, %rdi
callq 0x44e0
movq %rax, %r12
leaq 0x102e53(%rip), %r15    # 0x15552e
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x44e0
leaq 0x101894(%rip), %rsi    # 0x153f86
movl $0x3, %edx
movq %r12, %rdi
callq 0x44e0
movsd 0x8(%rbx), %xmm0
movq %r12, %rdi
callq 0x46b0
movq %rax, %r12
leaq 0x1021c1(%rip), %rsi    # 0x1548d7
movl $0x8, %edx
movq %rax, %rdi
callq 0x44e0
movsd 0x10(%rbx), %xmm0
movq %r12, %rdi
callq 0x46b0
movq %rax, %r12
leaq 0x1021a6(%rip), %rsi    # 0x1548e0
movl $0x8, %edx
movq %rax, %rdi
callq 0x44e0
movsd 0x18(%rbx), %xmm0
movq %r12, %rdi
callq 0x46b0
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x44e0
leaq 0x10217b(%rip), %rsi    # 0x1548e9
movl $0x7, %edx
movq %r12, %rdi
callq 0x44e0
movsd 0x20(%rbx), %xmm0
movq %r12, %rdi
callq 0x46b0
movq %rax, %r12
leaq 0x10215f(%rip), %rsi    # 0x1548f1
movl $0xb, %edx
movq %rax, %rdi
callq 0x44e0
movsd 0x28(%rbx), %xmm0
movq %r12, %rdi
callq 0x46b0
movq %rax, %r12
leaq 0x102147(%rip), %rsi    # 0x1548fd
movl $0xc, %edx
movq %rax, %rdi
callq 0x44e0
movsd 0x30(%rbx), %xmm0
movq %r12, %rdi
callq 0x46b0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x44e0
leaq 0x102123(%rip), %rsi    # 0x15490a
movl $0x5, %edx
movq %r14, %rdi
callq 0x44e0
leaq 0x38(%rbx), %rdi
movq 0x1447c1(%rip), %r12    # 0x196fc0
movq %r12, %rsi
callq 0x85992
leaq 0x102102(%rip), %rsi    # 0x154910
movl $0x5, %edx
movq %r14, %rdi
callq 0x44e0
leaq 0x50(%rbx), %rdi
movq %r12, %rsi
callq 0x85992
leaq 0x1020e8(%rip), %rsi    # 0x154916
movl $0x5, %edx
movq %r14, %rdi
callq 0x44e0
leaq 0x68(%rbx), %rdi
movq %r12, %rsi
callq 0x85992
leaq 0x1020ce(%rip), %rsi    # 0x15491c
movl $0x11, %edx
movq %r14, %rdi
callq 0x44e0
movl 0x110(%rbx), %esi
movq %r14, %rdi
callq 0x4750
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x44e0
cmpl $0x0, 0x110(%rbx)
jle 0x528d8
xorl %r12d, %r12d
movabsq $-0x79435e50d79435e5, %r13 # imm = 0x86BCA1AF286BCA1B
movq 0x14472a(%rip), %r15    # 0x196fc0
xorl %r14d, %r14d
movq 0x2f0(%rbx), %rdi
movq 0x2f8(%rbx), %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
imulq %r13, %rdx
cmpq %r14, %rdx
jbe 0x528e2
addq %r12, %rdi
movq %r15, %rsi
callq 0x5186c
incq %r14
movslq 0x110(%rbx), %rax
addq $0x98, %r12
cmpq %rax, %r14
jl 0x52899
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xfcdbc(%rip), %rdi     # 0x14f6a5
movq %r14, %rsi
xorl %eax, %eax
callq 0x4630
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movsd 0x50(%rsi), %xmm3
mulsd 0x38(%rsi), %xmm0
mulsd %xmm1, %xmm3
addsd %xmm3, %xmm0
movsd 0x68(%rsi), %xmm3
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm0
movsd 0x70(%rsi), %xmm3
mulsd 0x58(%rsi), %xmm1
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm1
mulsd 0x78(%rsi), %xmm2
callq 0x85436
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movsd 0xd0(%rsi), %xmm3
mulsd 0xc8(%rsi), %xmm0
mulsd %xmm1, %xmm3
addsd %xmm3, %xmm0
movsd 0xd8(%rsi), %xmm3
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm0
movsd 0xf0(%rsi), %xmm3
mulsd 0xe8(%rsi), %xmm1
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm1
mulsd 0x108(%rsi), %xmm2
callq 0x85436
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/networkstorage.cc
// Function: ATOM_NETWORK::calcDistanceXYZ(double, double, double, double, double, double) const
double ATOM_NETWORK::calcDistanceXYZ(double x1, double y1, double z1, double x2, double y2, double z2) const {
    Point abcCoord = xyz_to_abc(x1, y1, z1);
    //cout << abcCoord.vals[0] <<  abcCoord.vals[1] << abcCoord.vals[2] << endl;
    //cout << x2 <<  y2 << z2 << endl;
    //cout << calcDistanceXYZABC(x2, y2, z2, abcCoord[0], abcCoord[1], abcCoord[2]);
    return calcDistanceXYZABC(x2, y2, z2, abcCoord[0], abcCoord[1], abcCoord[2]);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movsd %xmm5, 0x28(%rsp)
movsd %xmm4, 0x20(%rsp)
movsd %xmm3, 0x18(%rsp)
movq %rdi, %rbx
movsd 0xd0(%rdi), %xmm3
mulsd 0xc8(%rdi), %xmm0
mulsd %xmm1, %xmm3
addsd %xmm3, %xmm0
movsd 0xd8(%rdi), %xmm3
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm0
movsd 0xf0(%rdi), %xmm3
mulsd 0xe8(%rdi), %xmm1
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm1
mulsd 0x108(%rdi), %xmm2
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x85436
movq %r14, %rdi
xorl %esi, %esi
callq 0x85478
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
movl $0x1, %esi
callq 0x85478
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movl $0x2, %esi
callq 0x85478
movsd (%rax), %xmm5
movq %rbx, %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movsd 0x28(%rsp), %xmm2
movsd 0x10(%rsp), %xmm3
movsd 0x8(%rsp), %xmm4
callq 0x53836
addq $0x48, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movsd %xmm5, 0x10(%rsp)
movsd %xmm4, 0x8(%rsp)
movsd %xmm3, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movsd 0xd0(%rsi), %xmm3
mulsd 0xc8(%rsi), %xmm0
mulsd %xmm1, %xmm3
addsd %xmm3, %xmm0
movsd 0xd8(%rsi), %xmm3
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm0
movsd 0xf0(%rsi), %xmm3
mulsd 0xe8(%rsi), %xmm1
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm1
mulsd 0x108(%rsi), %xmm2
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x85436
movsd 0xd0(%r14), %xmm0
movsd (%rsp), %xmm1
mulsd 0xc8(%r14), %xmm1
movsd 0x8(%rsp), %xmm3
mulsd %xmm3, %xmm0
addsd %xmm0, %xmm1
movsd 0xd8(%r14), %xmm0
movsd 0x10(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0xf0(%r14), %xmm1
mulsd 0xe8(%r14), %xmm3
mulsd %xmm2, %xmm1
addsd %xmm1, %xmm3
movapd %xmm3, %xmm1
mulsd 0x108(%r14), %xmm2
leaq 0x28(%rsp), %rdi
callq 0x85436
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
movq %rbx, %rdi
callq 0x85982
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0x52aea
movq %r15, %rdi
xorl %esi, %esi
callq 0x85478
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
movl $0x1, %esi
callq 0x85478
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
movl $0x2, %esi
callq 0x85478
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x85478
movsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x85478
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x85478
movsd (%rax), %xmm5
leaq 0x8(%rbx), %rdx
leaq 0x10(%rbx), %rcx
leaq 0x58(%rsp), %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm2
movsd 0x20(%rsp), %xmm3
movsd 0x18(%rsp), %xmm4
movq %rbx, %rsi
callq 0x78f58
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x53c02
movq 0x98(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x53c1c
movq 0x80(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x53c33
movq 0x68(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq %rbx, %rax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x38a78
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/networkstorage.cc
// Function: VORONOI_NETWORK::prune(double const&)
const VORONOI_NETWORK VORONOI_NETWORK::prune(const double& minRadius)
{
    vector<VOR_EDGE> newEdges;
    // Add edges whose radius is greater than the input minimum to a list
    for(vector<VOR_EDGE>::iterator edgeIter = edges.begin();
        edgeIter != edges.end(); edgeIter++) {
        if(edgeIter->rad_moving_sphere > minRadius){
            //VOR_EDGE newEdge = *edgeIter;
            
            // further check: keep edges only if they connect accessible nodes
            if( nodes[edgeIter->from].rad_stat_sphere > minRadius && nodes[edgeIter->to].rad_stat_sphere > minRadius )
                newEdges.push_back(*edgeIter);
            
        }
    };
    
    vector<VOR_NODE> newNodes = nodes;
    for(unsigned int i = 0; i < nodes.size(); i++)
    {
        if(nodes[i].rad_stat_sphere > minRadius) newNodes[i].active = true; else newNodes[i].active = false;
    };
    
    return VORONOI_NETWORK(v_a, v_b, v_c, newNodes, newEdges);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x60(%rsi), %r12
cmpq 0x68(%rsi), %r12
je 0x560d5
movq %rsp, %r13
movsd 0x8(%r12), %xmm1
movsd (%r15), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x560cb
movslq (%r12), %rcx
movq 0x48(%r14), %rax
shlq $0x6, %rcx
movsd 0x18(%rax,%rcx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x560cb
movslq 0x4(%r12), %rcx
shlq $0x6, %rcx
movsd 0x18(%rax,%rcx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x560cb
movq %r13, %rdi
movq %r12, %rsi
callq 0xe9ba
addq $0x28, %r12
cmpq 0x68(%r14), %r12
jne 0x56081
leaq 0x48(%r14), %rsi
leaq 0x18(%rsp), %rdi
callq 0x67a40
movq 0x48(%r14), %rax
movq 0x50(%r14), %rcx
subq %rax, %rcx
je 0x56122
sarq $0x6, %rcx
movsd (%r15), %xmm0
movl $0x1, %edx
movq 0x18(%rsp), %rsi
xorl %edi, %edi
movsd 0x18(%rax,%rdi), %xmm1
ucomisd %xmm0, %xmm1
seta 0x38(%rsi,%rdi)
movl %edx, %r8d
addq $0x40, %rdi
incl %edx
cmpq %r8, %rcx
ja 0x56105
leaq 0x18(%r14), %rdx
leaq 0x30(%r14), %rcx
leaq 0x18(%rsp), %r8
movq %rsp, %r9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x55608
leaq 0x18(%rsp), %rdi
callq 0xf1b8
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5615d
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xf1b8
jmp 0x56182
jmp 0x5617f
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x56198
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movslq %esi, %rsi
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
sarq $0x5, %rdx
cmpq %rsi, %rdx
jbe 0x61ccf
shlq $0x5, %rsi
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rcx,%rsi), %rax
movq 0x8(%rcx,%rsi), %rdx
addq %rax, %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xf32a
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xf32a
movq %rsp, %rdi
callq 0x107aab
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x61c91
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4470
movl %ebp, 0x438(%rbx)
addq $0x440, %rbx            # imm = 0x440
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x4240
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x61cc2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x4470
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xed9cf(%rip), %rdi     # 0x14f6a5
xorl %eax, %eax
callq 0x4630
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x61cfb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4470
jmp 0x61cfb
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x61d12
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x4470
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x6ae71
movq %rsi, %r14
movl $0x1, %ebp
leaq 0x10(%rsp), %r12
xorl %ecx, %ecx
leaq 0x8(%rsp), %r15
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
movq 0x18(%r14), %rdx
leaq (%rcx,%rcx,2), %rsi
movl (%rdx,%rcx,4), %ecx
movl %ecx, 0x8(%rsp)
movq 0x10(%rax,%rsi,8), %rcx
movq %rcx, 0x10(%r12)
movups (%rax,%rsi,8), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6ae4b
movups 0x8(%rsp), %xmm0
movups 0x18(%rsp), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x20, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6ae56
movq %rbx, %rdi
movq %r15, %rdx
callq 0x49804
movl %ebp, %ecx
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %r13, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x6ae04
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
testq %rdi, %rdi
je 0x6ae9a
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x4470
movq %r14, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r12, %rcx
decq %rcx
je 0x6af91
movq %rsi, %r14
movl $0x1, %ebp
leaq 0x18(%rsp), %r13
xorl %r15d, %r15d
leaq (%r15,%r15,2), %rcx
movq 0x10(%rax,%rcx,8), %rdx
movq %rdx, 0x60(%rsp)
movups (%rax,%rcx,8), %xmm0
movaps %xmm0, 0x50(%rsp)
movl %ebp, %r15d
leaq (%r15,%r15,2), %rcx
movq 0x10(%rax,%rcx,8), %rsi
movq %rsi, 0x40(%rsp)
movups (%rax,%rcx,8), %xmm1
movaps %xmm1, 0x30(%rsp)
movq %rdx, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %rsi, 0x10(%r13)
movups %xmm1, (%r13)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6af66
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movups %xmm2, 0x20(%rsi)
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x30, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6af71
movq %rbx, %rdi
movq %rsp, %rdx
callq 0x6e8ee
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
imulq %r12, %rcx
decq %rcx
incl %ebp
cmpq %r15, %rcx
ja 0x6aef6
leaq (%rcx,%rcx,2), %rcx
movq 0x10(%rax,%rcx,8), %rdx
movq %rdx, 0x10(%rsp)
movups (%rax,%rcx,8), %xmm0
movaps %xmm0, (%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x28(%rsp)
movups (%rax), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6afe5
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movups %xmm2, 0x20(%rsi)
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x30, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6aff0
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x6e8ee
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6b004
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6b01b
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x4470
movq %r14, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x6e830
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6adba
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
je 0x6bbdc
movl $0x1, %ebp
xorl %ecx, %ecx
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 0x6b6da
movl %ebp, %ecx
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x6bb8c
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x6aea2
movq 0x30(%rsp), %rdi
cmpq %rdi, 0x38(%rsp)
je 0x6bc8a
movl $0x1, %ebp
leaq 0x98(%rsp), %r14
xorl %eax, %eax
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movups (%rdi,%rax), %xmm0
movups 0x10(%rdi,%rax), %xmm1
movups 0x20(%rdi,%rax), %xmm2
movaps %xmm2, 0xa0(%rsp)
movaps %xmm1, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movq 0x10(%r14), %rcx
movq %rcx, 0x28(%rsp)
movups (%r14), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x10(%rdi,%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rdi,%rax), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6b916
movl %ebp, %eax
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rcx
subq %rdi, %rcx
sarq $0x4, %rcx
imulq %r15, %rcx
incl %ebp
cmpq %rax, %rcx
ja 0x6bc12
testq %rdi, %rdi
je 0x6bc9c
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x6bcb3
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6bcdf
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x6bce2
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
jmp 0x6bce2
movq %rax, %rbx
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x6bcf9
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq %rbx, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xea2fb(%rip), %rsi     # 0x15626d
movl $0xa, %edx
movq %rbx, %rdi
callq 0x44e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4750
movq %rax, %r13
leaq 0xea395(%rip), %rsi     # 0x156328
movl $0x3, %edx
movq %rax, %rdi
callq 0x44e0
leaq 0xe9587(%rip), %r12     # 0x15552e
movl $0x1, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x44e0
leaq 0xea2ba(%rip), %rsi     # 0x156278
movl $0x13, %edx
movq %r13, %rdi
callq 0x44e0
movq %r13, %rdi
movl %ebp, %esi
callq 0x4750
movq %rax, %r13
leaq 0xea2ad(%rip), %rsi     # 0x15628c
movl $0x3, %edx
movq %rax, %rdi
callq 0x44e0
movl $0x1, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x44e0
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
je 0x6c044
movl $0x1, %ebp
xorl %ecx, %ecx
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
leaq (%rcx,%rcx,2), %rdi
shlq $0x4, %rdi
addq %rax, %rdi
movq %r14, %rsi
callq 0x6b024
movl %ebp, %ecx
movq (%r15), %rax
movq 0x8(%r15), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
imulq %r12, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x6c016
leaq 0xea243(%rip), %rsi     # 0x15628e
movl $0x1, %edx
movq %rbx, %rdi
callq 0x44e0
leaq 0xe94cf(%rip), %rsi     # 0x15552e
movl $0x1, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x44e0
// File: /workspace/github_cpp_makefile_star2_O1/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), %rsi
movq %rdi, (%rsp)
callq 0xfa26
movq 0x8(%rbx), %rax
cmpq (%rbx), %rax
je 0x6c6db
xorl %r14d, %r14d
leaq 0x40(%rsp), %rbp
leaq 0x10(%rsp), %r12
movq %rbp, %rdi
callq 0x6b2d6
movq (%rbx), %rcx
movq %r14, 0x8(%rsp)
leaq (%r14,%r14,2), %r15
movq (%rcx,%r15,8), %rax
cmpq %rax, 0x8(%rcx,%r15,8)
je 0x6c65f
movl $0x1, %r14d
xorl %ecx, %ecx
leaq (%rcx,%rcx,2), %r13
shlq $0x4, %r13
addq %rax, %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0xe7f6
addq $0x18, %r13
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0xe886
movq %rbp, %rdi
movq %r12, %rsi
callq 0x6bb54
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x6c618
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x6c62f
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movl %r14d, %ecx
movq (%rbx), %rdx
movq (%rdx,%r15,8), %rax
movq 0x8(%rdx,%r15,8), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rdx
incl %r14d
cmpq %rcx, %rdx
ja 0x6c5cf
movq (%rsp), %rdi
movq %rbp, %rsi
callq 0x6e8be
leaq 0x120(%rsp), %rdi
callq 0xf4f6
leaq 0xf0(%rsp), %rdi
callq 0xf568
leaq 0xc0(%rsp), %rdi
callq 0xf5b8
leaq 0x90(%rsp), %rdi
callq 0xf118
leaq 0x60(%rsp), %rdi
callq 0xf62e
movq %rbp, %rdi
callq 0xf538
movq 0x8(%rbx), %rax
subq (%rbx), %rax
movq 0x8(%rsp), %r14
incl %r14d
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
cmpq %r14, %rax
ja 0x6c5a4
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6c70b
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x6c71d
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
jmp 0x6c71d
movq %rax, %rbx
jmp 0x6c71d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xe906
leaq 0x40(%rsp), %rdi
callq 0xf4b2
movq %rbx, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq $0x0, 0x58(%rsi)
je 0x70b98
movq %rsi, %r14
leaq 0x38(%rsi), %r15
xorl %r12d, %r12d
movq 0x40(%r14), %rcx
movq %r15, %rax
testq %rcx, %rcx
je 0x70b58
movq %r15, %rax
xorl %edx, %edx
cmpl %r12d, 0x20(%rcx)
setl %dl
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x70b41
movq %r15, %rdx
cmpq %r15, %rax
je 0x70b6b
cmpl 0x20(%rax), %r12d
cmovlq %r15, %rax
movq %rax, %rdx
addq $0x24, %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x70b87
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x70b8f
movq %rbx, %rdi
callq 0xf7b4
incl %r12d
cmpq %r12, 0x58(%r14)
ja 0x70b32
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x70bbe
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x4470
movq %r14, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5604c
leaq 0x10(%rsp), %rdi
callq 0x50e9e
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x50fc8
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x70bc6
leaq 0x10(%rsp), %rdi
callq 0xf07c
movq 0xd0(%rsp), %rdi
testq %rdi, %rdi
je 0x71a44
movq 0xe0(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq 0xb8(%rsp), %rdi
callq 0xf1b8
addq $0xe8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x71a6e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf07c
leaq 0x70(%rsp), %rdi
callq 0xeab8
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/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 0x509e2
movl %eax, %ebp
movq (%rbx), %rsi
movl 0x8(%rbx), %edx
movq %r14, %rdi
callq 0x509e2
movl %eax, %ecx
movl %ebp, %eax
xorb $0x1, %al
testb %bpl, %bpl
jne 0x7333e
testb %cl, %cl
jne 0x7333e
leaq 0x10(%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x779ee
addq $0x18, %rbx
cmpq %rbx, %rax
sete %bpl
movq %r12, %rdi
movq %r14, %rsi
callq 0x779ee
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_O1/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 0x6f79c
leaq 0x60(%r14), %rsi
leaq 0x60(%rbx), %rdi
callq 0x39036
leaq 0x78(%r14), %rsi
leaq 0x78(%rbx), %rdi
callq 0x38d5a
movl $0x90, %edi
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0x76a5e
movl $0xa8, %edi
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0x76b64
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 0x76cdc
movq %r14, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rdx, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
callq 0x70bc6
movq (%rsp), %rsi
cmpq %rsi, 0x8(%rsp)
je 0x747d0
leaq 0x78(%rsp), %r15
movl $0x1, %ebp
leaq 0x48(%rsp), %r12
xorl %eax, %eax
leaq 0x18(%rsp), %r13
movabsq $-0x79435e50d79435e5, %r14 # imm = 0x86BCA1AF286BCA1B
imulq $0x130, %rax, %rax      # imm = 0x130
cmpl $0x0, 0x108(%rsi,%rax)
jle 0x747af
addq %rax, %rsi
movq %r13, %rdi
callq 0x745e8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x782da
leaq 0xc0(%rsp), %rdi
callq 0xefda
movq 0xa8(%rsp), %rdi
testq %rdi, %rdi
je 0x7477a
movq 0xb8(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x74797
movq 0xa0(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq %r15, %rdi
callq 0xf07c
movq %r12, %rdi
callq 0xf118
movq %r13, %rdi
callq 0xf118
movl %ebp, %eax
movq (%rsp), %rsi
movq 0x8(%rsp), %rcx
subq %rsi, %rcx
sarq $0x4, %rcx
imulq %r14, %rcx
incl %ebp
cmpq %rax, %rcx
ja 0x74729
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x78628
movq %rbx, %rdi
callq 0xee6a
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x747f7
movq %rax, %rbx
jmp 0x74809
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x76cdc
movq %rsp, %rdi
callq 0xee6a
movq %rbx, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rdx, %rbx
xorps %xmm1, %xmm1
movq %rsp, %rdx
movaps %xmm1, (%rdx)
movq $0x0, 0x10(%rdx)
callq 0x719ce
movq (%rsp), %rsi
cmpq %rsi, 0x8(%rsp)
je 0x7491a
leaq 0x78(%rsp), %r15
movl $0x1, %ebp
leaq 0x48(%rsp), %r12
xorl %eax, %eax
leaq 0x18(%rsp), %r13
movabsq $-0x79435e50d79435e5, %r14 # imm = 0x86BCA1AF286BCA1B
imulq $0x130, %rax, %rax      # imm = 0x130
cmpl $0x0, 0x108(%rsi,%rax)
jle 0x748f9
addq %rax, %rsi
movq %r13, %rdi
callq 0x745e8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x782da
leaq 0xc0(%rsp), %rdi
callq 0xefda
movq 0xa8(%rsp), %rdi
testq %rdi, %rdi
je 0x748c4
movq 0xb8(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x748e1
movq 0xa0(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq %r15, %rdi
callq 0xf07c
movq %r12, %rdi
callq 0xf118
movq %r13, %rdi
callq 0xf118
movl %ebp, %eax
movq (%rsp), %rsi
movq 0x8(%rsp), %rcx
subq %rsi, %rcx
sarq $0x4, %rcx
imulq %r14, %rcx
incl %ebp
cmpq %rax, %rcx
ja 0x74873
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x78628
movq %rbx, %rdi
callq 0xee6a
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x74941
movq %rax, %rbx
jmp 0x74953
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x76cdc
movq %rsp, %rdi
callq 0xee6a
movq %rbx, %rdi
callq 0x4780
nop