LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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, -0x30(%rbp)
movq 0x10(%rbp), %rax
movq %r9, -0x38(%rbp)
andq $0x0, (%r9)
movq %rdi, %r13
movq %rax, -0x40(%rbp)
andq $0x0, (%rax)
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 0x4858
movsd (%r12), %xmm0
movsd (%rbx), %xmm1
movsd (%r14), %xmm2
leaq -0x58(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x45c0
testl %r15d, %r15d
js 0x47e6
movsd -0x48(%rbp), %xmm0
movsd -0x50(%rbp), %xmm1
movq %r13, %rdi
movl -0x30(%rbp), %esi
movl %r15d, %edx
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %r8
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4632
movl %r15d, %edx
negl %edx
movsd -0x48(%rbp), %xmm0
movsd -0x50(%rbp), %xmm1
movq %r13, %rdi
movl -0x30(%rbp), %esi
movq -0x38(%rbp), %r14
movq %r14, %rcx
movq -0x40(%rbp), %rbx
movq %rbx, %r8
callq 0x4632
cvtsi2sd %r15d, %xmm1
movsd %xmm1, -0x30(%rbp)
movsd 0x2838(%rip), %xmm0     # 0x7058
callq 0x2340
mulsd (%r14), %xmm0
movsd %xmm0, (%r14)
movsd 0x2821(%rip), %xmm0     # 0x7058
movsd -0x30(%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
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2754(%rip), %xmm2     # 0x7018
mulsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x48de
subsd %xmm1, %xmm0
movsd %xmm0, (%rcx)
movsd 0x3218(%rax), %xmm1
movsd 0x2752(%rip), %xmm2     # 0x7038
mulsd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
jbe 0x48f8
addsd %xmm1, %xmm0
movsd %xmm0, (%rcx)
movsd (%r8), %xmm0
movsd 0x3220(%rax), %xmm1
movsd 0x270b(%rip), %xmm2     # 0x7018
mulsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x4928
subsd %xmm1, %xmm0
movsd %xmm0, (%r8)
movsd 0x3220(%rax), %xmm1
movsd 0x2708(%rip), %xmm2     # 0x7038
mulsd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
jbe 0x4943
addsd %xmm1, %xmm0
movsd %xmm0, (%r8)
movsd (%r9), %xmm0
movsd 0x3228(%rax), %xmm1
movsd 0x26c0(%rip), %xmm2     # 0x7018
mulsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x4973
subsd %xmm1, %xmm0
movsd %xmm0, (%r9)
movsd 0x3228(%rax), %xmm1
movsd 0x26bd(%rip), %xmm2     # 0x7038
mulsd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
jbe 0x498e
addsd %xmm1, %xmm0
movsd %xmm0, (%r9)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::calculate_averageComplexQLM()
void CMolecularSystem::calculate_averageComplexQLM()
{
  int nop;
  nop = this->parameter->nop;
  double realNQ6[13],imgNQ6[13];
  double realNQ4[9],imgNQ4[9];

  for (int ti= 0;ti<nop;ti++)
  {
    for (int mi=0;mi<13;mi++)
    {
      realNQ6[mi] = this->molecules[ti].realQ6[mi];
      imgNQ6[mi]  = this->molecules[ti].imgQ6[mi];
      for (int ci = 0;ci<this->molecules[ti].n_neighbors;ci++)
      {
        realNQ6[mi] += this->molecules[this->molecules[ti].neighbors[ci]].realQ6[mi];
        imgNQ6[mi]  += this->molecules[this->molecules[ti].neighbors[ci]].imgQ6[mi];
      }
      realNQ6[mi] = realNQ6[mi]/double(this->molecules[ti].n_neighbors+1);
      imgNQ6[mi]  = imgNQ6[mi]/double(this->molecules[ti].n_neighbors+1);

      this->molecules[ti].arealQ6[mi] = realNQ6[mi];
      this->molecules[ti].aimgQ6[mi] = imgNQ6[mi];
    }

    for (int mi=0;mi<9;mi++)
    {
      realNQ4[mi] = this->molecules[ti].realQ4[mi];
      imgNQ4[mi]  = this->molecules[ti].imgQ4[mi];
      for (int ci = 0;ci<this->molecules[ti].n_neighbors;ci++)
      {
        realNQ4[mi] += this->molecules[this->molecules[ti].neighbors[ci]].realQ4[mi];
        imgNQ4[mi]  += this->molecules[this->molecules[ti].neighbors[ci]].imgQ4[mi];
      }
      realNQ4[mi] = realNQ4[mi]/double(this->molecules[ti].n_neighbors+1);
      imgNQ4[mi]  = imgNQ4[mi]/double(this->molecules[ti].n_neighbors+1);

      this->molecules[ti].arealQ4[mi] = realNQ4[mi];
      this->molecules[ti].aimgQ4[mi] = imgNQ4[mi];
    }

  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq 0xb4e8b8(%rdi), %rax
movq 0xb4e8c0(%rdi), %rcx
movl 0x3208(%rcx), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
leaq 0xa0(%rax), %rsi
xorl %edi, %edi
cmpq %rcx, %rdi
je 0x4ca3
imulq $0x870, %rdi, %r8       # imm = 0x870
movl 0x550(%rax,%r8), %r9d
leal 0x1(%r9), %r10d
cvtsi2sd %r10d, %xmm0
testl %r9d, %r9d
cmovlel %edx, %r9d
addq %rax, %r8
xorl %r10d, %r10d
cmpq $0xd, %r10
je 0x4c27
movsd 0x5e8(%r8,%r10,8), %xmm2
movsd 0x650(%r8,%r10,8), %xmm1
xorl %r11d, %r11d
cmpq %r11, %r9
je 0x4c06
movslq (%rsi,%r11,4), %rbx
imulq $0x870, %rbx, %rbx      # imm = 0x870
addq %rax, %rbx
addsd 0x5e8(%rbx,%r10,8), %xmm2
addsd 0x650(%rbx,%r10,8), %xmm1
incq %r11
jmp 0x4bda
divsd %xmm0, %xmm2
divsd %xmm0, %xmm1
movsd %xmm2, 0x748(%r8,%r10,8)
movsd %xmm1, 0x7b0(%r8,%r10,8)
incq %r10
jmp 0x4bbd
xorl %r10d, %r10d
cmpq $0x9, %r10
je 0x4c94
movsd 0x558(%r8,%r10,8), %xmm2
movsd 0x5a0(%r8,%r10,8), %xmm1
xorl %r11d, %r11d
cmpq %r11, %r9
je 0x4c73
movslq (%rsi,%r11,4), %rbx
imulq $0x870, %rbx, %rbx      # imm = 0x870
addq %rax, %rbx
addsd 0x558(%rbx,%r10,8), %xmm2
addsd 0x5a0(%rbx,%r10,8), %xmm1
incq %r11
jmp 0x4c47
divsd %xmm0, %xmm2
divsd %xmm0, %xmm1
movsd %xmm2, 0x6b8(%r8,%r10,8)
movsd %xmm1, 0x700(%r8,%r10,8)
incq %r10
jmp 0x4c2a
incq %rdi
addq $0x870, %rsi            # imm = 0x870
jmp 0x4b8f
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
movq 0xb4e8c0(%rdi), %rax
movl 0x3208(%rax), %eax
xorl %r15d, %r15d
testl %eax, %eax
cmovlel %r15d, %eax
movq %rax, -0x30(%rbp)
movl $0x650, %r12d           # imm = 0x650
movl $0x5a0, %r13d           # imm = 0x5A0
cmpq -0x30(%rbp), %r15
je 0x4db4
movq 0xb4e8b8(%rbx), %rax
addq %r12, %rax
xorpd %xmm0, %xmm0
pushq $-0x68
popq %rcx
testq %rcx, %rcx
je 0x4d1e
movsd (%rax,%rcx), %xmm1
movsd 0x68(%rax,%rcx), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
addsd %xmm1, %xmm0
addq $0x8, %rcx
jmp 0x4cf8
mulsd 0x233a(%rip), %xmm0     # 0x7060
movsd 0x22ea(%rip), %xmm1     # 0x7018
callq 0x2340
movq 0xb4e8b8(%rbx), %rax
imulq $0x870, %r15, %r14      # imm = 0x870
movsd %xmm0, 0x818(%rax,%r14)
addq %r13, %rax
xorpd %xmm0, %xmm0
pushq $-0x48
popq %rcx
testq %rcx, %rcx
je 0x4d7b
movsd (%rax,%rcx), %xmm1
movsd 0x48(%rax,%rcx), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
addsd %xmm1, %xmm0
addq $0x8, %rcx
jmp 0x4d55
mulsd 0x22e5(%rip), %xmm0     # 0x7068
movsd 0x228d(%rip), %xmm1     # 0x7018
callq 0x2340
movq 0xb4e8b8(%rbx), %rax
movsd %xmm0, 0x820(%rax,%r14)
incq %r15
movl $0x870, %eax            # imm = 0x870
addq %rax, %r12
addq %rax, %r13
jmp 0x4cdd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rdi, %rbx
movq 0xb4e8c0(%rdi), %rax
movl 0x3208(%rax), %r14d
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
movl $0x700, %r12d           # imm = 0x700
movl $0x7b0, %r13d           # imm = 0x7B0
cmpq %r14, %r15
je 0x4ef7
movq 0xb4e8b8(%rbx), %rax
addq %r12, %rax
xorpd %xmm0, %xmm0
pushq $-0x48
popq %rcx
testq %rcx, %rcx
je 0x4e39
movsd (%rax,%rcx), %xmm1
movsd 0x48(%rax,%rcx), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
addsd %xmm1, %xmm0
addq $0x8, %rcx
jmp 0x4e13
mulsd 0x222f(%rip), %xmm0     # 0x7070
mulsd 0x222f(%rip), %xmm0     # 0x7078
divsd 0x222f(%rip), %xmm0     # 0x7080
movsd 0x21bf(%rip), %xmm1     # 0x7018
callq 0x2340
movsd %xmm0, -0x30(%rbp)
movq 0xb4e8b8(%rbx), %rax
addq %r13, %rax
xorpd %xmm0, %xmm0
pushq $-0x68
popq %rcx
testq %rcx, %rcx
je 0x4e9a
movsd (%rax,%rcx), %xmm1
movsd 0x68(%rax,%rcx), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
addsd %xmm1, %xmm0
addq $0x8, %rcx
jmp 0x4e74
mulsd 0x21ce(%rip), %xmm0     # 0x7070
mulsd 0x21ce(%rip), %xmm0     # 0x7078
divsd 0x21d6(%rip), %xmm0     # 0x7088
movsd 0x215e(%rip), %xmm1     # 0x7018
callq 0x2340
movq 0xb4e8b8(%rbx), %rax
imulq $0x870, %r15, %rcx      # imm = 0x870
movsd -0x30(%rbp), %xmm1
movsd %xmm1, 0x840(%rax,%rcx)
movsd %xmm0, 0x838(%rax,%rcx)
incq %r15
movl $0x870, %eax            # imm = 0x870
addq %rax, %r12
addq %rax, %r13
jmp 0x4df9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %xmm0, %xmm0
pushq $-0xd
popq %rdx
xorpd %xmm5, %xmm5
xorpd %xmm7, %xmm7
xorpd %xmm6, %xmm6
testq %rdx, %rdx
je 0x519c
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
jmp 0x5136
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jb 0x51ac
sqrtsd %xmm0, %xmm1
jmp 0x51d7
movsd %xmm5, -0x10(%rbp)
movsd %xmm6, -0x8(%rbp)
movsd %xmm7, -0x18(%rbp)
callq 0x2160
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 0x51e7
sqrtsd %xmm6, %xmm0
jmp 0x5204
movapd %xmm6, %xmm0
movsd %xmm5, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
callq 0x2160
movsd -0x8(%rbp), %xmm1
movsd -0x10(%rbp), %xmm5
mulsd %xmm0, %xmm1
divsd %xmm1, %xmm5
movapd %xmm5, %xmm0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
movl $0xa0, %eax
movq %rax, -0x30(%rbp)
xorl %r14d, %r14d
movq 0xb4e8c0(%rbx), %rax
movslq 0x3208(%rax), %rax
cmpq %rax, %r14
jge 0x52ac
xorl %r13d, %r13d
imulq $0x870, %r14, %r12      # imm = 0x870
xorl %r15d, %r15d
movq 0xb4e8b8(%rbx), %rax
movslq 0x550(%rax,%r12), %rcx
cmpq %rcx, %r13
jge 0x528f
addq -0x30(%rbp), %rax
movl (%rax,%r13,4), %edx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x50fa
xorl %eax, %eax
ucomisd 0x1d94(%rip), %xmm0     # 0x7018
seta %al
addl %eax, %r15d
incq %r13
jmp 0x5253
cvtsi2sd %r15d, %xmm0
addq %r12, %rax
movsd %xmm0, 0x858(%rax)
incq %r14
addq $0x870, -0x30(%rbp)     # imm = 0x870
jmp 0x5233
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1fd9(%rip), %xmm0     # 0x72b0
leaq -0xa0(%rbp), %rbx
movaps %xmm0, (%rbx)
movw $0x74, %r15w
movw %r15w, 0x10(%rbx)
leaq 0x1fd0(%rip), %r14      # 0x72c2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2210
movq %rax, -0x40(%rbp)
movw %r15w, 0x10(%rbx)
movups 0x1fb7(%rip), %xmm0     # 0x72c4
movaps %xmm0, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2210
movq %rax, -0x38(%rbp)
movw %r15w, 0x10(%rbx)
movups 0x1fab(%rip), %xmm0     # 0x72d6
movaps %xmm0, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2210
movq %rax, -0x30(%rbp)
movw %r15w, 0x10(%rbx)
movups 0x1f9f(%rip), %xmm0     # 0x72e8
movaps %xmm0, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2210
movq %rax, %r13
addq $0x7a50b8, %r12         # imm = 0x7A50B8
xorl %ebx, %ebx
leaq 0x1f90(%rip), %r14      # 0x72fa
cmpq $0x258, %rbx            # imm = 0x258
je 0x5448
movq %r12, -0x48(%rbp)
xorl %r15d, %r15d
cmpq $0xc8, %r15
je 0x5405
movsd (%r12), %xmm0
movq -0x40(%rbp), %rdi
movq %r14, %rsi
movl %r15d, %edx
movl %ebx, %ecx
movb $0x1, %al
callq 0x2290
movsd 0xea600(%r12), %xmm0
movq -0x38(%rbp), %rdi
movq %r14, %rsi
movl %r15d, %edx
movl %ebx, %ecx
movb $0x1, %al
callq 0x2290
movsd 0x1d4c00(%r12), %xmm0
movq -0x30(%rbp), %rdi
movq %r14, %rsi
movl %r15d, %edx
movl %ebx, %ecx
movb $0x1, %al
callq 0x2290
movsd 0x2bf200(%r12), %xmm0
movq %r13, %rdi
movq %r14, %rsi
movl %r15d, %edx
movl %ebx, %ecx
movb $0x1, %al
callq 0x2290
incq %r15
addq $0x12c0, %r12           # imm = 0x12C0
jmp 0x537e
pushq $0xa
popq %r15
movl %r15d, %edi
movq -0x40(%rbp), %rsi
callq 0x2240
movl %r15d, %edi
movq -0x38(%rbp), %rsi
callq 0x2240
movl %r15d, %edi
movq -0x30(%rbp), %rsi
callq 0x2240
movl %r15d, %edi
movq %r13, %rsi
callq 0x2240
incq %rbx
movq -0x48(%rbp), %r12
addq $0x8, %r12
jmp 0x536a
movq -0x40(%rbp), %rdi
callq 0x21c0
movq -0x38(%rbp), %rdi
callq 0x21c0
movq -0x30(%rbp), %rdi
callq 0x21c0
movq %r13, %rdi
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
addq $0xa642b8, %rdi         # imm = 0xA642B8
xorpd %xmm0, %xmm0
xorl %eax, %eax
movq %rdi, %rcx
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
xorpd %xmm3, %xmm3
cmpq $0xc8, %rax
je 0x54de
xorl %edx, %edx
cmpq $0x258, %rdx            # imm = 0x258
je 0x54d2
addsd -0x2bf200(%rcx,%rdx,8), %xmm0
addsd -0x1d4c00(%rcx,%rdx,8), %xmm2
addsd -0xea600(%rcx,%rdx,8), %xmm1
addsd (%rcx,%rdx,8), %xmm3
incq %rdx
jmp 0x54a4
incq %rax
addq $0x12c0, %rcx           # imm = 0x12C0
jmp 0x549a
xorl %eax, %eax
cmpq $0xc8, %rax
je 0x5554
xorl %ecx, %ecx
cmpq $0x258, %rcx            # imm = 0x258
je 0x5548
movsd -0x2bf200(%rdi,%rcx,8), %xmm4
divsd %xmm0, %xmm4
movsd %xmm4, -0x2bf200(%rdi,%rcx,8)
movsd -0x1d4c00(%rdi,%rcx,8), %xmm4
divsd %xmm2, %xmm4
movsd %xmm4, -0x1d4c00(%rdi,%rcx,8)
movsd -0xea600(%rdi,%rcx,8), %xmm4
divsd %xmm1, %xmm4
movsd %xmm4, -0xea600(%rdi,%rcx,8)
movsd (%rdi,%rcx,8), %xmm4
divsd %xmm3, %xmm4
movsd %xmm4, (%rdi,%rcx,8)
incq %rcx
jmp 0x54ea
incq %rax
addq $0x12c0, %rdi           # imm = 0x12C0
jmp 0x54e0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %rax
leaq 0x7a50b8(%rdi), %rcx
leaq 0x88f6b8(%rdi), %rdx
leaq 0x979cb8(%rdi), %rsi
movl $0x840, %r8d            # imm = 0x840
addq 0xb4e8b8(%rdi), %r8
addq $0xa642b8, %rdi         # imm = 0xA642B8
xorl %r9d, %r9d
movsd 0x1af3(%rip), %xmm0     # 0x7090
movsd 0x1a63(%rip), %xmm1     # 0x7008
cmpq %rax, %r9
jge 0x5636
movsd (%r8), %xmm2
mulsd %xmm0, %xmm2
cvttsd2si %xmm2, %r10d
movsd -0x8(%r8), %xmm2
mulsd %xmm0, %xmm2
cvttsd2si %xmm2, %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)
incq %r9
addq $0x870, %r8             # imm = 0x870
jmp 0x55a5
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::get_HistoBox(double, double, double, int)
int CMolecularSystem::get_HistoBox(double value,double a, double b, int n)
{
  int box;
  box = 0;
  if ((value < a) || (value > b))
  {
   cerr << "value out of Histogram bound, check OrderParameterHistoStart and OrderParameterHistoStop\n";
  } else {
    box = int((value - a)/(b - a)*n);
  }
  return box;
}

// Assembly:
ucomisd %xmm0, %xmm1
ja 0x565f
ucomisd %xmm2, %xmm0
ja 0x565f
subsd %xmm1, %xmm0
subsd %xmm1, %xmm2
cvtsi2sd %esi, %xmm1
divsd %xmm2, %xmm0
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
retq
pushq %rbp
movq %rsp, %rbp
movq 0x4986(%rip), %rdi      # 0x9ff0
leaq 0x1c97(%rip), %rsi      # 0x7308
callq 0x21b0
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::calculate_bondOrderParameter()
void CMolecularSystem::calculate_bondOrderParameter()
{
  //Find all particles within a radius of neighbordistance
  this->get_AllNeighbors();
  //Calculate q_lm vector
  this->calculate_complexQLM();
  //Calculate averaged version of q_lm as in J. Chem. Phys. 129, 114707 (2008)
  this->calculate_averageComplexQLM();
  //From these vectors calculate the q_4 and q_4
  this->calculate_qFromComplexVector();
  //and also aq_4 and aq_6
  this->calculate_averagedqFromComplexVector();
  //and Q_6 and Q_4
  this->calculate_globalqFromComplexVector();
  //and the number of bonds to find the largest cluster
  this->calculate_frenkelNumbers();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x41b8
movq %rbx, %rdi
callq 0x4990
movq %rbx, %rdi
callq 0x4b66
movq %rbx, %rdi
callq 0x4ca6
movq %rbx, %rdi
callq 0x4dc4
movq %rbx, %rdi
callq 0x4f06
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5216
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::clusterCriterium(int, int)
int CMolecularSystem::clusterCriterium(int ti,int criterium)
{
  int value;
  value = 0;
  if (criterium == 0)
  {
    if (this->molecules[ti].frenkelnumber > parameter->minfrenkel)
    { value = 1; } else {value = 0;}
  }
  return value;
}

// Assembly:
xorl %eax, %eax
testl %edx, %edx
je 0x590f
retq
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rax
imulq $0x870, %rax, %rax      # imm = 0x870
movq 0xb4e8b8(%rdi), %rcx
movq 0xb4e8c0(%rdi), %rdx
movsd 0x858(%rcx,%rax), %xmm0
cvtsi2sdl 0x3210(%rdx), %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
seta %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::harvestCluster(int, int, int)
void CMolecularSystem::harvestCluster(int ti,int numberofCluster,int criterium)
{
  int c;
  int neighbor;
  c = 0;
  do
  {
    neighbor =  this->molecules[ti].neighbors[c];
    if ((this->molecules[neighbor].belongsto == nilvalue) && (clusterCriterium(neighbor,criterium)))
    {
      this->molecules[neighbor].belongsto = numberofCluster;
      harvestCluster(neighbor,numberofCluster,criterium);
    }
    c += 1;
    } while (this->molecules[ti].neighbors[c] != nilvalue);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, -0x30(%rbp)
movq %rdi, %r15
movslq %esi, %rax
movq 0xb4e8b8(%rdi), %r14
imulq $0x870, %rax, %r13      # imm = 0x870
movl 0xa0(%r14,%r13), %r12d
addq $0xa4, %r13
movl %ecx, -0x2c(%rbp)
movslq %r12d, %rax
imulq $0x870, %rax, %rbx      # imm = 0x870
cmpl $0x1fca055, 0x860(%r14,%rbx) # imm = 0x1FCA055
jne 0x59d5
movq %r15, %rdi
movl %r12d, %esi
movl %ecx, %edx
callq 0x5908
testl %eax, %eax
je 0x59d2
leaq (%r14,%rbx), %rax
addq $0x860, %rax            # imm = 0x860
movl -0x30(%rbp), %edx
movl %edx, (%rax)
movq %r15, %rdi
movl %r12d, %esi
movl -0x2c(%rbp), %ebx
movl %ebx, %ecx
callq 0x5948
movq 0xb4e8b8(%r15), %r14
movl %ebx, %ecx
jmp 0x59d5
movl -0x2c(%rbp), %ecx
movl (%r14,%r13), %r12d
addq $0x4, %r13
cmpl $0x1fca055, %r12d       # imm = 0x1FCA055
jne 0x597f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::buildClusters(int)
int CMolecularSystem::buildClusters(int criterium)
{
  int numberofCluster;
  int nop;
  nop = parameter->nop;
  numberofCluster = 0;
  for (int ti= 0;ti<nop;ti++)
  {
    this->molecules[ti].belongsto = nilvalue;
  }
  for (int ti= 0;ti<nop;ti++)
  {
    if ((this->molecules[ti].belongsto == nilvalue) && (clusterCriterium(ti,criterium)))
    {
      numberofCluster += 1;
      this->molecules[ti].belongsto = numberofCluster;
      harvestCluster(ti,numberofCluster,criterium);
    }
  }
  return numberofCluster;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r12d
movq %rdi, %r14
movq 0xb4e8b8(%rdi), %rax
movq 0xb4e8c0(%rdi), %rcx
movl 0x3208(%rcx), %r8d
xorl %ecx, %ecx
testl %r8d, %r8d
cmovlel %ecx, %r8d
imulq $0x870, %r8, %rsi       # imm = 0x870
cmpq %rcx, %rsi
je 0x5a4b
movl $0x1fca055, 0x860(%rax,%rcx) # imm = 0x1FCA055
addq $0x870, %rcx            # imm = 0x870
jmp 0x5a32
xorl %r15d, %r15d
movl $0x860, %ebx            # imm = 0x860
movl $0x0, -0x2c(%rbp)
movq %r8, -0x38(%rbp)
cmpq %r15, %r8
je 0x5ab2
movq 0xb4e8b8(%r14), %r13
cmpl $0x1fca055, (%r13,%rbx) # imm = 0x1FCA055
jne 0x5aa6
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0x5908
testl %eax, %eax
je 0x5aa2
movl -0x2c(%rbp), %edx
incl %edx
movl %edx, (%r13,%rbx)
movq %r14, %rdi
movl %r15d, %esi
movl %edx, -0x2c(%rbp)
movl %r12d, %ecx
callq 0x5948
movq -0x38(%rbp), %r8
incq %r15
addq $0x870, %rbx            # imm = 0x870
jmp 0x5a5e
movl -0x2c(%rbp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::get_greatestCluster(int, int&)
int CMolecularSystem::get_greatestCluster(int criterium,int &greatestbelongsto)
{
  int nop;
  nop = parameter->nop;
  int clusterhisto[nop];
  int greatestcluster ;
  greatestcluster = 0;

  this->buildClusters(criterium);

  for (int ti= 0;ti<nop;ti++)
  {
    clusterhisto[ti] = 0;
  }
  //Builds an histo of clustersizes
  for (int ti= 0;ti<nop;ti++)
  {
    if (this->molecules[ti].belongsto != nilvalue) clusterhisto[this->molecules[ti].belongsto] += 1;
  }
  //From the clustersize histo we can find the largest one.
  for (int ti= 0;ti<nop;ti++)
  {
    if (clusterhisto[ti] > greatestcluster)
    {
      greatestcluster = clusterhisto[ti];
      greatestbelongsto = ti;
    }
  }
  //return the size of the greatest cluster. To investigate the cluster use the variable
  //greatestbelongs to.
  return greatestcluster;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq 0xb4e8c0(%rdi), %rax
movl 0x3208(%rax), %r12d
movq %rsp, %r15
leaq 0xf(,%r12,4), %rax
andq $-0x10, %rax
subq %rax, %r15
movq %r15, %rsp
callq 0x59f6
xorl %eax, %eax
testl %r12d, %r12d
movl $0x0, %ecx
cmovgl %r12d, %ecx
cmpq %rax, %rcx
je 0x5b1a
andl $0x0, (%r15,%rax,4)
incq %rax
jmp 0x5b0b
movq 0xb4e8b8(%r14), %rax
imulq $0x870, %rcx, %rdx      # imm = 0x870
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x5b4d
movslq 0x860(%rax,%rsi), %rdi
cmpq $0x1fca055, %rdi        # imm = 0x1FCA055
je 0x5b44
incl (%r15,%rdi,4)
addq $0x870, %rsi            # imm = 0x870
jmp 0x5b2a
xorl %edx, %edx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x5b67
movl (%r15,%rdx,4), %esi
cmpl %eax, %esi
jle 0x5b62
movl %edx, (%rbx)
movl %esi, %eax
incq %rdx
jmp 0x5b51
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::makeperiodic(int)
void CMolecularSystem::makeperiodic(int ti)
{ 
  double boxx,boxy,boxz;
  boxx = this->parameter->boxx;
  boxy = this->parameter->boxy;
  boxz = this->parameter->boxz;
  
  if (this->molecules[ti].posx >=  boxx) {this->molecules[ti].posx -=boxx;}
  if (this->molecules[ti].posx <   0.0)  {this->molecules[ti].posx +=boxx;}
  if (this->molecules[ti].posy >=  boxy) {this->molecules[ti].posy -=boxy;}
  if (this->molecules[ti].posy <   0.0)  {this->molecules[ti].posy +=boxy;}
  if (this->molecules[ti].posz >=  boxz) {this->molecules[ti].posz -=boxz;}
  if (this->molecules[ti].posz <   0.0)  {this->molecules[ti].posz +=boxz;}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xb4e8b8(%rdi), %rax
movq 0xb4e8c0(%rdi), %rdx
movsd 0x3218(%rdx), %xmm2
movsd 0x3220(%rdx), %xmm1
movslq %esi, %rcx
imulq $0x870, %rcx, %rcx      # imm = 0x870
movsd 0x8(%rax,%rcx), %xmm4
ucomisd %xmm2, %xmm4
movsd 0x3228(%rdx), %xmm0
movapd %xmm4, %xmm5
subsd %xmm2, %xmm5
movapd %xmm2, %xmm3
cmplesd %xmm4, %xmm3
andpd %xmm3, %xmm5
andnpd %xmm4, %xmm3
orpd %xmm5, %xmm3
jae 0x5bdb
xorpd %xmm4, %xmm4
ucomisd %xmm3, %xmm4
jbe 0x5c04
leaq (%rax,%rcx), %rdx
addq $0x8, %rdx
addsd %xmm3, %xmm2
xorpd %xmm4, %xmm4
movapd %xmm3, %xmm5
cmpltsd %xmm4, %xmm5
andpd %xmm5, %xmm2
andnpd %xmm3, %xmm5
orpd %xmm2, %xmm5
movlpd %xmm5, (%rdx)
movsd 0x10(%rax,%rcx), %xmm3
ucomisd %xmm1, %xmm3
movapd %xmm3, %xmm4
subsd %xmm1, %xmm4
movapd %xmm1, %xmm2
cmplesd %xmm3, %xmm2
andpd %xmm2, %xmm4
andnpd %xmm3, %xmm2
orpd %xmm4, %xmm2
jae 0x5c37
xorpd %xmm3, %xmm3
ucomisd %xmm2, %xmm3
jbe 0x5c60
leaq (%rax,%rcx), %rdx
addq $0x10, %rdx
addsd %xmm2, %xmm1
xorpd %xmm3, %xmm3
movapd %xmm2, %xmm4
cmpltsd %xmm3, %xmm4
andpd %xmm4, %xmm1
andnpd %xmm2, %xmm4
orpd %xmm1, %xmm4
movlpd %xmm4, (%rdx)
movsd 0x18(%rax,%rcx), %xmm2
ucomisd %xmm0, %xmm2
movapd %xmm2, %xmm3
subsd %xmm0, %xmm3
movapd %xmm0, %xmm1
cmplesd %xmm2, %xmm1
andpd %xmm1, %xmm3
andnpd %xmm2, %xmm1
orpd %xmm3, %xmm1
jae 0x5c93
xorpd %xmm2, %xmm2
ucomisd %xmm1, %xmm2
jbe 0x5cbb
addq %rcx, %rax
addq $0x18, %rax
addsd %xmm1, %xmm0
xorpd %xmm2, %xmm2
movapd %xmm1, %xmm3
cmpltsd %xmm2, %xmm3
andpd %xmm3, %xmm0
andnpd %xmm1, %xmm3
orpd %xmm0, %xmm3
movlpd %xmm3, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::get_distancePosition(int, double, double, double, double&, double&, double&)
void CMolecularSystem::get_distancePosition(int ti ,double posx, double posy,double posz ,double &diffx,double &diffy,double &diffz)
{
  diffx = posx - this->molecules[ti].posx;
  diffy = posy - this->molecules[ti].posy;
  diffz = 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 %esi, %rsi
imulq $0x870, %rsi, %rsi      # imm = 0x870
subsd 0x8(%rax,%rsi), %xmm0
movsd %xmm0, (%rdx)
subsd 0x10(%rax,%rsi), %xmm1
movsd %xmm1, (%rcx)
subsd 0x18(%rax,%rsi), %xmm2
movsd %xmm2, (%r8)
movsd (%rdx), %xmm0
movq 0xb4e8c0(%rdi), %rax
movsd 0x3218(%rax), %xmm1
movsd 0x130b(%rip), %xmm2     # 0x7018
mulsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x5d27
subsd %xmm1, %xmm0
movsd %xmm0, (%rdx)
movsd 0x3218(%rax), %xmm1
movsd 0x1309(%rip), %xmm2     # 0x7038
mulsd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
jbe 0x5d41
addsd %xmm1, %xmm0
movsd %xmm0, (%rdx)
movsd (%rcx), %xmm0
movsd 0x3220(%rax), %xmm1
movsd 0x12c3(%rip), %xmm2     # 0x7018
mulsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x5d6f
subsd %xmm1, %xmm0
movsd %xmm0, (%rcx)
movsd 0x3220(%rax), %xmm1
movsd 0x12c1(%rip), %xmm2     # 0x7038
mulsd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
jbe 0x5d89
addsd %xmm1, %xmm0
movsd %xmm0, (%rcx)
movsd (%r8), %xmm0
movsd 0x3228(%rax), %xmm1
movsd 0x127a(%rip), %xmm2     # 0x7018
mulsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x5db9
subsd %xmm1, %xmm0
movsd %xmm0, (%r8)
movsd 0x3228(%rax), %xmm1
movsd 0x1277(%rip), %xmm2     # 0x7038
mulsd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
jbe 0x5dd4
addsd %xmm1, %xmm0
movsd %xmm0, (%r8)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::outputSimpleVMDXYZFile(int)
void CMolecularSystem::outputSimpleVMDXYZFile(int number)
{
  char IntStr[80];
  ofstream of;
  sprintf( IntStr, "./output/simple.%d.xyz", number);
  of.open (IntStr, ofstream::out | ofstream::app);
  if (of.is_open())
  {
    of << this->parameter->nop << "\n\n"; 
    for (int ti=0;ti<this->parameter->nop;ti++)
    {
      of << "h " << this->molecules[ti].posx  << " " << this->molecules[ti].posy  << " " <<this->molecules[ti].posz  << "\n";
    }
  }
  of.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x228(%rbp), %r15
movq %r15, %rdi
callq 0x2310
leaq 0x155c(%rip), %rsi      # 0x7362
leaq -0x280(%rbp), %r12
movq %r12, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x2070
pushq $0x11
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2050
leaq -0x1b8(%rbp), %rdi
callq 0x20a0
testb %al, %al
je 0x5f14
movq 0xb4e8c0(%rbx), %rax
movl 0x3208(%rax), %esi
leaq -0x228(%rbp), %rdi
callq 0x2330
leaq 0x151d(%rip), %rsi      # 0x7379
movq %rax, %rdi
callq 0x21b0
xorl %r14d, %r14d
leaq 0x12f9(%rip), %r12      # 0x7167
leaq 0x1505(%rip), %r13      # 0x737a
xorl %r15d, %r15d
movq 0xb4e8c0(%rbx), %rax
movslq 0x3208(%rax), %rax
cmpq %rax, %r15
jge 0x5f14
leaq -0x228(%rbp), %rdi
leaq 0x14df(%rip), %rsi      # 0x737c
callq 0x21b0
movq 0xb4e8b8(%rbx), %rcx
movsd 0x8(%rcx,%r14), %xmm0
movq %rax, %rdi
callq 0x22e0
movq %rax, %rdi
movq %r12, %rsi
callq 0x21b0
movq 0xb4e8b8(%rbx), %rcx
movsd 0x10(%rcx,%r14), %xmm0
movq %rax, %rdi
callq 0x22e0
movq %rax, %rdi
movq %r12, %rsi
callq 0x21b0
movq 0xb4e8b8(%rbx), %rcx
movsd 0x18(%rcx,%r14), %xmm0
movq %rax, %rdi
callq 0x22e0
movq %rax, %rdi
movq %r13, %rsi
callq 0x21b0
incq %r15
addq $0x870, %r14            # imm = 0x870
jmp 0x5e78
leaq -0x228(%rbp), %rdi
callq 0x2280
leaq -0x228(%rbp), %rdi
callq 0x22a0
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5f40
movq %rax, %rbx
leaq -0x228(%rbp), %rdi
callq 0x22a0
movq %rbx, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/molecular_system.cpp
// Function: CMolecularSystem::outputSimpleResults(int)
void CMolecularSystem::outputSimpleResults(int number)
{
  char IntStr[80];
  ofstream of;
  sprintf( IntStr, "./output/result.%d.dat", number);
  of.open (IntStr, ofstream::out | ofstream::trunc);
  if (of.is_open())
  {
    for (int ti=0;ti<this->parameter->nop;ti++)
    {
      of << ti << " " << this->molecules[ti].posx  << " " << this->molecules[ti].posy  << " " <<this->molecules[ti].posz
               << " " << this->molecules[ti].AQ4  << " " << this->molecules[ti].AQ6
               << " " << this->molecules[ti].Q4  << " " << this->molecules[ti].Q6
               << " " << this->molecules[ti].n_neighbors << "\n";
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x280(%rbp), %r15
movq %r15, %rdi
callq 0x2310
leaq 0x13f7(%rip), %rsi      # 0x737f
leaq -0x80(%rbp), %r12
movq %r12, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x2070
pushq $0x30
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2050
leaq -0x210(%rbp), %rdi
callq 0x20a0
testb %al, %al
je 0x6124
xorl %r14d, %r14d
leaq 0x11a2(%rip), %r15      # 0x7167
leaq 0x13ae(%rip), %r12      # 0x737a
xorl %r13d, %r13d
movq 0xb4e8c0(%rbx), %rax
movslq 0x3208(%rax), %rax
cmpq %rax, %r13
jge 0x6124
leaq -0x280(%rbp), %rdi
movl %r13d, %esi
callq 0x2330
movq %rax, %rdi
movq %r15, %rsi
callq 0x21b0
movq 0xb4e8b8(%rbx), %rcx
movsd 0x8(%rcx,%r14), %xmm0
movq %rax, %rdi
callq 0x22e0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21b0
movq 0xb4e8b8(%rbx), %rcx
movsd 0x10(%rcx,%r14), %xmm0
movq %rax, %rdi
callq 0x22e0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21b0
movq 0xb4e8b8(%rbx), %rcx
movsd 0x18(%rcx,%r14), %xmm0
movq %rax, %rdi
callq 0x22e0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21b0
movq 0xb4e8b8(%rbx), %rcx
movsd 0x840(%rcx,%r14), %xmm0
movq %rax, %rdi
callq 0x22e0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21b0
movq 0xb4e8b8(%rbx), %rcx
movsd 0x838(%rcx,%r14), %xmm0
movq %rax, %rdi
callq 0x22e0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21b0
movq 0xb4e8b8(%rbx), %rcx
movsd 0x820(%rcx,%r14), %xmm0
movq %rax, %rdi
callq 0x22e0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21b0
movq 0xb4e8b8(%rbx), %rcx
movsd 0x818(%rcx,%r14), %xmm0
movq %rax, %rdi
callq 0x22e0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21b0
movq 0xb4e8b8(%rbx), %rcx
movl 0x550(%rcx,%r14), %esi
movq %rax, %rdi
callq 0x2330
movq %rax, %rdi
movq %r12, %rsi
callq 0x21b0
incq %r13
addq $0x870, %r14            # imm = 0x870
jmp 0x5fcf
leaq -0x280(%rbp), %rdi
callq 0x22a0
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6144
movq %rax, %rbx
leaq -0x280(%rbp), %rdi
callq 0x22a0
movq %rbx, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/parameter.cpp
// Function: CParameter::CParameter()
CParameter::CParameter()
{
  this->nop = -1;
  this->boxx = -1.0;
  this->boxy = -1.0;
  this->boxz = -1.0;
  this->xyzFile = "notset";
  this->baseunit = -1;
  this->noc = -1;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3474(%rip), %rax      # 0x9d88
movq %rax, (%rdi)
leaq 0x38(%rdi), %rax
movl $0x3200, %ecx           # imm = 0x3200
xorl %edx, %edx
leaq -0x20(%rax), %rsi
movq %rsi, -0x30(%rax)
andq $0x0, -0x28(%rax)
movb %dl, -0x20(%rax)
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %dl, (%rax)
addq $0x40, %rax
addq $-0x40, %rcx
jne 0x6922
leaq 0x3230(%rbx), %r14
leaq 0x3240(%rbx), %rax
movq %rax, 0x3230(%rbx)
andq $0x0, 0x3238(%rbx)
movb $0x0, 0x3240(%rbx)
orl $-0x1, 0x3208(%rbx)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x3218(%rbx)
movq %rax, 0x3220(%rbx)
movq %rax, 0x3228(%rbx)
leaq 0x746(%rip), %rsi       # 0x70de
movq %r14, %rdi
callq 0x2380
orl $-0x1, 0x320c(%rbx)
orl $-0x1, 0x3214(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x23a8
movl $0x31c8, %r14d          # imm = 0x31C8
leaq (%rbx,%r14), %rdi
callq 0x6e60
addq $-0x40, %r14
cmpq $-0x38, %r14
jne 0x69ca
movq %r15, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O2/WolfgangLechner[P]StructureAnalysis/parameter.cpp
// Function: CParameter::checkParameter()
void CParameter::checkParameter()
{
  double minnd;
  minnd = double(this->boxx)/double(this->baseunit)*sqrt(2.0)/2.0;
  if (this->neighbordistance < minnd)
  {
    cerr << "The minimal neighbor distance is " << minnd << "in parameter.txt it is set to " << this->neighbordistance << "\n";
    cerr << "I now set the neighbordistance to reach the first shell " <<"\n";
    this->neighbordistance = minnd + 0.2;
  }


}

// Assembly:
movsd 0x3218(%rdi), %xmm1
cvtsi2sdl 0x320c(%rdi), %xmm0
divsd %xmm0, %xmm1
mulsd 0x276(%rip), %xmm1      # 0x7020
mulsd 0x266(%rip), %xmm1      # 0x7018
ucomisd 0x3250(%rdi), %xmm1
jbe 0x6e5f
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x321c(%rip), %r14      # 0x9ff0
leaq 0x808(%rip), %rsi       # 0x75e3
movq %r14, %rdi
movsd %xmm1, -0x20(%rbp)
callq 0x21b0
movq %rax, %rdi
movsd -0x20(%rbp), %xmm0
callq 0x22e0
leaq 0x809(%rip), %rsi       # 0x7605
movq %rax, %rdi
callq 0x21b0
movsd 0x3250(%rbx), %xmm0
movq %rax, %rdi
callq 0x22e0
leaq 0x55f(%rip), %r15       # 0x737a
movq %rax, %rdi
movq %r15, %rsi
callq 0x21b0
leaq 0x7f7(%rip), %rsi       # 0x7624
movq %r14, %rdi
callq 0x21b0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21b0
movsd -0x20(%rbp), %xmm0
addsd 0x6f3(%rip), %xmm0      # 0x7540
movsd %xmm0, 0x3250(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Character.cpp
// Function: Character::validatePositiveInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Character::validatePositiveInt(std::string value_name)
{
    int value = 0;
    while (value < 1)
    {
        std::cout << "Enter " << value_name << " (integer) : ";
        std::cin >> value;

        if (value < 1)
            std::cout << "Can't be a negative value. Try again\n";
    }
    return value; 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x4(%rsp), %rbx
andl $0x0, (%rbx)
movq %rsi, %r14
xorl %eax, %eax
movq 0x574d(%rip), %r15      # 0x7fc8
leaq 0x27f5(%rip), %r12      # 0x5077
leaq 0x27f5(%rip), %r13      # 0x507e
movq 0x5748(%rip), %rbp      # 0x7fd8
testl %eax, %eax
jg 0x28dd
movq %r15, %rdi
movq %r12, %rsi
callq 0x2130
movq %rax, %rdi
movq %r14, %rsi
callq 0x2100
movq %rax, %rdi
movq %r13, %rsi
callq 0x2130
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x20b0
movl 0x4(%rsp), %eax
testl %eax, %eax
jg 0x2890
movq %r15, %rdi
leaq 0x27ba(%rip), %rsi      # 0x508c
callq 0x2130
movl 0x4(%rsp), %eax
jmp 0x2890
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Character.cpp
// Function: Character::validatePercent(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
float Character::validatePercent(std::string value_name)
{
    float value = -1;
    while (value < 0 || value > 1)
    {
        std::cout << "Enter " << value_name << " (float) : ";
        std::cin >> value;

        if (value < 0 || value > 1)
            std::cout << "Can't only be decimal number between 0 and 1. Try again\n";
    }
    return value; 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x4(%rsp), %r14
movl $0xbf800000, (%r14)     # imm = 0xBF800000
movss 0x26f6(%rip), %xmm0     # 0x5004
movq 0x56b3(%rip), %r15      # 0x7fc8
leaq 0x275b(%rip), %r12      # 0x5077
leaq 0x278f(%rip), %r13      # 0x50b2
movq 0x56ae(%rip), %rbp      # 0x7fd8
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
ja 0x293b
ucomiss 0x26cf(%rip), %xmm0     # 0x5008
jbe 0x2995
movq %r15, %rdi
movq %r12, %rsi
callq 0x2130
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2100
movq %rax, %rdi
movq %r13, %rsi
callq 0x2130
movq %rbp, %rdi
movq %r14, %rsi
callq 0x2250
movss 0x4(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
ja 0x297e
ucomiss 0x268c(%rip), %xmm0     # 0x5008
jbe 0x292a
movq %r15, %rdi
leaq 0x2736(%rip), %rsi      # 0x50be
callq 0x2130
movss 0x4(%rsp), %xmm0
jmp 0x292a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Character.cpp
// Function: Character::print(int)
void Character::print(int line)
{
    switch (line)
    {
        case 1:
            std::cout << "HP: " << std::setw(4) << current_HP << " / " << std::setw(4) << HP;
            break;
        case 2:
            std::cout << "MP: " << std::setw(4) << current_MP << " / " << std::setw(4) << MP;
            break;
        case 3:
            std::cout << "Status: " << std::setw(7) << status;
            break;
        default:
            // Don't do anything
            break;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x3, %esi
je 0x2b08
cmpl $0x2, %esi
je 0x2ab9
cmpl $0x1, %esi
jne 0x2b40
movq 0x5553(%rip), %rdi      # 0x7fc8
leaq 0x267b(%rip), %rsi      # 0x50f7
callq 0x2130
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
pushq $0x4
popq %r14
movq %r14, 0x10(%rax,%rcx)
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x2210
leaq 0x2659(%rip), %rsi      # 0x50fc
movq %rax, %rdi
callq 0x2130
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r14, 0x10(%rax,%rcx)
jmp 0x2b2f
movq 0x5508(%rip), %rdi      # 0x7fc8
leaq 0x2639(%rip), %rsi      # 0x5100
callq 0x2130
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
pushq $0x4
popq %r14
movq %r14, 0x10(%rax,%rcx)
movl 0xc(%rbx), %esi
movq %rax, %rdi
callq 0x2210
leaq 0x260e(%rip), %rsi      # 0x50fc
movq %rax, %rdi
callq 0x2130
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r14, 0x10(%rax,%rcx)
addq $0x8, %rbx
jmp 0x2b2f
movq 0x54b9(%rip), %rdi      # 0x7fc8
leaq 0x25ef(%rip), %rsi      # 0x5105
callq 0x2130
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x7, 0x10(%rax,%rcx)
addq $0x48, %rbx
movl (%rbx), %esi
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2210
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Character.cpp
// Function: Character::receiveDamage(int)
void Character::receiveDamage(int base_damage)
{
    // Do not allow negative damage. The std::max function will return
    //  the highest value from 0 or the damage minus the defense
    current_HP -= std::max( (base_damage - defense), 0 );
    if (current_HP <= 0)
    {
        current_HP = 0;
        status = DEAD;
    }
}

// Assembly:
subl 0x20(%rdi), %esi
xorl %eax, %eax
testl %esi, %esi
cmovgl %esi, %eax
subl %eax, 0x4(%rdi)
jle 0x2b6a
retq
andl $0x0, 0x4(%rdi)
movl $0x1, 0x48(%rdi)
retq