LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::CMolecularSystem()
CMolecularSystem::CMolecularSystem()
{
  this->fillConstants();
  this->parameter = new CParameter;
  this->parameter->nop = -1;
  this->is_listcreated = -1;
  for (int i = 0;i<OrderParameterHistoSize;i++)
  {
    this->q4Histo[i] = 0;
    this->q6Histo[i] = 0;
    this->aq4Histo[i] = 0;
    this->aq6Histo[i] = 0;
    this->normq4 = 0;
    this->normq6 = 0;
    this->normaq4 = 0;
    this->normaq6 = 0;
  }
  for (int i = 0;i<OrderParameterHistoSize;i++)
  {
     for (int j = 0;j<OrderParameterHistoSize;j++)
     {
       this->q46Histo3d[i][j] = 0;
       this->aq46Histo3d[i][j] = 0;

     }
  }
  clear_Q4Q6Histograms();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8284(%rip), %rax      # 0xad08
movq %rax, (%rdi)
callq 0x2bb0
movl $0x3258, %edi           # imm = 0x3258
callq 0x21b0
movq %rax, %r14
movq %rax, %rdi
callq 0x7640
movq %r14, 0xb4e8c0(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x3208(%r14)
movl %eax, 0x20(%rbx)
leaq 0x24(%rbx), %rdi
leaq 0x7a50a4(%rbx), %r14
movl $0x3e80, %edx           # imm = 0x3E80
xorl %esi, %esi
callq 0x2120
movl $0x3e8, %eax            # imm = 0x3E8
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
decq %rax
jne 0x2ad6
leaq 0x3d47a4(%rbx), %rax
xorl %ecx, %ecx
xorl %edx, %edx
xorl %esi, %esi
movl %ecx, -0x3d0900(%rax,%rsi,4)
movl %ecx, (%rax,%rsi,4)
incq %rsi
cmpq $0x3e8, %rsi            # imm = 0x3E8
jne 0x2aec
incq %rdx
addq $0xfa0, %rax            # imm = 0xFA0
cmpq $0x3e8, %rdx            # imm = 0x3E8
jne 0x2aea
addq $0xa642b8, %rbx         # imm = 0xA642B8
movq $-0xea600, %r13         # imm = 0xFFF15A00
leaq (%rbx,%r13), %r15
leaq (%rbx,%r13), %r14
addq $0xea600, %r14          # imm = 0xEA600
leaq (%rbx,%r13), %r12
addq $-0xea600, %r12         # imm = 0xFFF15A00
leaq (%rbx,%r13), %rdi
addq $-0x1d4c00, %rdi        # imm = 0xFFE2B400
movl $0x12c0, %edx           # imm = 0x12C0
xorl %esi, %esi
callq 0x2120
movl $0x12c0, %edx           # imm = 0x12C0
movq %r12, %rdi
xorl %esi, %esi
callq 0x2120
movl $0x12c0, %edx           # imm = 0x12C0
movq %r15, %rdi
xorl %esi, %esi
callq 0x2120
movl $0x12c0, %edx           # imm = 0x12C0
movq %r14, %rdi
xorl %esi, %esi
callq 0x2120
addq $0x12c0, %r13           # imm = 0x12C0
jne 0x2b22
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x3258, %esi           # imm = 0x3258
movq %r14, %rdi
callq 0x21c0
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O1/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::clear_Q4Q6Histograms()
void CMolecularSystem::clear_Q4Q6Histograms()
{
  for (int ti = 0;ti<Q4SIZE;ti++)
  {
    for (int tj = 0;tj<Q6SIZE;tj++)
    {
      this->QBCC[ti][tj] = 0.0;
      this->QFCC[ti][tj] = 0.0;
      this->QHCP[ti][tj] = 0.0;
      this->QLIQ[ti][tj] = 0.0;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
addq $0xa642b8, %rdi         # imm = 0xA642B8
xorl %eax, %eax
xorl %ecx, %ecx
xorl %edx, %edx
movq %rax, -0x2bf200(%rdi,%rdx,8)
movq %rax, -0x1d4c00(%rdi,%rdx,8)
movq %rax, -0xea600(%rdi,%rdx,8)
movq %rax, (%rdi,%rdx,8)
incq %rdx
cmpq $0x258, %rdx            # imm = 0x258
jne 0x3123
incq %rcx
addq $0x12c0, %rdi           # imm = 0x12C0
cmpq $0xc8, %rcx
jne 0x3121
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::~CMolecularSystem()
CMolecularSystem::~CMolecularSystem()
{
  delete parameter;
  delete [] molecules;
  delete [] cellHead;
  delete [] cellList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7b90(%rip), %rax      # 0xad08
movq %rax, (%rdi)
movq 0xb4e8c0(%rdi), %rdi
testq %rdi, %rdi
je 0x318d
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xb4e8b8(%rbx), %r15
testq %r15, %r15
je 0x31d9
leaq -0x8(%r15), %r14
movq -0x8(%r15), %r12
testq %r12, %r12
je 0x31c6
addq $-0x870, %r15           # imm = 0xF790
imulq $0x870, %r12, %r13      # imm = 0x870
leaq (%r15,%r13), %rdi
callq 0x75ee
addq $-0x870, %r13           # imm = 0xF790
jne 0x31b4
imulq $0x870, %r12, %rsi      # imm = 0x870
orq $0x8, %rsi
movq %r14, %rdi
callq 0x2390
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x31e7
callq 0x2240
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x3203
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2240
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::initializeMolecules()
void CMolecularSystem::initializeMolecules()
{
  try {
    if (this->parameter->nop <0) {throw NumberOfParticlesNotDefinedException();}
    else {
      this->molecules   = new CMolecule[this->parameter->nop];

    }
  } catch(NumberOfParticlesNotDefinedException& ) {}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0xb4e8c0(%rdi), %rax
movslq 0x3208(%rax), %r12
testq %r12, %r12
js 0x339d
movq %rdi, -0x38(%rbp)
imulq $0x870, %r12, %rbx      # imm = 0x870
orq $0x8, %rbx
movq %rbx, %rdi
callq 0x2030
movq %r12, (%rax)
movq %rax, -0x30(%rbp)
leaq 0x8(%rax), %r14
testl %r12d, %r12d
je 0x3383
imulq $-0x870, %r12, %r15     # imm = 0xF790
xorl %r13d, %r13d
movq %r14, %r12
movq %r12, %rdi
callq 0x75d4
addq $-0x870, %r13           # imm = 0xF790
addq $0x870, %r12            # imm = 0x870
cmpq %r13, %r15
jne 0x3368
movq -0x38(%rbp), %rax
movq %r14, 0xb4e8b8(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %edi
callq 0x20f0
leaq 0x797a(%rip), %rsi      # 0xad28
movq %rax, %rdi
xorl %edx, %edx
callq 0x2320
movq %rdx, %r12
movq %rax, %r15
jmp 0x33f7
movq %rdx, %r12
movq %rax, %r15
testq %r13, %r13
je 0x33eb
negq %r13
movq -0x30(%rbp), %r14
addq $-0x868, %r14           # imm = 0xF798
leaq (%r14,%r13), %rdi
callq 0x75ee
addq $-0x870, %r13           # imm = 0xF790
jne 0x33d9
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x2390
movq %r15, %rdi
cmpl $0x1, %r12d
jne 0x3418
callq 0x20e0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22f0
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O1/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::InitializeSystem()
void CMolecularSystem::InitializeSystem()
{
  if (this->parameter->xyzFile.compare("notset") == 0) {
    cerr << "xyzFilename must be set in parameter.txt\nif you want to create a fcc use CREATEFCC as filename\n";}
  else
  {
    if (this->parameter->xyzFile.compare(CREATEFCCSTRING) == 0)
    {
      this->createFCC();
    } else if (this->parameter->xyzFile.compare(CREATEBCCSTRING) == 0)
    {
      this->createBCC();
    } else if (this->parameter->xyzFile.compare(CREATEHCPSTRING) == 0)
    {
      this->createHCP();
    } else {
      this->readParticleFile();
    }


  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x3230, %r14d          # imm = 0x3230
movq 0xb4e8c0(%rdi), %rdi
addq %r14, %rdi
leaq 0x4c37(%rip), %rsi      # 0x80de
callq 0x20c0
testl %eax, %eax
je 0x3510
addq 0xb4e8c0(%rbx), %r14
leaq 0x7d42(%rip), %rsi      # 0xb200
movq %r14, %rdi
callq 0x2040
testl %eax, %eax
je 0x352c
movl $0x3230, %r14d          # imm = 0x3230
movq 0xb4e8c0(%rbx), %rdi
addq %r14, %rdi
leaq 0x7d3f(%rip), %rsi      # 0xb220
callq 0x2040
testl %eax, %eax
je 0x3538
addq 0xb4e8c0(%rbx), %r14
leaq 0x7d48(%rip), %rsi      # 0xb240
movq %r14, %rdi
callq 0x2040
movq %rbx, %rdi
testl %eax, %eax
je 0x3544
popq %rbx
popq %r14
popq %rbp
jmp 0x3b7a
movq 0x7ad9(%rip), %rdi      # 0xaff0
leaq 0x4bc7(%rip), %rsi      # 0x80e5
movl $0x5f, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x21f0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x354e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x371e
popq %rbx
popq %r14
popq %rbp
jmp 0x3908
nop
// File: /workspace/github_cpp_makefile_star2_O1/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::createFCC()
void CMolecularSystem::createFCC()
{
  int t;
  int bu;
  bu = this->parameter->baseunit;
  if (bu != -1)
  {
    if (parameter->nop != -1) {cerr << "how comes that numberofparticles is already set in createfcc?\n";}
    this->parameter->nop = 4*bu*bu*bu;
    this->initializeMolecules(4*bu*bu*bu);
    for (int jz=0; jz < 2*bu ; jz++)
    {
      for (int jy=0; jy < 2*bu ; jy++)
      {
        for (int jx = 0; jx < bu; jx++)
        {
          t = 2*bu*bu*jz + bu*jy + jx;
          this->molecules[t].posx = double(jx)*this->parameter->boxx/double(bu) + this->parameter->boxx/double(2*bu) * ((jz+jy) % 2);
          this->molecules[t].posy = double(jy)*this->parameter->boxy/double(2*bu);
          this->molecules[t].posz = double(jz)*this->parameter->boxz/double(2*bu);
        }
      }
    }
  } else { cerr << "baseunit is not set, which is needed for createFCC\n";}
  setNumberOfCells();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xb4e8c0(%rdi), %rax
movl 0x320c(%rax), %r14d
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %r14
je 0x36c3
cmpl $-0x1, 0x3208(%rax)
je 0x3595
movq 0x7a6c(%rip), %rdi      # 0xaff0
leaq 0x4bde(%rip), %rsi      # 0x8169
movl $0x3e, %edx
callq 0x21f0
movl %r14d, %esi
imull %r14d, %esi
imull %r14d, %esi
shll $0x2, %esi
movq 0xb4e8c0(%rbx), %rax
movl %esi, 0x3208(%rax)
movq %rbx, %rdi
callq 0x3230
testl %r14d, %r14d
jle 0x36db
leal (%r14,%r14), %ecx
cvtsi2sd %r14d, %xmm0
cvtsi2sd %ecx, %xmm1
cmpl $0x2, %ecx
movl $0x1, %eax
cmovgel %ecx, %eax
movl %r14d, %ecx
imull %ecx, %ecx
addl %ecx, %ecx
xorl %edx, %edx
xorpd %xmm2, %xmm2
movsd 0x4a19(%rip), %xmm3     # 0x8008
xorl %esi, %esi
movq 0xb4e8b8(%rbx), %rdi
movq 0xb4e8c0(%rbx), %r8
movsd 0x3218(%r8), %xmm4
movsd 0x3220(%r8), %xmm5
movapd %xmm4, %xmm6
divsd %xmm1, %xmm6
movsd 0x3228(%r8), %xmm7
mulsd %xmm2, %xmm7
divsd %xmm1, %xmm7
movq %rdx, %r8
xorpd %xmm8, %xmm8
xorl %r9d, %r9d
leal (%r9,%rsi), %r10d
andl $0x1, %r10d
xorps %xmm9, %xmm9
cvtsi2sd %r10d, %xmm9
mulsd %xmm6, %xmm9
movapd %xmm5, %xmm10
mulsd %xmm8, %xmm10
divsd %xmm1, %xmm10
xorl %r10d, %r10d
leal (%r8,%r10), %r11d
xorps %xmm11, %xmm11
cvtsi2sd %r10d, %xmm11
mulsd %xmm4, %xmm11
divsd %xmm0, %xmm11
addsd %xmm9, %xmm11
movslq %r11d, %r11
imulq $0x870, %r11, %r11      # imm = 0x870
movsd %xmm11, 0x8(%rdi,%r11)
movsd %xmm10, 0x10(%rdi,%r11)
movsd %xmm7, 0x18(%rdi,%r11)
incq %r10
cmpq %r10, %r14
jne 0x365d
addsd %xmm3, %xmm8
incl %r9d
addq %r14, %r8
cmpl %eax, %r9d
jne 0x3635
addsd %xmm3, %xmm2
incl %esi
addq %rcx, %rdx
cmpl %eax, %esi
jne 0x35f1
jmp 0x36db
movq 0x7926(%rip), %rdi      # 0xaff0
leaq 0x4ad7(%rip), %rsi      # 0x81a8
movl $0x33, %edx
callq 0x21f0
movq 0xb4e8c0(%rbx), %rbx
cmpl $0x0, 0x3214(%rbx)
jns 0x3718
movsd 0x3218(%rbx), %xmm0
divsd 0x3250(%rbx), %xmm0
callq 0x2300
cvttsd2si %xmm0, %eax
cmpl $0x6, %eax
movl $0x5, %ecx
cmovgel %eax, %ecx
addl $-0x2, %ecx
movl %ecx, 0x3214(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::convertIndex(int, int&, int&, int&)
void CMolecularSystem::convertIndex(int index,int &idx, int &idy, int &idz)
{
  int noc;
  noc = this->parameter->noc;
  idx = index%noc;
  idy = (index/noc)%noc;
  idz = index/(noc*noc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdx, %r9
movq 0xb4e8c0(%rdi), %rax
movl 0x3214(%rax), %edi
movl %esi, %eax
cltd
idivl %edi
movl %edx, (%r9)
cltd
idivl %edi
movl %edx, (%rcx)
imull %edi, %edi
movl %esi, %eax
cltd
idivl %edi
movl %eax, (%r8)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::createLists()
void CMolecularSystem::createLists()
{
  int noc;
  if (this->is_listcreated == -1)
  {
    noc = this->parameter->noc;
    cellList = new int[this->parameter->nop];
    cellHead = new int[noc*noc*noc];
    neighborcells = new SNeighborCells[noc*noc*noc];
    fillNeighborCells();
    this->is_listcreated = 1;

  }
}

// Assembly:
cmpl $-0x1, 0x20(%rdi)
je 0x47eb
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb4e8c0(%rdi), %rax
movl 0x3214(%rax), %r15d
movslq 0x3208(%rax), %rax
leaq (,%rax,4), %rdi
testq %rax, %rax
movq $-0x1, %r14
cmovsq %r14, %rdi
callq 0x2030
movq %rax, 0x8(%rbx)
movl %r15d, %eax
imull %r15d, %eax
imull %r15d, %eax
movslq %eax, %r15
leaq (,%r15,4), %rdi
testl %r15d, %r15d
cmovsq %r14, %rdi
callq 0x2030
movq %rax, %rcx
movl $0x68, %edx
movq %r15, %rax
mulq %rdx
movq %rcx, 0x10(%rbx)
cmovnoq %rax, %r14
movq %r14, %rdi
callq 0x2030
movq %rax, 0x18(%rbx)
movq %rbx, %rdi
callq 0x4144
movl $0x1, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::get_cellByIndex(int)
int CMolecularSystem::get_cellByIndex(int i)
{
  int cell,noc;
  double boxx,boxy,boxz;
  double x,y,z;
  boxx = this->parameter->boxx;
  boxy = this->parameter->boxy;
  boxz = this->parameter->boxz;
  noc = this->parameter->noc;

  x = this->molecules[i].posx;
  y = this->molecules[i].posy;
  z = this->molecules[i].posz;
  //cout << x << " " << y << " " << z << "\n";
  cell =  int (floor((x / boxx) * noc) +
               floor((y / boxy) * noc) * noc +
               floor((z / boxz) * noc) * noc * noc);
  return cell;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq 0xb4e8b8(%rdi), %rax
movq 0xb4e8c0(%rdi), %rbx
movslq %esi, %rcx
imulq $0x870, %rcx, %rcx      # imm = 0x870
movsd 0x8(%rax,%rcx), %xmm0
movsd 0x10(%rax,%rcx), %xmm1
movsd %xmm1, -0x10(%rbp)
divsd 0x3218(%rbx), %xmm0
movsd 0x18(%rax,%rcx), %xmm1
movsd %xmm1, -0x28(%rbp)
xorps %xmm1, %xmm1
cvtsi2sdl 0x3214(%rbx), %xmm1
movsd %xmm1, -0x18(%rbp)
mulsd %xmm1, %xmm0
callq 0x2300
movsd %xmm0, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
divsd 0x3220(%rbx), %xmm0
mulsd -0x18(%rbp), %xmm0
callq 0x2300
movsd -0x18(%rbp), %xmm1
mulsd %xmm1, %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x28(%rbp), %xmm0
divsd 0x3228(%rbx), %xmm0
mulsd %xmm1, %xmm0
callq 0x2300
movsd -0x18(%rbp), %xmm1
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
addsd -0x10(%rbp), %xmm0
cvttsd2si %xmm0, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::fillLists()
void CMolecularSystem::fillLists()
{
  int cell,allCells,noc;
  createLists();

  noc = this->parameter->noc;
  allCells = noc*noc*noc;
  for(int ti=0;ti<this->parameter->nop;ti++)
  {
    cellList[ti] = nilvalue;
  }
  for (int ci=0;ci<allCells;ci++)
  {
    cellHead[ci] = nilvalue;
  }
  for(int ti=0;ti<this->parameter->nop;ti++)
  {
    cell = get_cellByIndex(ti);
    this->molecules[ti].cell = cell;
    cellList[ti] = cellHead[cell];
    cellHead[cell] = ti;
  }
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
callq 0x47e4
movq 0xb4e8c0(%r12), %r15
movl 0x3214(%r15), %ecx
movl %ecx, %eax
imull %ecx, %eax
imull %ecx, %eax
cmpl $0x0, 0x3208(%r15)
jle 0x499e
movq 0x8(%r12), %rcx
xorl %edx, %edx
movl $0x1fca055, (%rcx,%rdx,4) # imm = 0x1FCA055
incq %rdx
movslq 0x3208(%r15), %rsi
cmpq %rsi, %rdx
jl 0x4988
testl %eax, %eax
jle 0x49ba
movq 0x10(%r12), %rcx
movl %eax, %eax
xorl %edx, %edx
movl $0x1fca055, (%rcx,%rdx,4) # imm = 0x1FCA055
incq %rdx
cmpq %rdx, %rax
jne 0x49ab
cmpl $0x0, 0x3208(%r15)
jle 0x4a19
movq 0x8(%r12), %rax
movq %rax, -0x30(%rbp)
movq 0x10(%r12), %r13
movl $0x554, %ebx            # imm = 0x554
addq 0xb4e8b8(%r12), %rbx
xorl %r14d, %r14d
movq %r12, %rdi
movl %r14d, %esi
callq 0x488a
movl %eax, (%rbx)
cltq
movl (%r13,%rax,4), %ecx
movq -0x30(%rbp), %rdx
movl %ecx, (%rdx,%r14,4)
movl %r14d, (%r13,%rax,4)
incq %r14
movslq 0x3208(%r15), %rax
addq $0x870, %rbx            # imm = 0x870
cmpq %rax, %r14
jl 0x49e2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::get_AllNeighbors()
void CMolecularSystem::get_AllNeighbors()
{
  double nd,d;
  nd = this->parameter->neighbordistance;
  int c,nop;
  nop = this->parameter->nop;

  for (int ti = 0;ti<nop;ti++)
  {
    for (int tn = 0;tn<MAXNUMBEROFNEIGHBORS;tn++)
    {
      this->molecules[ti].neighbors[tn] = nilvalue;
      this->molecules[ti].neighbordist[tn] = -1.0;
    }
  }


  for (int ti = 0;ti<nop;ti++)
  {
    c = 0;
	  for (int tj = 0;tj<nop;tj++)
	  {

          if (tj != ti) { 
            d = get_absDistance(ti,tj); 
            if (d < nd) {
              this->molecules[ti].neighbors[c] = tj; 
              this->molecules[ti].neighbordist[c]=d; 
              c += 1;   
            }
         }
	  }
    this->molecules[ti].n_neighbors = c;
    cout << ti << " " << c << "\n";
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0xb4e8c0(%rdi), %rax
movsd 0x3250(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movslq 0x3208(%rax), %r13
testq %r13, %r13
jle 0x4a9a
movq 0xb4e8b8(%rbx), %rax
xorl %ecx, %ecx
movabsq $-0x4010000000000000, %rdx # imm = 0xBFF0000000000000
movl $0x46, %esi
movl $0x1fca055, -0x78(%rax,%rsi,4) # imm = 0x1FCA055
movq %rdx, (%rax,%rsi,8)
incq %rsi
cmpq $0xaa, %rsi
jne 0x4a74
incq %rcx
addq $0x870, %rax            # imm = 0x870
cmpq %r13, %rcx
jne 0x4a6f
testl %r13d, %r13d
jle 0x4b64
xorl %r14d, %r14d
imulq $0x870, %r14, %rax      # imm = 0x870
movq %rax, -0x30(%rbp)
xorl %r12d, %r12d
xorl %r15d, %r15d
cmpq %r12, %r14
je 0x4af8
movq %rbx, %rdi
movl %r14d, %esi
movl %r12d, %edx
callq 0x4b74
movsd -0x38(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x4af8
movslq %r15d, %r15
movq 0xb4e8b8(%rbx), %rax
addq -0x30(%rbp), %rax
movl %r12d, 0xa0(%rax,%r15,4)
movsd %xmm0, 0x230(%rax,%r15,8)
incl %r15d
incq %r12
cmpl %r12d, %r13d
jne 0x4ab7
movq 0xb4e8b8(%rbx), %rax
movq -0x30(%rbp), %rcx
movl %r15d, 0x550(%rax,%rcx)
movq 0x64b6(%rip), %rdi      # 0xafd0
movl %r14d, %esi
callq 0x2330
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
leaq 0x3633(%rip), %rsi      # 0x8167
callq 0x21f0
movq %r12, %rdi
movl %r15d, %esi
callq 0x2330
movl $0x1, %edx
movq %rax, %rdi
leaq 0x3827(%rip), %rsi      # 0x837a
callq 0x21f0
incq %r14
cmpq %r13, %r14
jne 0x4aa6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::get_absDistance(int, int)
double CMolecularSystem::get_absDistance(int ti ,int tj)
{
  double abs,diffx,diffy,diffz;
  diffx = this->molecules[tj].posx - this->molecules[ti].posx;
  diffy = this->molecules[tj].posy - this->molecules[ti].posy;
  diffz = this->molecules[tj].posz - this->molecules[ti].posz;
  //nearest image
  if (diffx >  this->parameter->boxx/2.0) {diffx = diffx - this->parameter->boxx;};
  if (diffx < -this->parameter->boxx/2.0) {diffx = diffx + this->parameter->boxx;};
  if (diffy >  this->parameter->boxy/2.0) {diffy = diffy - this->parameter->boxy;};
  if (diffy < -this->parameter->boxy/2.0) {diffy = diffy + this->parameter->boxy;};
  if (diffz >  this->parameter->boxz/2.0) {diffz = diffz - this->parameter->boxz;};
  if (diffz < -this->parameter->boxz/2.0) {diffz = diffz + this->parameter->boxz;};
  abs = sqrt(diffx*diffx + diffy*diffy + diffz*diffz);
  return abs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %edx, %rax
imulq $0x870, %rax, %rax      # imm = 0x870
movslq %esi, %rcx
imulq $0x870, %rcx, %rcx      # imm = 0x870
movq 0xb4e8b8(%rdi), %rdx
movsd 0x8(%rdx,%rax), %xmm2
movsd 0x10(%rdx,%rax), %xmm5
subsd 0x8(%rdx,%rcx), %xmm2
subsd 0x10(%rdx,%rcx), %xmm5
movsd 0x18(%rdx,%rax), %xmm0
subsd 0x18(%rdx,%rcx), %xmm0
movq 0xb4e8c0(%rdi), %rax
movsd 0x3218(%rax), %xmm6
movsd 0x3220(%rax), %xmm4
movsd 0x3442(%rip), %xmm1     # 0x8018
movapd %xmm6, %xmm7
mulsd %xmm1, %xmm7
movapd %xmm2, %xmm3
subsd %xmm6, %xmm3
cmpltsd %xmm2, %xmm7
andpd %xmm7, %xmm3
andnpd %xmm2, %xmm7
orpd %xmm3, %xmm7
movsd 0x3439(%rip), %xmm3     # 0x8038
movapd %xmm6, %xmm8
mulsd %xmm3, %xmm8
addsd %xmm7, %xmm6
movapd %xmm7, %xmm2
cmpltsd %xmm8, %xmm2
andpd %xmm2, %xmm6
andnpd %xmm7, %xmm2
orpd %xmm6, %xmm2
movapd %xmm4, %xmm6
mulsd %xmm1, %xmm6
movapd %xmm5, %xmm7
subsd %xmm4, %xmm7
cmpltsd %xmm5, %xmm6
andpd %xmm6, %xmm7
andnpd %xmm5, %xmm6
orpd %xmm7, %xmm6
movapd %xmm4, %xmm7
mulsd %xmm3, %xmm7
addsd %xmm6, %xmm4
movapd %xmm6, %xmm5
cmpltsd %xmm7, %xmm5
andpd %xmm5, %xmm4
andnpd %xmm6, %xmm5
orpd %xmm4, %xmm5
movsd 0x3228(%rax), %xmm4
mulsd %xmm4, %xmm1
movapd %xmm0, %xmm6
subsd %xmm4, %xmm6
cmpltsd %xmm0, %xmm1
andpd %xmm1, %xmm6
andnpd %xmm0, %xmm1
orpd %xmm6, %xmm1
mulsd %xmm4, %xmm3
addsd %xmm1, %xmm4
movapd %xmm1, %xmm0
cmpltsd %xmm3, %xmm0
andpd %xmm0, %xmm4
andnpd %xmm1, %xmm0
orpd %xmm4, %xmm0
mulsd %xmm5, %xmm5
mulsd %xmm2, %xmm2
addsd %xmm5, %xmm2
mulsd %xmm0, %xmm0
addsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4ccb
sqrtsd %xmm0, %xmm0
popq %rbp
retq
popq %rbp
jmp 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O1/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::PLM(int, int, double)
double CMolecularSystem::PLM(int l, int m, double x)
{
  double fact,pll,pmm,pmmp1,somx2;
  int i,ll;
  pll = 0.0;
  if (m < 0 || m > l || fabs(x) > 1.0)
  cerr << "impossible combination of l and m" << "\n";
  pmm=1.0;
  if (m > 0)
  {
    somx2=sqrt((1.0-x)*(1.0+x));
    fact=1.0;
    for (i=1;i<=m;i++)
    {
      pmm *= -fact*somx2;
      fact += 2.0;
    }
  }
  if (l == m)
    return pmm;
  else
  {
    pmmp1=x*(2*m+1)*pmm;
    if (l == (m+1))
      return pmmp1;
    else
    {
      for (ll=m+2;ll<=l;ll++)
        {
          pll=(x*(2*ll-1)*pmmp1-(ll+m-1)*pmm)/(ll-m);
          pmm=pmmp1;
          pmmp1=pll;
        }
        return pll;
     }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movapd %xmm0, %xmm5
movl %edx, %ebx
movl %esi, %r14d
testl %edx, %edx
js 0x4d07
cmpl %ebx, %r14d
jl 0x4d07
movapd 0x33a7(%rip), %xmm0     # 0x80a0
andpd %xmm5, %xmm0
ucomisd 0x3303(%rip), %xmm0     # 0x8008
jbe 0x4d40
movq 0x62e2(%rip), %r15      # 0xaff0
leaq 0x3579(%rip), %rsi      # 0x828e
movl $0x21, %edx
movq %r15, %rdi
movapd %xmm5, -0x30(%rbp)
callq 0x21f0
leaq 0x364c(%rip), %rsi      # 0x837a
movl $0x1, %edx
movq %r15, %rdi
callq 0x21f0
movapd -0x30(%rbp), %xmm5
movsd 0x32c0(%rip), %xmm6     # 0x8008
testl %ebx, %ebx
jle 0x4db5
movapd %xmm6, %xmm1
subsd %xmm5, %xmm1
movapd %xmm5, %xmm0
addsd %xmm6, %xmm0
mulsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4d70
sqrtsd %xmm0, %xmm0
jmp 0x4d87
movapd %xmm5, -0x30(%rbp)
callq 0x2150
movsd 0x3286(%rip), %xmm6     # 0x8008
movapd -0x30(%rbp), %xmm5
movapd 0x3321(%rip), %xmm1     # 0x80b0
movsd 0x32a9(%rip), %xmm2     # 0x8040
movl %ebx, %eax
movapd %xmm6, %xmm3
movapd %xmm3, %xmm4
xorpd %xmm1, %xmm4
mulsd %xmm0, %xmm4
mulsd %xmm4, %xmm6
addsd %xmm2, %xmm3
decl %eax
jne 0x4d9d
movl %r14d, %eax
subl %ebx, %eax
jne 0x4dc5
movapd %xmm6, %xmm0
jmp 0x4e46
leal 0x1(,%rbx,2), %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
mulsd %xmm5, %xmm1
mulsd %xmm6, %xmm1
leal 0x1(%rbx), %ecx
cmpl %r14d, %ecx
jne 0x4de9
movapd %xmm1, %xmm0
jmp 0x4e46
leal 0x2(%rbx), %ecx
xorpd %xmm0, %xmm0
cmpl %r14d, %ecx
jg 0x4e46
movl %ebx, %ecx
addl %ebx, %ebx
leal 0x3(,%rcx,2), %ecx
movl $0x1, %edx
movapd %xmm1, %xmm0
leal (%rbx,%rdx), %esi
xorps %xmm1, %xmm1
cvtsi2sd %esi, %xmm1
mulsd %xmm6, %xmm1
movapd %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
mulsd %xmm5, %xmm0
mulsd %xmm2, %xmm0
subsd %xmm1, %xmm0
incl %edx
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
addl $0x2, %ecx
movapd %xmm2, %xmm6
cmpl %edx, %eax
jne 0x4e09
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::convert_SphericalCoordinates(double, double, double, double&, double&, double&)
void CMolecularSystem::convert_SphericalCoordinates(double x, double y, double z, double &r, double &phi, double &theta)
{
  //r = sqrt(x*x + y*y + z*z);
  //if (y >= 0.0) { phi = acos(x/sqrt(x*x + y*y)); } else {phi = 2.0*pi - acos(x/sqrt(x*x + y*y)); }
  //if (fabs(x)<0.00000001 && fabs(y)<0.000000001) phi = 0.0;
  //theta = pi/2 - atan(z/sqrt(x*x + y*y));
  r = sqrt(x*x+y*y+z*z);
  theta = acos(z/r);
  phi = atan2(y,x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movapd %xmm2, %xmm3
movsd %xmm1, -0x28(%rbp)
movapd %xmm1, %xmm2
mulsd %xmm1, %xmm2
movsd %xmm0, -0x30(%rbp)
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movapd %xmm3, %xmm0
mulsd %xmm3, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4ea6
sqrtsd %xmm0, %xmm0
jmp 0x4eb5
movsd %xmm3, -0x20(%rbp)
callq 0x2150
movsd -0x20(%rbp), %xmm3
movsd %xmm0, (%r15)
divsd %xmm0, %xmm3
movapd %xmm3, %xmm0
callq 0x2180
movsd %xmm0, (%r14)
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
callq 0x2060
movsd %xmm0, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::YLM(int, int, double, double, double&, double&)
void CMolecularSystem::YLM(int l, int m, double theta, double phi, double &realYLM, double &imgYLM)
{
  double factor;
  double m_PLM;
  m_PLM = PLM(l,m,cos(theta));
  factor = ((2.0*double(l) + 1.0)*constants.factorials[l-m]) / (4.0*pi*constants.factorials[l+m]);
  realYLM = sqrt(factor) * m_PLM * cos(double(m)*phi);
  imgYLM  = sqrt(factor) * m_PLM * sin(double(m)*phi);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, %r14
movsd %xmm1, -0x38(%rbp)
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r13
callq 0x2380
movl %r12d, %esi
movl %r15d, %edx
callq 0x4cd2
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
cvtsi2sd %r12d, %xmm0
addsd %xmm0, %xmm0
addsd 0x30d0(%rip), %xmm0     # 0x8008
leal (%r15,%r12), %eax
subl %r15d, %r12d
movslq %r12d, %rcx
xorps %xmm1, %xmm1
cvtsi2sdl 0xb4e8c8(%r13,%rcx,4), %xmm1
mulsd %xmm0, %xmm1
cltq
xorps %xmm0, %xmm0
cvtsi2sdl 0xb4e8c8(%r13,%rax,4), %xmm0
mulsd 0x30de(%rip), %xmm0     # 0x8048
divsd %xmm0, %xmm1
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
xorpd %xmm2, %xmm2
movsd %xmm1, -0x40(%rbp)
ucomisd %xmm2, %xmm1
movsd %xmm0, -0x50(%rbp)
jae 0x4f93
movsd -0x40(%rbp), %xmm0
callq 0x2150
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x2380
mulsd -0x48(%rbp), %xmm0
movsd %xmm0, (%r14)
movsd -0x40(%rbp), %xmm0
ucomisd 0x3085(%rip), %xmm0     # 0x8050
movsd -0x50(%rbp), %xmm0
jae 0x4fdc
movsd -0x40(%rbp), %xmm0
callq 0x2150
movsd -0x30(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, -0x30(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x2080
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::QLM(int, int, int, int, double&, double&)
void CMolecularSystem::QLM(int l,int m,int ti,int tj,double &realYLM, double &imgYLM )
{
  double diffx, diffy, diffz;
  double r,phi,theta;
  realYLM = 0.0;
  imgYLM = 0.0;
  this->get_distance(ti,tj,diffx,diffy,diffz);
  this->convert_SphericalCoordinates(diffx, diffy, diffz, r, phi, theta);
  if (m < 0) {
    YLM(l, abs(m), theta, phi, realYLM, imgYLM);
    realYLM = pow(-1.0,m)*realYLM;
    imgYLM = pow(-1.0,m)*imgYLM;
  }
    else
  {
    YLM(l, m, theta, phi, realYLM, imgYLM);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %r15d
movl %esi, -0x38(%rbp)
movq %rdi, %r13
movq 0x10(%rbp), %rdx
xorl %eax, %eax
movq %r9, -0x40(%rbp)
movq %rax, (%r9)
movq %rdx, -0x48(%rbp)
movq %rax, (%rdx)
leaq -0x70(%rbp), %r12
leaq -0x68(%rbp), %rbx
leaq -0x60(%rbp), %r14
movl %ecx, %esi
movl %r8d, %edx
movq %r12, %rcx
movq %rbx, %r8
movq %r14, %r9
callq 0x516c
movsd (%r12), %xmm1
movsd (%rbx), %xmm0
movsd (%r14), %xmm2
movsd %xmm0, -0x50(%rbp)
mulsd %xmm0, %xmm0
movsd %xmm1, -0x58(%rbp)
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movapd %xmm2, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x509a
sqrtsd %xmm0, %xmm0
jmp 0x50a9
movsd %xmm2, -0x30(%rbp)
callq 0x2150
movsd -0x30(%rbp), %xmm2
divsd %xmm0, %xmm2
movapd %xmm2, %xmm0
callq 0x2180
movsd %xmm0, -0x30(%rbp)
movsd -0x50(%rbp), %xmm0
movsd -0x58(%rbp), %xmm1
callq 0x2060
movaps %xmm0, %xmm1
testl %r15d, %r15d
js 0x50fb
movq %r13, %rdi
movl -0x38(%rbp), %esi
movl %r15d, %edx
movsd -0x30(%rbp), %xmm0
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %r8
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4eea
movl %r15d, %edx
negl %edx
movq %r13, %rdi
movl -0x38(%rbp), %esi
movsd -0x30(%rbp), %xmm0
movq -0x40(%rbp), %r14
movq %r14, %rcx
movq -0x48(%rbp), %rbx
movq %rbx, %r8
callq 0x4eea
xorps %xmm1, %xmm1
cvtsi2sd %r15d, %xmm1
movsd %xmm1, -0x38(%rbp)
movsd 0x2f25(%rip), %xmm0     # 0x8058
callq 0x2340
mulsd (%r14), %xmm0
movsd %xmm0, (%r14)
movsd 0x2f0e(%rip), %xmm0     # 0x8058
movsd -0x38(%rbp), %xmm1
callq 0x2340
mulsd (%rbx), %xmm0
movsd %xmm0, (%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::get_distance(int, int, double&, double&, double&)
void CMolecularSystem::get_distance(int ti ,int tj ,double &diffx ,double &diffy,double &diffz)
{
  diffx = this->molecules[tj].posx - this->molecules[ti].posx;
  diffy = this->molecules[tj].posy - this->molecules[ti].posy;
  diffz = this->molecules[tj].posz - this->molecules[ti].posz;

  //nearest image
  if (diffx >  this->parameter->boxx/2.0) {diffx = diffx - this->parameter->boxx;};
  if (diffx < -this->parameter->boxx/2.0) {diffx = diffx + this->parameter->boxx;};
  if (diffy >  this->parameter->boxy/2.0) {diffy = diffy - this->parameter->boxy;};
  if (diffy < -this->parameter->boxy/2.0) {diffy = diffy + this->parameter->boxy;};
  if (diffz >  this->parameter->boxz/2.0) {diffz = diffz - this->parameter->boxz;};
  if (diffz < -this->parameter->boxz/2.0) {diffz = diffz + this->parameter->boxz;};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xb4e8b8(%rdi), %rax
movslq %edx, %rdx
imulq $0x870, %rdx, %rdx      # imm = 0x870
movsd 0x8(%rax,%rdx), %xmm0
movslq %esi, %rsi
imulq $0x870, %rsi, %rsi      # imm = 0x870
subsd 0x8(%rax,%rsi), %xmm0
movsd %xmm0, (%rcx)
movsd 0x10(%rax,%rdx), %xmm0
subsd 0x10(%rax,%rsi), %xmm0
movsd %xmm0, (%r8)
movsd 0x18(%rax,%rdx), %xmm0
subsd 0x18(%rax,%rsi), %xmm0
movsd %xmm0, (%r9)
movsd (%rcx), %xmm0
movq 0xb4e8c0(%rdi), %rax
movsd 0x3218(%rax), %xmm1
movsd 0x2e40(%rip), %xmm2     # 0x8018
mulsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x51ea
subsd %xmm1, %xmm0
movsd %xmm0, (%rcx)
movsd (%rcx), %xmm0
movsd 0x3218(%rax), %xmm1
movsd 0x2e3a(%rip), %xmm2     # 0x8038
mulsd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
jbe 0x5210
addsd %xmm1, %xmm0
movsd %xmm0, (%rcx)
movsd (%r8), %xmm0
movsd 0x3220(%rax), %xmm1
movsd 0x2df3(%rip), %xmm2     # 0x8018
mulsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x5238
subsd %xmm1, %xmm0
movsd %xmm0, (%r8)
movsd (%r8), %xmm0
movsd 0x3220(%rax), %xmm1
movsd 0x2deb(%rip), %xmm2     # 0x8038
mulsd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
jbe 0x5260
addsd %xmm1, %xmm0
movsd %xmm0, (%r8)
movsd (%r9), %xmm0
movsd 0x3228(%rax), %xmm1
movsd 0x2da3(%rip), %xmm2     # 0x8018
mulsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x5288
subsd %xmm1, %xmm0
movsd %xmm0, (%r9)
movsd (%r9), %xmm0
movsd 0x3228(%rax), %xmm1
movsd 0x2d9b(%rip), %xmm2     # 0x8038
mulsd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
jbe 0x52b0
addsd %xmm1, %xmm0
movsd %xmm0, (%r9)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::calculate_qFromComplexVector()
void CMolecularSystem::calculate_qFromComplexVector()
{
  int nop;
  nop = this->parameter->nop;
  double sumQ6,sumQ4;
  for (int ti= 0;ti<nop;ti++)
  {
    sumQ6 = 0.0;
    sumQ4 = 0.0;
    for (int mi = 0;mi < 13;mi++)
    {
      sumQ6 += this->molecules[ti].realQ6[mi]*this->molecules[ti].realQ6[mi] + this->molecules[ti].imgQ6[mi]*this->molecules[ti].imgQ6[mi];
      //if (ti == 0) {cout << ti << " " << mi << " " << this->molecules[ti].realQ6[mi]*this->molecules[ti].realQ6[mi] + this->molecules[ti].imgQ6[mi]*this->molecules[ti].imgQ6[mi] << "\n";}
    }
    sumQ6 = pow(((4.0*pi/13.0) * sumQ6),0.5);
    this->molecules[ti].Q6 = sumQ6;

    for (int mi = 0;mi < 9;mi++)
    {
	sumQ4 += this->molecules[ti].realQ4[mi]*this->molecules[ti].realQ4[mi] + this->molecules[ti].imgQ4[mi]*this->molecules[ti].imgQ4[mi];
    }
    sumQ4 = pow(((4.0*pi/9.0) * sumQ4),0.5);
    this->molecules[ti].Q4 = sumQ4;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xb4e8c0(%rdi), %rax
movslq 0x3208(%rax), %rax
movq %rax, -0x30(%rbp)
testq %rax, %rax
jle 0x57d3
movq %rdi, %rbx
movl $0x650, %r15d           # imm = 0x650
movl $0x5a0, %r12d           # imm = 0x5A0
xorl %r13d, %r13d
movq 0xb4e8b8(%rbx), %rax
addq %r15, %rax
xorpd %xmm0, %xmm0
movq $-0xd, %rcx
movsd (%rax,%rcx,8), %xmm1
movsd 0x68(%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
addsd %xmm1, %xmm0
incq %rcx
jne 0x571a
mulsd 0x291e(%rip), %xmm0     # 0x8060
movsd 0x28ce(%rip), %xmm1     # 0x8018
callq 0x2340
movq 0xb4e8b8(%rbx), %rax
imulq $0x870, %r13, %r14      # imm = 0x870
movsd %xmm0, 0x818(%rax,%r14)
addq %r12, %rax
xorpd %xmm0, %xmm0
movq $-0x9, %rcx
movsd (%rax,%rcx,8), %xmm1
movsd 0x48(%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
addsd %xmm1, %xmm0
incq %rcx
jne 0x5775
mulsd 0x28cb(%rip), %xmm0     # 0x8068
movsd 0x2873(%rip), %xmm1     # 0x8018
callq 0x2340
movq 0xb4e8b8(%rbx), %rax
movsd %xmm0, 0x820(%rax,%r14)
incq %r13
movl $0x870, %eax            # imm = 0x870
addq %rax, %r15
addq %rax, %r12
cmpq -0x30(%rbp), %r13
jne 0x5705
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::calculate_averagedqFromComplexVector()
void CMolecularSystem::calculate_averagedqFromComplexVector()
{
  int nop;
  nop = this->parameter->nop;
  double sumAQ4,sumAQ6;

  for (int ti= 0;ti<nop;ti++)
  {
    sumAQ4 = 0.0;
    for (int hi=0;hi<9;hi++)
    {
      sumAQ4 += this->molecules[ti].arealQ4[hi]*this->molecules[ti].arealQ4[hi]+ this->molecules[ti].aimgQ4[hi]*this->molecules[ti].aimgQ4[hi];
    }
    sumAQ4  = sumAQ4 * 4.0*pi/9.0;
    sumAQ4  = pow(sumAQ4 ,0.5);

    sumAQ6 = 0.0;
    for (int hi=0;hi<13;hi++)
    {
      sumAQ6 += this->molecules[ti].arealQ6[hi]*this->molecules[ti].arealQ6[hi]+ this->molecules[ti].aimgQ6[hi]*this->molecules[ti].aimgQ6[hi];
    }
    sumAQ6  = sumAQ6 * 4.0*pi/13.0;
    sumAQ6  = pow(sumAQ6 ,0.5);

    this->molecules[ti].AQ4 = sumAQ4;
    this->molecules[ti].AQ6 = sumAQ6;
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0xb4e8c0(%rdi), %rax
movslq 0x3208(%rax), %rax
movq %rax, -0x30(%rbp)
testq %rax, %rax
jle 0x5917
movq %rdi, %rbx
movl $0x700, %r15d           # imm = 0x700
movl $0x7b0, %r12d           # imm = 0x7B0
xorl %r13d, %r13d
movl $0x870, %r14d           # imm = 0x870
movq 0xb4e8b8(%rbx), %rax
addq %r15, %rax
xorpd %xmm0, %xmm0
movq $-0x9, %rcx
movsd (%rax,%rcx,8), %xmm1
movsd 0x48(%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
addsd %xmm1, %xmm0
incq %rcx
jne 0x583b
mulsd 0x280d(%rip), %xmm0     # 0x8070
mulsd 0x280d(%rip), %xmm0     # 0x8078
divsd 0x280d(%rip), %xmm0     # 0x8080
movsd 0x279d(%rip), %xmm1     # 0x8018
callq 0x2340
movsd %xmm0, -0x38(%rbp)
movq 0xb4e8b8(%rbx), %rax
addq %r12, %rax
xorpd %xmm0, %xmm0
movq $-0xd, %rcx
movsd (%rax,%rcx,8), %xmm1
movsd 0x68(%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
addsd %xmm1, %xmm0
incq %rcx
jne 0x589a
mulsd 0x27ae(%rip), %xmm0     # 0x8070
mulsd 0x27ae(%rip), %xmm0     # 0x8078
divsd 0x27b6(%rip), %xmm0     # 0x8088
movsd 0x273e(%rip), %xmm1     # 0x8018
callq 0x2340
movq 0xb4e8b8(%rbx), %rax
imulq $0x870, %r13, %rcx      # imm = 0x870
movsd -0x38(%rbp), %xmm1
movsd %xmm1, 0x840(%rax,%rcx)
movsd %xmm0, 0x838(%rax,%rcx)
incq %r13
addq %r14, %r15
addq %r14, %r12
cmpq -0x30(%rbp), %r13
jne 0x5826
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::get_NumberFromBond(int, int)
double CMolecularSystem::get_NumberFromBond(int ti,int tj)
{
  double sumSquareti,sumSquaretj;
  double realdotproduct,imgdotproduct;
  double connection;
  sumSquareti = 0.0;
  sumSquaretj = 0.0;
  realdotproduct = 0.0;
  imgdotproduct = 0.0;

  for (int mi = 0;mi < 13;mi++)
  {

    sumSquareti += this->molecules[ti].realQ6[mi]*this->molecules[ti].realQ6[mi] + this->molecules[ti].imgQ6[mi] *this->molecules[ti].imgQ6[mi];
    sumSquaretj += this->molecules[tj].realQ6[mi]*this->molecules[tj].realQ6[mi] + this->molecules[tj].imgQ6[mi] *this->molecules[tj].imgQ6[mi];
    realdotproduct += this->molecules[ti].realQ6[mi]*this->molecules[tj].realQ6[mi];
    imgdotproduct  += this->molecules[ti].imgQ6[mi] *this->molecules[tj].imgQ6[mi];
  }
  connection = (realdotproduct+imgdotproduct)/(sqrt(sumSquaretj)*sqrt(sumSquareti));
  return connection;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0xb4e8b8(%rdi), %rdi
movslq %esi, %rax
imulq $0x870, %rax, %rax      # imm = 0x870
addq %rdi, %rax
movslq %edx, %rcx
imulq $0x870, %rcx, %rcx      # imm = 0x870
addq %rdi, %rcx
xorpd %xmm6, %xmm6
movq $-0xd, %rdx
xorpd %xmm7, %xmm7
xorpd %xmm5, %xmm5
xorpd %xmm0, %xmm0
movsd 0x650(%rax,%rdx,8), %xmm2
movsd 0x6b8(%rax,%rdx,8), %xmm1
movapd %xmm1, %xmm3
mulsd %xmm1, %xmm3
movapd %xmm2, %xmm4
mulsd %xmm2, %xmm4
addsd %xmm3, %xmm4
addsd %xmm4, %xmm6
movsd 0x650(%rcx,%rdx,8), %xmm3
movsd 0x6b8(%rcx,%rdx,8), %xmm4
mulsd %xmm4, %xmm1
mulsd %xmm4, %xmm4
mulsd %xmm3, %xmm2
mulsd %xmm3, %xmm3
addsd %xmm4, %xmm3
addsd %xmm3, %xmm0
addsd %xmm2, %xmm5
addsd %xmm1, %xmm7
incq %rdx
jne 0x5bc8
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jb 0x5c3c
xorps %xmm1, %xmm1
sqrtsd %xmm0, %xmm1
jmp 0x5c67
movsd %xmm5, -0x10(%rbp)
movsd %xmm6, -0x8(%rbp)
movsd %xmm7, -0x18(%rbp)
callq 0x2150
xorpd %xmm2, %xmm2
movsd -0x18(%rbp), %xmm7
movsd -0x8(%rbp), %xmm6
movsd -0x10(%rbp), %xmm5
movapd %xmm0, %xmm1
addsd %xmm7, %xmm5
ucomisd %xmm2, %xmm6
jb 0x5c7a
xorps %xmm0, %xmm0
sqrtsd %xmm6, %xmm0
jmp 0x5c97
movapd %xmm6, %xmm0
movsd %xmm5, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
callq 0x2150
movsd -0x8(%rbp), %xmm1
movsd -0x10(%rbp), %xmm5
mulsd %xmm0, %xmm1
divsd %xmm1, %xmm5
movapd %xmm5, %xmm0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::calculate_frenkelNumbers()
void CMolecularSystem::calculate_frenkelNumbers()
{
  int frenkelcons;
  double scalar;
  for (int ti= 0;ti<this->parameter->nop;ti++)
  {
    frenkelcons = 0;
    for (int c = 0;c<this->molecules[ti].n_neighbors;c++)
    {
      scalar = this->get_NumberFromBond(ti,this->molecules[ti].neighbors[c]);
      if (scalar > 0.5) frenkelcons += 1;
    }
    this->molecules[ti].frenkelnumber = frenkelcons;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xb4e8c0(%rdi), %rax
cmpl $0x0, 0x3208(%rax)
jle 0x5d73
movq %rdi, %r14
movl $0xa0, %ecx
xorl %r13d, %r13d
movq 0xb4e8b8(%r14), %rax
imulq $0x870, %r13, %rbx      # imm = 0x870
cmpl $0x0, 0x550(%rax,%rbx)
jle 0x5d44
xorl %r12d, %r12d
xorl %r15d, %r15d
movq %rcx, -0x30(%rbp)
addq %rcx, %rax
movl (%rax,%r12,4), %edx
movq %r14, %rdi
movl %r13d, %esi
callq 0x5b88
movsd 0x2305(%rip), %xmm1     # 0x8018
xorl %eax, %eax
ucomisd %xmm1, %xmm0
seta %al
addl %eax, %r15d
incq %r12
movq 0xb4e8b8(%r14), %rax
movslq 0x550(%rax,%rbx), %rcx
cmpq %rcx, %r12
movq -0x30(%rbp), %rcx
jl 0x5cf9
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
jmp 0x5d48
xorpd %xmm0, %xmm0
movsd %xmm0, 0x858(%rax,%rbx)
incq %r13
movq 0xb4e8c0(%r14), %rax
movslq 0x3208(%rax), %rax
movl $0x870, %edx            # imm = 0x870
addq %rdx, %rcx
cmpq %rax, %r13
jl 0x5cd7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::writeQ4Q6Histograms()
void CMolecularSystem::writeQ4Q6Histograms()
{
  FILE *ofBCC,*ofFCC,*ofHCP,*ofLIQ;
  
  char IntStr[80];
  sprintf( IntStr, "./output/QBCC.dat") ;
  ofBCC = fopen(IntStr,"w");
  sprintf( IntStr, "./output/QFCC.dat") ;
  ofFCC = fopen(IntStr,"w");
  sprintf( IntStr, "./output/QHCP.dat") ;
  ofHCP = fopen(IntStr,"w");
  sprintf( IntStr, "./output/QLIQ.dat") ;
  ofLIQ = fopen(IntStr,"w");
  
  for (int j = 0;j<Q6SIZE;j++)
  {
    for (int i = 0;i<Q4SIZE;i++)
    {
      fprintf(ofBCC,"%d %d %.18lf\n",i ,j ,QBCC[i][j]);
      fprintf(ofFCC,"%d %d %.18lf\n",i ,j ,QFCC[i][j]);
      fprintf(ofHCP,"%d %d %.18lf\n",i ,j ,QHCP[i][j]);
      fprintf(ofLIQ,"%d %d %.18lf\n",i ,j ,QLIQ[i][j]);
    }
    fprintf(ofBCC,"\n");
    fprintf(ofFCC,"\n");
    fprintf(ofHCP,"\n");
    fprintf(ofLIQ,"\n");
  }
  fclose(ofBCC);
  fclose(ofFCC);
  fclose(ofHCP);
  fclose(ofLIQ);
 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r12
movups 0x2513(%rip), %xmm0     # 0x82b0
leaq -0xa0(%rbp), %rbx
movaps %xmm0, (%rbx)
movw $0x74, %r15w
movw %r15w, 0x10(%rbx)
leaq 0x250a(%rip), %r14      # 0x82c2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200
movq %rax, -0x38(%rbp)
movw %r15w, 0x10(%rbx)
movups 0x24f1(%rip), %xmm0     # 0x82c4
movaps %xmm0, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200
movq %rax, %r13
movw %r15w, 0x10(%rbx)
movups 0x24e6(%rip), %xmm0     # 0x82d6
movaps %xmm0, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200
movq %rax, -0x30(%rbp)
movw %r15w, 0x10(%rbx)
movups 0x24da(%rip), %xmm0     # 0x82e8
movaps %xmm0, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200
addq $0x7a50b8, %r12         # imm = 0x7A50B8
xorl %ebx, %ebx
leaq 0x24ce(%rip), %r14      # 0x82fa
movq %rax, -0x48(%rbp)
movq %r13, -0x40(%rbp)
movq %r12, -0x50(%rbp)
xorl %r15d, %r15d
movq -0x38(%rbp), %r13
movsd (%r12), %xmm0
movq %r13, %rdi
movq %r14, %rsi
movl %r15d, %edx
movl %ebx, %ecx
movb $0x1, %al
callq 0x2280
movsd 0xea600(%r12), %xmm0
movq -0x40(%rbp), %rdi
movq %r14, %rsi
movl %r15d, %edx
movl %ebx, %ecx
movb $0x1, %al
callq 0x2280
movsd 0x1d4c00(%r12), %xmm0
movq -0x30(%rbp), %rdi
movq %r14, %rsi
movl %r15d, %edx
movl %ebx, %ecx
movb $0x1, %al
callq 0x2280
movsd 0x2bf200(%r12), %xmm0
movq -0x48(%rbp), %rdi
movq %r14, %rsi
movl %r15d, %edx
movl %ebx, %ecx
movb $0x1, %al
callq 0x2280
incq %r15
addq $0x12c0, %r12           # imm = 0x12C0
cmpq $0xc8, %r15
jne 0x5e3f
movl $0xa, %edi
movq %r13, %rsi
callq 0x2230
movl $0xa, %edi
movq -0x40(%rbp), %r13
movq %r13, %rsi
callq 0x2230
movl $0xa, %edi
movq -0x30(%rbp), %rsi
callq 0x2230
movl $0xa, %edi
movq -0x48(%rbp), %r15
movq %r15, %rsi
callq 0x2230
incq %rbx
movq -0x50(%rbp), %r12
addq $0x8, %r12
cmpq $0x258, %rbx            # imm = 0x258
jne 0x5e34
movq -0x38(%rbp), %rdi
callq 0x21a0
movq %r13, %rdi
callq 0x21a0
movq -0x30(%rbp), %rdi
callq 0x21a0
movq %r15, %rdi
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::norm_Q4Q6Histograms()
void CMolecularSystem::norm_Q4Q6Histograms()
{
  double normBCC, normHCP, normFCC, normLIQ;
  normBCC = 0.0;
  normHCP = 0.0;
  normFCC = 0.0;
  normLIQ = 0.0;
  for (int ti = 0;ti<Q4SIZE;ti++)
  {
    for (int tj = 0;tj<Q6SIZE;tj++)
    {
      normBCC += QBCC[ti][tj];
      normFCC += QFCC[ti][tj];
      normHCP += QHCP[ti][tj];
      normLIQ += QLIQ[ti][tj];
    }
  }
  for (int ti = 0;ti<Q4SIZE;ti++)
  {
    for (int tj = 0;tj<Q6SIZE;tj++)
    {
      QBCC[ti][tj] /= normBCC;
      QFCC[ti][tj] /= normFCC;
      QHCP[ti][tj] /= normHCP;
      QLIQ[ti][tj] /= normLIQ;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xa642b8(%rdi), %rax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
xorpd %xmm3, %xmm3
xorl %edx, %edx
addsd -0x2bf200(%rax,%rdx,8), %xmm3
addsd -0x1d4c00(%rax,%rdx,8), %xmm1
addsd -0xea600(%rax,%rdx,8), %xmm2
addsd (%rax,%rdx,8), %xmm0
incq %rdx
cmpq $0x258, %rdx            # imm = 0x258
jne 0x5f69
incq %rcx
addq $0x12c0, %rax           # imm = 0x12C0
cmpq $0xc8, %rcx
jne 0x5f67
addq $0xa642b8, %rdi         # imm = 0xA642B8
xorl %eax, %eax
xorl %ecx, %ecx
movsd -0x2bf200(%rdi,%rcx,8), %xmm4
divsd %xmm3, %xmm4
movsd %xmm4, -0x2bf200(%rdi,%rcx,8)
movsd -0x1d4c00(%rdi,%rcx,8), %xmm4
divsd %xmm1, %xmm4
movsd %xmm4, -0x1d4c00(%rdi,%rcx,8)
movsd -0xea600(%rdi,%rcx,8), %xmm4
divsd %xmm2, %xmm4
movsd %xmm4, -0xea600(%rdi,%rcx,8)
movsd (%rdi,%rcx,8), %xmm4
divsd %xmm0, %xmm4
movsd %xmm4, (%rdi,%rcx,8)
incq %rcx
cmpq $0x258, %rcx            # imm = 0x258
jne 0x5fb2
incq %rax
addq $0x12c0, %rdi           # imm = 0x12C0
cmpq $0xc8, %rax
jne 0x5fb0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::sample_Q4Q6Histograms()
void CMolecularSystem::sample_Q4Q6Histograms()
{
  int q4box,q6box;
  for (int ti= 0;ti<this->parameter->nop;ti++)
  {
    q4box = int(this->molecules[ti].AQ4 * Q4FACTOR);
    q6box = int(this->molecules[ti].AQ6 * Q4FACTOR);
    this->QBCC[q4box][q6box] += 1.0;
    this->QFCC[q4box][q6box] += 1.0;
    this->QHCP[q4box][q6box] += 1.0;
    this->QLIQ[q4box][q6box] += 1.0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq 0xb4e8c0(%rdi), %rax
movslq 0x3208(%rax), %r8
testq %r8, %r8
jle 0x610d
movq 0xb4e8b8(%rdi), %rax
leaq 0x7a50b8(%rdi), %rcx
leaq 0x88f6b8(%rdi), %rdx
leaq 0x979cb8(%rdi), %rsi
addq $0xa642b8, %rdi         # imm = 0xA642B8
imulq $0x870, %r8, %r8        # imm = 0x870
xorl %r9d, %r9d
movsd 0x201d(%rip), %xmm0     # 0x8090
movsd 0x1f8d(%rip), %xmm1     # 0x8008
movsd 0x840(%rax,%r9), %xmm2
mulsd %xmm0, %xmm2
movsd 0x838(%rax,%r9), %xmm3
cvttsd2si %xmm2, %r10d
mulsd %xmm0, %xmm3
cvttsd2si %xmm3, %r11d
movslq %r10d, %r10
movslq %r11d, %r11
imulq $0x12c0, %r10, %r10     # imm = 0x12C0
leaq (%rcx,%r10), %rbx
movsd (%rbx,%r11,8), %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, (%rbx,%r11,8)
leaq (%rdx,%r10), %rbx
movsd (%rbx,%r11,8), %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, (%rbx,%r11,8)
leaq (%rsi,%r10), %rbx
movsd (%rbx,%r11,8), %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, (%rbx,%r11,8)
addq %rdi, %r10
movsd (%r10,%r11,8), %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, (%r10,%r11,8)
addq $0x870, %r9             # imm = 0x870
cmpq %r9, %r8
jne 0x607b
popq %rbx
popq %rbp
retq