LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: evec_c(Matrix&)
Vector evec_c(Matrix& A){
	assert(nrows(A) == ncols(A));
	// INITIALISATION
	Vector x(nrows(A));
  Vector xold(nrows(A));
  xold  = randv(xold);
  x  = randv(x);
  float eps = 1.0;
  float lam;
  while (eps>1e-15){
    x = A*x;
    lam = (xold*x)/xold.norm();
    x = x/x.norm();
    eps=(x-xold).norm();
    xold=x;
  }
  signed int s = (lam>0) - (lam<0);
  x= x*s;
  return x;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movl 0x8(%rsi), %esi
cmpl 0xc(%r14), %esi
jne 0x48ea
movq %rdi, %rbx
callq 0x8268
movl 0x8(%r14), %esi
leaq 0x18(%rsp), %rdi
callq 0x8268
movq %rsp, %rdi
leaq 0x18(%rsp), %rsi
callq 0x8f05
leaq 0x18(%rsp), %rdi
movq %rsp, %rsi
callq 0x89dc
movq %rsp, %rdi
callq 0x8310
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x8f05
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x89dc
movq %rsp, %r15
movq %r15, %rdi
callq 0x8310
leaq 0x18(%rsp), %r12
leaq 0x10(%rsp), %r13
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3941
movq %rbx, %rdi
movq %r15, %rsi
callq 0x89dc
movq %r15, %rdi
callq 0x8310
movq %r12, %rdi
movq %rbx, %rsi
callq 0x8673
movsd %xmm0, 0x30(%rsp)
movq %r12, %rdi
movl $0x2, %esi
callq 0x8dfc
movsd %xmm0, 0x28(%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8dfc
movsd %xmm0, 0x10(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x8804
movq %rbx, %rdi
movq %r15, %rsi
callq 0x89dc
movq %r15, %rdi
callq 0x8310
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x84c8
movq %r15, %rdi
movl $0x2, %esi
callq 0x8dfc
movsd %xmm0, 0x38(%rsp)
movq %r15, %rdi
callq 0x8310
movq %r12, %rdi
movq %rbx, %rsi
callq 0x89dc
xorps %xmm0, %xmm0
cvtsd2ss 0x38(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd 0x5812(%rip), %xmm0     # 0xa088
ja 0x47b4
movsd 0x30(%rsp), %xmm0
divsd 0x28(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
xorps %xmm1, %xmm1
xorl %eax, %eax
ucomiss %xmm1, %xmm0
seta %al
xorl %ecx, %ecx
ucomiss %xmm0, %xmm1
seta %cl
subl %ecx, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
leaq 0x10(%rsp), %rdx
movsd %xmm0, (%rdx)
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x86f8
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x89dc
movq %rsp, %rdi
callq 0x8310
leaq 0x18(%rsp), %rdi
callq 0x8310
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x5a29(%rip), %rdi      # 0xa31a
leaq 0x5859(%rip), %rsi      # 0xa151
leaq 0x5a30(%rip), %rcx      # 0xa32f
movl $0x1aa, %edx            # imm = 0x1AA
callq 0x20b0
jmp 0x4922
jmp 0x4931
jmp 0x4922
jmp 0x4931
jmp 0x4922
jmp 0x4931
movq %rax, %r14
jmp 0x493e
jmp 0x4931
jmp 0x4922
jmp 0x4922
jmp 0x4931
movq %rax, %r14
movq %rsp, %rdi
callq 0x8310
jmp 0x4934
jmp 0x4931
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x8310
movq %rbx, %rdi
callq 0x8310
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Vector.cpp
// Function: Vector::Vector(int)
Vector::Vector(int sizeVal)
{
  mData=new double[sizeVal];
  mSize = sizeVal;
  for (int i=0; i<mSize; i++)
  {
     mData[i] = 0.0;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movslq %esi, %r15
leaq (,%r15,8), %rax
testl %r15d, %r15d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, (%r14)
movl %r15d, 0x8(%r14)
testl %r15d, %r15d
jle 0x82b1
movl %ebx, %edx
shlq $0x3, %rdx
movq %rax, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x20a0
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Vector.cpp
// Function: Vector::Vector(Vector const&)
Vector::Vector(const Vector& v1)
{
  mSize = v1.mSize;
  mData=new double[mSize];
  for (int i=0; i<v1.mSize; i++)
  {
    mData[i] = v1.mData[i];
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x8(%rsi), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movl %eax, 0x8(%rdi)
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x2030
movq %rax, (%r14)
movslq 0x8(%rbx), %rcx
testq %rcx, %rcx
jle 0x8307
movq (%rbx), %rdx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x82f5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Vector.cpp
// Function: operator*(Vector const&, Vector const&)
double operator*(const Vector& v1, const Vector& v2)
{
  int n;
  double dp;


//  check vectors are of the same length
//  if not assume missing entries are 0 
  if (v1.mSize > v2.mSize)
    {
      n = v2.mSize;
      std::cerr<<"scalar product - vectors different lengths\n";
      std::cerr<<"extra entries of shorter vector assumed to be 0.0\n";
    }
  else if (v1.mSize < v2.mSize)
    {
      n = v1.mSize;
      std::cerr<<"scalar product - vectors different lengths\n";
      std::cerr<<"extra entries of shorter vector assumed to be 0.0\n";
    }
  else
    {
      n = v1.mSize;
    }



//  compute scalar product

  dp = 0.0;

  for (int i=0; i<n; i++)
    {
      dp += v1.mData[i] * v2.mData[i];
    }

  return dp;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %edx
movl 0x8(%rsi), %ebp
cmpl %ebp, %edx
jg 0x868e
movl %edx, %ebp
jge 0x86bf
movq 0x595b(%rip), %r15      # 0xdff0
leaq 0x1efc(%rip), %rsi      # 0xa598
movl $0x2b, %edx
movq %r15, %rdi
callq 0x2160
leaq 0x1e88(%rip), %rsi      # 0xa538
movl $0x32, %edx
movq %r15, %rdi
callq 0x2160
movl %ebp, %edx
testl %edx, %edx
jle 0x86e9
movq (%r14), %rax
movq (%rbx), %rcx
movl %edx, %edx
xorpd %xmm0, %xmm0
xorl %esi, %esi
movsd (%rax,%rsi,8), %xmm1
mulsd (%rcx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rdx
jne 0x86d1
jmp 0x86ed
xorpd %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Vector.cpp
// Function: operator*(Vector const&, double const&)
Vector operator*(const Vector& v, const double& a)
{

//  create a vector of the same length as v with entries equal to a*v

  Vector w(v.mSize);

  for (int i=0; i<v.mSize; i++)
    {
      w.mData[i] = a * v.mData[i];
    }

  return w;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movslq 0x8(%rsi), %rbp
leaq (,%rbp,8), %r13
testq %rbp, %rbp
movq $-0x1, %rdi
cmovnsq %r13, %rdi
callq 0x2030
movq %rax, %r14
movq %rax, (%rbx)
movl %ebp, 0x8(%rbx)
testq %rbp, %rbp
jle 0x8746
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x20a0
testl %ebp, %ebp
jle 0x876c
movsd (%r12), %xmm0
movq (%r15), %rax
xorl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%r14,%rcx,8)
incq %rcx
cmpq %rcx, %rbp
jne 0x8755
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Vector.cpp
// Function: operator*(double const&, Vector const&)
Vector operator*(const double& a, const Vector& v)
{

//  create a vector of the same length as v with entries equal to a*v

  Vector w(v.mSize);

  for (int i=0; i<v.mSize; i++)
    {
      w.mData[i] = a * v.mData[i];
    }

  return w;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movslq 0x8(%rdx), %rbp
leaq (,%rbp,8), %r13
testq %rbp, %rbp
movq $-0x1, %rdi
cmovnsq %r13, %rdi
callq 0x2030
movq %rax, %r14
movq %rax, (%rbx)
movl %ebp, 0x8(%rbx)
testq %rbp, %rbp
jle 0x87cc
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x20a0
testl %ebp, %ebp
jle 0x87f2
movsd (%r12), %xmm0
movq (%r15), %rax
xorl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%r14,%rcx,8)
incq %rcx
cmpq %rcx, %rbp
jne 0x87db
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Vector.cpp
// Function: operator/(Vector const&, double const&)
Vector operator/(const Vector& v, const double& a)
{
  if (a == 0.0)
  {
     throw Exception("div 0", "Attempt to divide by zero");
  }
//  create a vector of the same length as v with entries equal to v/a

  Vector w(v.mSize);

  for (int i=0; i<v.mSize; i++)
    {
      w.mData[i] = v.mData[i] / a;
    }

  return w;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movsd (%rdx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x8822
jnp 0x889c
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movslq 0x8(%rsi), %rbp
leaq (,%rbp,8), %r13
testq %rbp, %rbp
movq $-0x1, %rdi
cmovnsq %r13, %rdi
callq 0x2030
movq %rax, %r12
movq %rax, (%rbx)
movl %ebp, 0x8(%rbx)
testq %rbp, %rbp
jle 0x8865
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x20a0
testl %ebp, %ebp
jle 0x888a
movq (%r15), %rax
movsd (%r14), %xmm0
xorl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%r12,%rcx,8)
incq %rcx
cmpq %rcx, %rbp
jne 0x8873
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x40, %edi
callq 0x2080
movq %rax, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1d0b(%rip), %rsi      # 0xa5c4
leaq 0x1d09(%rip), %rdx      # 0xa5c9
leaq 0x28(%rsp), %rdi
callq 0x81d6
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1cef(%rip), %rsi      # 0xa5ca
leaq 0x1d01(%rip), %rdx      # 0xa5e3
leaq 0x8(%rsp), %rdi
callq 0x81d6
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x8f64
xorl %ebp, %ebp
leaq 0x548e(%rip), %rsi      # 0xdd98
leaq -0x765(%rip), %rdx      # 0x81ac
movq %rbx, %rdi
callq 0x21c0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x8933
callq 0x2140
jmp 0x8933
movq %rax, %r14
movb $0x1, %bpl
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x894a
callq 0x2140
jmp 0x894a
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x8957
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Vector.cpp
// Function: operator-(Vector const&)
Vector operator-(const Vector& v)
{

//  create a vector w with entries equal to -v

  Vector w(v.mSize);

  for (int i=0; i<v.mSize; i++)
    {
      w.mData[i] = -v.mData[i];
    }

  return w;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movslq 0x8(%rsi), %r13
leaq (,%r13,8), %r12
testq %r13, %r13
movq $-0x1, %rdi
cmovnsq %r12, %rdi
callq 0x2030
movq %rax, %r14
movq %rax, (%rbx)
movl %r13d, 0x8(%rbx)
testq %r13, %r13
jle 0x89a9
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x20a0
testl %r13d, %r13d
jle 0x89cf
movq (%r15), %rax
xorl %ecx, %ecx
movaps 0x16a6(%rip), %xmm0     # 0xa060
movsd (%rax,%rcx,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%r14,%rcx,8)
incq %rcx
cmpq %rcx, %r13
jne 0x89ba
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Vector.cpp
// Function: Vector::operator=(Vector const&)
Vector& Vector::operator=(const Vector& v)
{

//  check both vectors have same length
//  if rhs vector is too short, assume missing entries are 0
//  if rhs vector is too long then throw

  if (v.mSize > mSize)
    {
      throw Exception("length mismatch",
		  "vector assignment operator - vectors have different lengths");
    }
  else if (v.mSize < mSize)
    {
      for (int i=0; i<v.mSize; i++)
	{
	  mData[i] = v.mData[i];
	}
      for (int i=v.mSize; i<mSize; i++)
	{
	  mData[i] = 0.0;
	}
      std::cerr << "vector assignment operator - copied vector was too short";
      std::cerr << " and has been extended with zeroes\n";
    }
  else
    {
      for (int i=0; i<mSize; i++)
	{
	  mData[i] = v.mData[i];
	}
    }

  return *this;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movslq 0x8(%rsi), %rcx
movl 0x8(%rdi), %eax
cmpl %eax, %ecx
jg 0x8a9c
movq %rdi, %rbx
cmpl %eax, %ecx
jge 0x8a6e
testl %ecx, %ecx
jle 0x8a1c
movq (%rsi), %rdx
movq (%rbx), %rsi
xorl %edi, %edi
movsd (%rdx,%rdi,8), %xmm0
movsd %xmm0, (%rsi,%rdi,8)
incq %rdi
cmpq %rdi, %rcx
jne 0x8a0a
cmpl %eax, %ecx
jge 0x8a3d
movq %rcx, %rdi
shlq $0x3, %rdi
addq (%rbx), %rdi
notl %ecx
addl %eax, %ecx
leaq 0x8(,%rcx,8), %rdx
xorl %esi, %esi
callq 0x20a0
movq 0x55ac(%rip), %r14      # 0xdff0
leaq 0x1bd5(%rip), %rsi      # 0xa620
movl $0x38, %edx
movq %r14, %rdi
callq 0x2160
leaq 0x1bfa(%rip), %rsi      # 0xa659
movl $0x23, %edx
movq %r14, %rdi
callq 0x2160
jmp 0x8a8c
testl %eax, %eax
jle 0x8a8c
movq (%rsi), %rcx
movq (%rbx), %rdx
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x8a7a
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x40, %edi
callq 0x2080
movq %rax, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1622(%rip), %rsi      # 0xa0db
leaq 0x162a(%rip), %rdx      # 0xa0ea
leaq 0x20(%rsp), %rdi
callq 0x81d6
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1b09(%rip), %rsi      # 0xa5e4
leaq 0x1b3d(%rip), %rdx      # 0xa61f
movq %rsp, %rdi
callq 0x81d6
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x8f64
xorl %ebp, %ebp
leaq 0x5292(%rip), %rsi      # 0xdd98
leaq -0x961(%rip), %rdx      # 0x81ac
movq %rbx, %rdi
callq 0x21c0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x8b2e
callq 0x2140
jmp 0x8b2e
movq %rax, %r14
movb $0x1, %bpl
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x8b45
callq 0x2140
jmp 0x8b45
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x8b52
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Vector.cpp
// Function: Vector::operator()(int)
double& Vector::operator()(int i)
{

  if (i < 1)
    {
      throw Exception("out of range",
		  "accessing vector through () - index too small");
    }
  else if (i > mSize)
    {
      throw Exception("length mismatch",
		  "accessing vector through () - index too high");
    }


  return mData[i-1];

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
testl %esi, %esi
jle 0x8b93
cmpl %esi, 0x8(%rdi)
jl 0x8c12
movq (%rdi), %rax
movl %esi, %ecx
leaq (%rax,%rcx,8), %rax
addq $-0x8, %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x40, %edi
callq 0x2080
movq %rax, %rbx
leaq 0x70(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x14f0(%rip), %rsi      # 0xa0a0
leaq 0x14f5(%rip), %rdx      # 0xa0ac
leaq 0x60(%rsp), %rdi
callq 0x81d6
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x14db(%rip), %rsi      # 0xa0ad
leaq 0x1501(%rip), %rdx      # 0xa0da
leaq 0x40(%rsp), %rdi
callq 0x81d6
movb $0x1, %bpl
leaq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x8f64
xorl %ebp, %ebp
leaq 0x5197(%rip), %rsi      # 0xdd98
leaq -0xa5c(%rip), %rdx      # 0x81ac
movq %rbx, %rdi
callq 0x21c0
jmp 0x8c8b
movl $0x40, %edi
callq 0x2080
movq %rax, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x14ac(%rip), %rsi      # 0xa0db
leaq 0x14b4(%rip), %rdx      # 0xa0ea
leaq 0x20(%rsp), %rdi
callq 0x81d6
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x149a(%rip), %rsi      # 0xa0eb
leaq 0x14bf(%rip), %rdx      # 0xa117
movq %rsp, %rdi
callq 0x81d6
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x8f64
xorl %ebp, %ebp
leaq 0x511c(%rip), %rsi      # 0xdd98
leaq -0xad7(%rip), %rdx      # 0x81ac
movq %rbx, %rdi
callq 0x21c0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x8ca4
callq 0x2140
jmp 0x8ca4
movq %rax, %r14
movb $0x1, %bpl
movq 0x20(%rsp), %rdi
jmp 0x8cca
movq %rax, %r14
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0x8cc5
callq 0x2140
jmp 0x8cc5
movq %rax, %r14
movb $0x1, %bpl
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x8cde
callq 0x2140
jmp 0x8cde
jmp 0x8cd8
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x8ceb
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Vector.cpp
// Function: operator<<(std::ostream&, Vector const&)
std::ostream& operator<<(std::ostream& output, const Vector& v) {
  output << "(";
  for (int i=0; i<v.mSize; i++)
    { 
      output <<  v.mData[i];
      if (i != v.mSize-1)
	output  << ", ";
      else
	output  << ")";
    }
  return output;  // for multiple << operators.
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1985(%rip), %rsi      # 0xa68e
movl $0x1, %edx
callq 0x2160
cmpl $0x0, 0x8(%r14)
jle 0x8d70
xorl %r13d, %r13d
leaq 0x155e(%rip), %r15      # 0xa282
leaq 0x1952(%rip), %r12      # 0xa67d
movq (%r14), %rax
movsd (%rax,%r13,8), %xmm0
movq %rbx, %rdi
callq 0x21a0
movl 0x8(%r14), %eax
decl %eax
cmpq %rax, %r13
jne 0x8d54
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
jmp 0x8d5f
movl $0x2, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2160
incq %r13
movslq 0x8(%r14), %rax
cmpq %rax, %r13
jl 0x8d2b
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Vector.cpp
// Function: norm(Vector&, int)
double norm(Vector& v, int p)
{
  double temp, norm_val;

  norm_val = 0.0;
  for (int i=1; i<=length(v); i++)
    {
      temp = fabs(v(i));
      norm_val += pow(temp, p);
    }

  return pow(norm_val, 1.0/((double) (p)));
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
cmpl $0x0, 0x8(%rdi)
cvtsi2sd %esi, %xmm0
movsd %xmm0, 0x8(%rsp)
jle 0x8dd6
movq %rdi, %rbx
xorpd %xmm2, %xmm2
xorl %ebp, %ebp
movsd %xmm2, 0x10(%rsp)
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8b5a
movsd (%rax), %xmm0
andpd 0x1746(%rip), %xmm0     # 0xa500
movsd 0x8(%rsp), %xmm1
callq 0x21e0
movsd 0x10(%rsp), %xmm2
addsd %xmm0, %xmm2
cmpl 0x8(%rbx), %ebp
jl 0x8d9c
jmp 0x8dda
xorpd %xmm2, %xmm2
movsd 0x1236(%rip), %xmm1     # 0xa018
divsd 0x8(%rsp), %xmm1
movapd %xmm2, %xmm0
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Vector.cpp
// Function: Vector::norm(int) const
double Vector::norm(int p) const
{
  double temp, norm_val;

  norm_val = 0.0;
  for (int i=0; i<mSize; i++)
    {
      temp = fabs(mData[i]);
      norm_val += pow(temp, p);
    }

  return pow(norm_val, 1.0/((double) (p)));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
cmpl $0x0, 0x8(%rdi)
cvtsi2sd %esi, %xmm2
jle 0x8e66
movq %rdi, %rbx
xorps %xmm0, %xmm0
xorl %r14d, %r14d
movsd %xmm2, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rax
movsd (%rax,%r14,8), %xmm0
andpd 0x16cd(%rip), %xmm0     # 0xa500
movapd %xmm2, %xmm1
callq 0x21e0
movsd 0x10(%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
incq %r14
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jl 0x8e1c
jmp 0x8e69
xorps %xmm0, %xmm0
movsd 0x11a7(%rip), %xmm1     # 0xa018
divsd %xmm2, %xmm1
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Vector.cpp
// Function: ones(int)
Vector ones(const int a)
{
	Vector b(a);
	for (int i=1; i<=a; i++){
		b.set_val(i,1);
	}
  return b;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %r12
leaq (,%r12,8), %rax
testl %r12d, %r12d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, %r14
movq %rax, (%rbx)
movl %r12d, 0x8(%rbx)
movl %ebp, %r15d
testl %r12d, %r12d
jle 0x8ed0
leaq (,%r15,8), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x20a0
testl %ebp, %ebp
jle 0x8eec
xorl %eax, %eax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%r14,%rax,8)
incq %rax
cmpq %rax, %r15
jne 0x8ee0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Vector.cpp
// Function: randv(Vector&)
Vector randv(Vector& v){
	int m = length(v);
	//srand( (unsigned)time( NULL ) );
	for (int i=1; i<=m ; i++){
			v.set_val(i,(float)rand()/RAND_MAX);
	}
	return v;


}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %r15d
testl %r15d, %r15d
jle 0x8f48
xorl %r12d, %r12d
callq 0x2060
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss 0x113d(%rip), %xmm0     # 0xa070
cvtss2sd %xmm0, %xmm0
movq (%r14), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x8f1f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x82b8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]lj_simd/./conf.hpp
// Function: measure(void (*)(), char const*, int)
void
measure(void(*pfunc)(), const char *name, int particle_number) {
  const auto s = std::chrono::system_clock::now();
  const int LOOP = 100;
  for (int i = 0; i < LOOP; i++) {
    sum++; // ループ交換阻害
    pfunc();
  }
  const auto e = std::chrono::system_clock::now();
  const auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(e - s).count();
  fprintf(stderr, "N=%d, %s %lld [ms]\n", particle_number, name, elapsed);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x64
popq %r12
callq 0x2050
movq %rax, %r14
incl 0x4f82(%rip)            # 0x7184
callq *%r15
decl %r12d
jne 0x21fc
callq 0x2050
subq %r14, %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movq 0x4dad(%rip), %rcx      # 0x6fd0
movq (%rcx), %rdi
leaq 0x2eff(%rip), %rsi      # 0x512c
movl %ebp, %edx
movq %rbx, %rcx
movq %rax, %r8
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2160
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]lj_simd/./conf.hpp
// Function: puts(int, int, int, int, int, int, int, int)
void
puts(int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8) {
  printf("%04d ", i1);
  printf("%04d ", i2);
  printf("%04d ", i3);
  printf("%04d ", i4);
  printf("%04d ", i5);
  printf("%04d ", i6);
  printf("%04d ", i7);
  printf("%04d\n", i8);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, (%rsp)
movl %r8d, %r12d
movl %ecx, %r13d
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %esi
movl 0x48(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x40(%rsp), %r14d
leaq 0x2c2d(%rip), %r15      # 0x5119
movq %r15, %rdi
xorl %eax, %eax
callq 0x2040
movq %r15, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x2040
movq %r15, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x2040
movq %r15, %rdi
movl %r13d, %esi
xorl %eax, %eax
callq 0x2040
movq %r15, %rdi
movl %r12d, %esi
xorl %eax, %eax
callq 0x2040
movq %r15, %rdi
movl (%rsp), %esi
xorl %eax, %eax
callq 0x2040
movq %r15, %rdi
movl %r14d, %esi
xorl %eax, %eax
callq 0x2040
leaq 0x2bd6(%rip), %rdi      # 0x511f
movl 0x4(%rsp), %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2040
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]lj_simd/./conf.hpp
// Function: puts(long long vector[4])
void
puts(__m256i vi) {
  int *v = (int*)(&vi);
  for (int i = 0; i < 8; i++) {
    printf("%04d ", v[i]);
  }
  printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
andq $-0x20, %rsp
subq $0x20, %rsp
vmovaps %ymm0, (%rsp)
leaq 0x2b9c(%rip), %rbx      # 0x5119
xorl %r14d, %r14d
movl (%rsp,%r14,4), %esi
movq %rbx, %rdi
xorl %eax, %eax
vzeroupper
callq 0x2040
incq %r14
cmpq $0x8, %r14
jne 0x2580
movl $0xa, %edi
callq 0x2150
leaq -0x10(%rbp), %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]lj_simd/./conf.hpp
// Function: puts(double, double, double, double, double, double, double, double)
void
puts(double d1, double d2, double d3, double d4, double d5, double d6, double d7, double d8) {
  printf("%.10f ", d1);
  printf("%.10f ", d2);
  printf("%.10f ", d3);
  printf("%.10f ", d4);
  printf("%.10f ", d5);
  printf("%.10f ", d6);
  printf("%.10f ", d7);
  printf("%.10f\n", d8);
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
vmovsd %xmm7, 0x38(%rsp)
vmovsd %xmm6, 0x30(%rsp)
vmovsd %xmm5, 0x28(%rsp)
vmovsd %xmm4, 0x20(%rsp)
vmovsd %xmm3, 0x18(%rsp)
vmovsd %xmm2, 0x10(%rsp)
vmovsd %xmm1, 0x8(%rsp)
leaq 0x2b42(%rip), %rbx      # 0x5125
movq %rbx, %rdi
movb $0x1, %al
callq 0x2040
movq %rbx, %rdi
vmovsd 0x8(%rsp), %xmm0
movb $0x1, %al
callq 0x2040
movq %rbx, %rdi
vmovsd 0x10(%rsp), %xmm0
movb $0x1, %al
callq 0x2040
movq %rbx, %rdi
vmovsd 0x18(%rsp), %xmm0
movb $0x1, %al
callq 0x2040
movq %rbx, %rdi
vmovsd 0x20(%rsp), %xmm0
movb $0x1, %al
callq 0x2040
movq %rbx, %rdi
vmovsd 0x28(%rsp), %xmm0
movb $0x1, %al
callq 0x2040
movq %rbx, %rdi
vmovsd 0x30(%rsp), %xmm0
movb $0x1, %al
callq 0x2040
leaq 0x2abe(%rip), %rdi      # 0x5112
vmovsd 0x38(%rsp), %xmm0
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
jmp 0x2040
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]lj_simd/./conf.hpp
// Function: puts4(double vector[4])
void
puts4(v4df x) {
  double *v = (double*)(&x);
  for (int i = 0; i < 4; i++) {
    printf("%.10f ", v[i]);
  }
  printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
andq $-0x20, %rsp
subq $0x20, %rsp
vmovaps %ymm0, (%rsp)
xorl %r14d, %r14d
leaq 0x2aa1(%rip), %rbx      # 0x5125
vmovsd (%rsp,%r14,8), %xmm0
movq %rbx, %rdi
movb $0x1, %al
vzeroupper
callq 0x2040
incq %r14
cmpq $0x4, %r14
jne 0x2684
movl $0xa, %edi
callq 0x2150
leaq -0x10(%rbp), %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]lj_simd/./conf.hpp
// Function: loadpair(int&, int*, int*, int*)
void
loadpair(int &number_of_pairs, int number_of_partners[N], int i_particles[MAX_PAIRS], int j_particles[MAX_PAIRS]) {
  std::ifstream ifs("pair.dat", std::ios::binary);
  ifs.read((char*)&number_of_pairs, sizeof(int));
  ifs.read((char*)number_of_partners, sizeof(int)*N);
  ifs.read((char*)i_particles, sizeof(int)*MAX_PAIRS);
  ifs.read((char*)j_particles, sizeof(int)*MAX_PAIRS);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x2a6a(%rip), %rsi      # 0x5140
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movl $0x4, %edx
callq 0x21c0
movl $0x4, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x2130
leaq 0x8(%rsp), %rdi
movl $0x186a00, %edx         # imm = 0x186A00
movq %r15, %rsi
callq 0x2130
leaq 0x8(%rsp), %rdi
movl $0x2dc6c00, %edx        # imm = 0x2DC6C00
movq %r14, %rsi
callq 0x2130
leaq 0x8(%rsp), %rdi
movl $0x2dc6c00, %edx        # imm = 0x2DC6C00
movq %rbx, %rsi
callq 0x2130
leaq 0x8(%rsp), %rdi
callq 0x2060
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]lj_simd/./conf.hpp
// Function: savepair(int, int*, int*, int*)
void
savepair(int number_of_pairs, int number_of_partners[N], int i_particles[MAX_PAIRS], int j_particles[MAX_PAIRS]) {
  std::ofstream ofs("pair.dat", std::ios::binary);
  ofs.write((char*)&number_of_pairs, sizeof(int));
  ofs.write((char*)number_of_partners, sizeof(int)*N);
  ofs.write((char*)i_particles, sizeof(int)*MAX_PAIRS);
  ofs.write((char*)j_particles, sizeof(int)*MAX_PAIRS);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0xc(%rsp), %r12
movl %edi, (%r12)
leaq 0x29b9(%rip), %rsi      # 0x5140
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movl $0x4, %edx
callq 0x2110
movl $0x4, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x2140
leaq 0x10(%rsp), %rdi
movl $0x186a00, %edx         # imm = 0x186A00
movq %r15, %rsi
callq 0x2140
leaq 0x10(%rsp), %rdi
movl $0x2dc6c00, %edx        # imm = 0x2DC6C00
movq %r14, %rsi
callq 0x2140
leaq 0x10(%rsp), %rdi
movl $0x2dc6c00, %edx        # imm = 0x2DC6C00
movq %rbx, %rsi
callq 0x2140
movq 0x47e2(%rip), %rax      # 0x6fc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x18(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x10(%rsp,%rcx)
callq 0x20d0
leaq 0x108(%rsp), %rdi
callq 0x2070
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]lj_simd/./conf.hpp
// Function: makepair(int, int&, int*, int*, int*, DataManager*)
void
makepair(int particle_number, int &number_of_pairs, int number_of_partners[N], int i_particles[MAX_PAIRS], int j_particles[MAX_PAIRS], DataManager *dm) {
  const double SL2 = SEARCH_LENGTH * SEARCH_LENGTH;
  for (int i = 0; i < particle_number; i++) {
    number_of_partners[i] = 0;
  }
  for (int i = 0; i < particle_number - 1; i++) {
    for (int j = i + 1; j < particle_number; j++) {
      const double r2 = dm->calc_distance(i, j);
      if (r2 < SL2) {
        register_pair(i, j, number_of_pairs, number_of_partners, i_particles, j_particles);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movl %edi, %ebp
testl %edi, %edi
jle 0x288e
movl %ebp, %edx
shlq $0x2, %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x2090
cmpl $0x2, %ebp
jl 0x2907
leal -0x2(%rbp), %eax
movl %eax, (%rsp)
xorl %eax, %eax
movl %eax, %r14d
leal 0x1(%r14), %r15d
movl %r15d, 0x4(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq *0x8(%rax)
vmovsd 0x274a(%rip), %xmm1     # 0x5008
vucomisd %xmm0, %xmm1
jbe 0x28f5
cmpl %r15d, %r14d
movl %r15d, %eax
cmovll %r14d, %eax
movl %r15d, %ecx
cmovgl %r14d, %ecx
movslq (%r13), %rdx
movq 0x8(%rsp), %rsi
movl %eax, (%rsi,%rdx,4)
movslq (%r13), %rdx
movq 0x10(%rsp), %rsi
movl %ecx, (%rsi,%rdx,4)
incl (%r12,%rax,4)
incl (%r13)
incl %r15d
cmpl %r15d, %ebp
jne 0x28a7
cmpl (%rsp), %r14d
movl 0x4(%rsp), %eax
jne 0x289b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]lj_simd/./conf.hpp
// Function: check_pairlist(int, int&, int*, int*, int*, DataManager*)
void
check_pairlist(int particle_number, int &number_of_pairs, int number_of_partners[N], int i_particles[MAX_PAIRS], int j_particles[MAX_PAIRS], DataManager *dm) {
  struct stat st;
  int ret = stat("pair.dat", &st);
  if (ret == 0) {
    std::cerr << "A pair-file is found. I use it." << std::endl;
    loadpair(number_of_pairs, number_of_partners, i_particles, j_particles);
  } else {
    std::cerr << "Make pairlist." << std::endl;
    makepair(particle_number, number_of_pairs, number_of_partners, i_particles, j_particles, dm);
    savepair(number_of_pairs, number_of_partners, i_particles, j_particles);
  }
  std::cerr << "Number of pairs: " << number_of_pairs << std::endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r9, %r13
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x2801(%rip), %rdi      # 0x5140
leaq 0x8(%rsp), %rsi
callq 0x20f0
testl %eax, %eax
je 0x29bd
movq %r13, (%rsp)
movq 0x4698(%rip), %r13      # 0x6ff0
leaq 0x280a(%rip), %rsi      # 0x5169
movl $0xe, %edx
movq %r13, %rdi
callq 0x2120
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2100
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movl %ebp, %edi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq (%rsp), %r9
callq 0x2857
movl (%rbx), %edi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x275e
jmp 0x2a11
movq 0x462c(%rip), %r13      # 0x6ff0
leaq 0x277e(%rip), %rsi      # 0x5149
movl $0x1f, %edx
movq %r13, %rdi
callq 0x2120
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2100
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x26b3
movq 0x45d8(%rip), %r14      # 0x6ff0
leaq 0x2759(%rip), %rsi      # 0x5178
movl $0x11, %edx
movq %r14, %rdi
callq 0x2120
movl (%rbx), %esi
movq %r14, %rdi
callq 0x2190
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]lj_simd/./conf.hpp
// Function: sortpair(int, int&, int*, int*, int*, int*, int*)
void
sortpair(const int pn, int &number_of_pairs, int number_of_partners[N], int i_particles[MAX_PAIRS], int j_particles[MAX_PAIRS], int pointer[N], int sorted_list[MAX_PAIRS]) {
  static int pointer2[N];
  int pos = 0;
  pointer[0] = 0;
  for (int i = 0; i < pn - 1; i++) {
    pos += number_of_partners[i];
    pointer[i + 1] = pos;
  }
  for (int i = 0; i < pn; i++) {
    pointer2[i] = 0;
  }
  const int s = number_of_pairs;
  for (int k = 0; k < s; k++) {
    int i = i_particles[k];
    int j = j_particles[k];
    int index = pointer[i] + pointer2[i];
    sorted_list[index] = j;
    pointer2[i] ++;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rsi, %r12
movl $0x0, (%r9)
cmpl $0x2, %edi
jl 0x2aa7
leal -0x1(%rdi), %eax
xorl %ecx, %ecx
xorl %esi, %esi
addl (%rdx,%rcx,4), %esi
movl %esi, 0x4(%rbx,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x2a98
testl %edi, %edi
jle 0x2abf
movl %edi, %edx
shlq $0x2, %rdx
leaq 0x46d8(%rip), %rdi      # 0x7190
xorl %esi, %esi
callq 0x2090
movslq (%r12), %rax
testq %rax, %rax
jle 0x2afd
movq 0x30(%rsp), %rcx
xorl %edx, %edx
leaq 0x46ba(%rip), %rsi      # 0x7190
movslq (%r15,%rdx,4), %rdi
movl (%r14,%rdx,4), %r8d
movslq (%rbx,%rdi,4), %r9
movslq (%rsi,%rdi,4), %r10
addq %r10, %r9
movl %r8d, (%rcx,%r9,4)
leal 0x1(%r10), %r8d
movl %r8d, (%rsi,%rdi,4)
incq %rdx
cmpq %rdx, %rax
jne 0x2ad6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]lj_simd/./conf.hpp
// Function: init(DataManager*, int&)
void
init(DataManager *dm, int &particle_number) {
  const double s = 1.0 / pow(density * 0.25, 1.0 / 3.0);
  const double hs = s * 0.5;
  int sx = static_cast<int>(L / s);
  int sy = static_cast<int>(L / s);
  int sz = static_cast<int>(L / s);
  for (int iz = 0; iz < sz; iz++) {
    for (int iy = 0; iy < sy; iy++) {
      for (int ix = 0; ix < sx; ix++) {
        double x = ix * s;
        double y = iy * s;
        double z = iz * s;
        dm->add_particle(x, y, z, particle_number);
        dm->add_particle(x, y + hs, z + hs, particle_number);
        dm->add_particle(x + hs, y, z + hs, particle_number);
        dm->add_particle(x + hs, y + hs, z, particle_number);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
vmovsd 0x45d9(%rip), %xmm0     # 0x70f8
vdivsd 0x24e9(%rip), %xmm0, %xmm0 # 0x5010
vcvttsd2si %xmm0, %ebp
testl %ebp, %ebp
jle 0x2c75
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
vxorpd %xmm0, %xmm0, %xmm0
vmovsd 0x24c8(%rip), %xmm1     # 0x5010
vmovsd 0x24c8(%rip), %xmm4     # 0x5018
vmovsd %xmm0, 0x30(%rsp)
vmulsd %xmm1, %xmm0, %xmm2
vaddsd %xmm4, %xmm2, %xmm0
vmovsd %xmm0, 0x10(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
xorl %r12d, %r12d
vmovsd %xmm2, 0x18(%rsp)
vmovsd %xmm0, 0x38(%rsp)
vmulsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, 0x28(%rsp)
vaddsd %xmm4, %xmm0, %xmm0
vmovsd %xmm0, 0x20(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
movl %ebp, %r13d
vmovsd %xmm0, 0x40(%rsp)
vmulsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, 0x8(%rsp)
movq (%r14), %rax
movq %r14, %rdi
vmovsd 0x28(%rsp), %xmm1
movq %rbx, %rsi
callq *(%rax)
movq (%r14), %rax
movq %r14, %rdi
vmovsd 0x8(%rsp), %xmm0
vmovsd 0x20(%rsp), %xmm1
vmovsd 0x10(%rsp), %xmm2
movq %rbx, %rsi
callq *(%rax)
vmovsd 0x8(%rsp), %xmm0
vaddsd 0x243a(%rip), %xmm0, %xmm0 # 0x5018
vmovsd %xmm0, 0x8(%rsp)
movq (%r14), %rax
movq %r14, %rdi
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x10(%rsp), %xmm2
movq %rbx, %rsi
callq *(%rax)
movq (%r14), %rax
movq %r14, %rdi
vmovsd 0x8(%rsp), %xmm0
vmovsd 0x20(%rsp), %xmm1
vmovsd 0x18(%rsp), %xmm2
movq %rbx, %rsi
callq *(%rax)
vmovsd 0x40(%rsp), %xmm0
vmovsd 0x18(%rsp), %xmm2
vmovsd 0x23f4(%rip), %xmm3     # 0x5020
vmovsd 0x23dc(%rip), %xmm1     # 0x5010
vaddsd %xmm3, %xmm0, %xmm0
decl %r13d
jne 0x2b92
vmovsd 0x38(%rsp), %xmm0
vaddsd %xmm3, %xmm0, %xmm0
incl %r12d
cmpl %ebp, %r12d
vmovsd 0x23bf(%rip), %xmm4     # 0x5018
jne 0x2b71
vmovsd 0x30(%rsp), %xmm0
vaddsd %xmm3, %xmm0, %xmm0
incl %r15d
cmpl %ebp, %r15d
jne 0x2b50
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]lj_simd/force_aos.cpp
// Function: copy_to_z()
void
copy_to_z(void) {
  for (int i = 0; i < particle_number; i++) {
    z[i][X] = q[i][X];
    z[i][Y] = q[i][Y];
    z[i][Z] = q[i][Z];
    z[i][PX] = p[i][X];
    z[i][PY] = p[i][Y];
    z[i][PZ] = p[i][Z];
  }
}

// Assembly:
movslq 0x325ef35(%rip), %rax   # 0x3261bc0
testq %rax, %rax
jle 0x2ce1
shlq $0x5, %rax
xorl %ecx, %ecx
leaq 0x18aef3(%rip), %rdx    # 0x18db90
leaq 0x19f4f1c(%rip), %rsi   # 0x19f7bc0
leaq 0xdbfee5(%rip), %rdi    # 0xdc2b90
vmovaps (%rcx,%rdx), %xmm0
vmovaps %xmm0, (%rsi,%rcx,2)
vmovsd 0x10(%rcx,%rdx), %xmm0
vmovsd %xmm0, 0x10(%rsi,%rcx,2)
vmovaps (%rcx,%rdi), %xmm0
vmovaps %xmm0, 0x20(%rsi,%rcx,2)
vmovsd 0x10(%rcx,%rdi), %xmm0
vmovsd %xmm0, 0x30(%rsi,%rcx,2)
addq $0x20, %rcx
cmpq %rcx, %rax
jne 0x2cab
retq
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]lj_simd/force_aos.cpp
// Function: copy_from_z()
void
copy_from_z(void) {
  for (int i = 0; i < particle_number; i++) {
    q[i][X] = z[i][X];
    q[i][Y] = z[i][Y];
    q[i][Z] = z[i][Z];
    p[i][X] = z[i][PX];
    p[i][Y] = z[i][PY];
    p[i][Z] = z[i][PZ];
  }
}

// Assembly:
movslq 0x325eed7(%rip), %rax   # 0x3261bc0
testq %rax, %rax
jle 0x2d3f
shlq $0x5, %rax
xorl %ecx, %ecx
leaq 0x19f4ec5(%rip), %rdx   # 0x19f7bc0
leaq 0x18ae8e(%rip), %rsi    # 0x18db90
leaq 0xdbfe87(%rip), %rdi    # 0xdc2b90
vmovaps (%rdx,%rcx,2), %xmm0
vmovaps %xmm0, (%rcx,%rsi)
vmovsd 0x10(%rdx,%rcx,2), %xmm0
vmovsd %xmm0, 0x10(%rcx,%rsi)
vmovaps 0x20(%rdx,%rcx,2), %xmm0
vmovaps %xmm0, (%rcx,%rdi)
vmovsd 0x30(%rdx,%rcx,2), %xmm0
vmovsd %xmm0, 0x10(%rcx,%rdi)
addq $0x20, %rcx
cmpq %rcx, %rax
jne 0x2d09
retq
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]lj_simd/force_aos.cpp
// Function: force_pair()
void
force_pair(void) {
  for (int k = 0; k < number_of_pairs; k++) {
    const int i = i_particles[k];
    const int j = j_particles[k];
    double dx = q[j][X] - q[i][X];
    double dy = q[j][Y] - q[i][Y];
    double dz = q[j][Z] - q[i][Z];
    double r2 = (dx * dx + dy * dy + dz * dz);
    double r6 = r2 * r2 * r2;
    double df = ((24.0 * r6 - 48.0) / (r6 * r6 * r2)) * dt;
    if (r2 > CL2) df = 0.0;
    p[i][X] += df * dx;
    p[i][Y] += df * dy;
    p[i][Z] += df * dz;
    p[j][X] -= df * dx;
    p[j][Y] -= df * dy;
    p[j][Z] -= df * dz;
  }
}

// Assembly:
movslq 0x325ee7d(%rip), %rax   # 0x3261bc4
testq %rax, %rax
jle 0x2e53
shlq $0x2, %rax
xorl %ecx, %ecx
leaq 0x33e5873(%rip), %rdx   # 0x33e85d0
leaq 0x61ac46c(%rip), %rsi   # 0x61af1d0
leaq 0x18ae25(%rip), %rdi    # 0x18db90
leaq 0xdbfe1e(%rip), %r8     # 0xdc2b90
vmovsd 0x22ae(%rip), %xmm0     # 0x5028
vmovsd 0x22ae(%rip), %xmm1     # 0x5030
vmovsd 0x22ae(%rip), %xmm2     # 0x5038
vmovsd 0x22ae(%rip), %xmm3     # 0x5040
vxorpd %xmm4, %xmm4, %xmm4
movslq (%rcx,%rdx), %r10
movslq (%rcx,%rsi), %r9
shlq $0x5, %r9
shlq $0x5, %r10
vmovsd 0x10(%r9,%rdi), %xmm5
vsubsd 0x10(%r10,%rdi), %xmm5, %xmm5
vmovapd (%r9,%rdi), %xmm6
vsubpd (%r10,%rdi), %xmm6, %xmm6
vmulpd %xmm6, %xmm6, %xmm7
vshufpd $0x1, %xmm7, %xmm7, %xmm7 # xmm7 = xmm7[1,0]
vfmadd231sd %xmm6, %xmm6, %xmm7 # xmm7 = (xmm6 * xmm6) + xmm7
vfmadd231sd %xmm5, %xmm5, %xmm7 # xmm7 = (xmm5 * xmm5) + xmm7
vmulsd %xmm7, %xmm7, %xmm8
vmulsd %xmm7, %xmm8, %xmm8
vmovapd %xmm0, %xmm9
vmulsd %xmm8, %xmm8, %xmm10
vfmadd213sd %xmm1, %xmm8, %xmm9 # xmm9 = (xmm8 * xmm9) + xmm1
vmulsd %xmm7, %xmm10, %xmm8
vdivsd %xmm8, %xmm9, %xmm8
vmulsd %xmm2, %xmm8, %xmm8
vcmpgtsd %xmm3, %xmm7, %k1
vmovsd %xmm4, %xmm8, %xmm8 {%k1}
vmovddup %xmm8, %xmm7            # xmm7 = xmm8[0,0]
vmovapd (%r10,%r8), %xmm9
vfmadd231pd %xmm6, %xmm7, %xmm9 # xmm9 = (xmm7 * xmm6) + xmm9
vmovapd %xmm9, (%r10,%r8)
vmovsd 0x10(%r10,%r8), %xmm9
vfmadd231sd %xmm5, %xmm8, %xmm9 # xmm9 = (xmm8 * xmm5) + xmm9
vmovsd %xmm9, 0x10(%r10,%r8)
vfnmadd213pd (%r9,%r8), %xmm7, %xmm6 # xmm6 = -(xmm7 * xmm6) + mem
vmovapd %xmm6, (%r9,%r8)
vfnmadd213sd 0x10(%r9,%r8), %xmm5, %xmm8 # xmm8 = -(xmm5 * xmm8) + mem
vmovsd %xmm8, 0x10(%r9,%r8)
addq $0x4, %rcx
cmpq %rcx, %rax
jne 0x2d96
retq
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]lj_simd/force_aos.cpp
// Function: force_sorted_z()
void
force_sorted_z(void) {
  const int pn = particle_number;
  for (int i = 0; i < pn; i++) {
    const double qix = z[i][X];
    const double qiy = z[i][Y];
    const double qiz = z[i][Z];
    const int np = number_of_partners[i];
    double pfx = 0;
    double pfy = 0;
    double pfz = 0;
    const int kp = pointer[i];
    for (int k = 0; k < np; k++) {
      const int j = sorted_list[kp + k];
      double dx = z[j][X] - qix;
      double dy = z[j][Y] - qiy;
      double dz = z[j][Z] - qiz;
      double r2 = (dx * dx + dy * dy + dz * dz);
      double r6 = r2 * r2 * r2;
      double df = ((24.0 * r6 - 48.0) / (r6 * r6 * r2)) * dt;
      if (r2 > CL2) df = 0.0;
      pfx += df * dx;
      pfy += df * dy;
      pfz += df * dz;
      z[j][PX] -= df * dx;
      z[j][PY] -= df * dy;
      z[j][PZ] -= df * dz;
    }
    z[i][PX] += pfx;
    z[i][PY] += pfy;
    z[i][PZ] += pfz;
  }
}

// Assembly:
movslq 0x325ec02(%rip), %rax   # 0x3261bc0
testq %rax, %rax
jle 0x3114
pushq %r14
pushq %rbx
xorl %ecx, %ecx
leaq 0x19f4bed(%rip), %rdx   # 0x19f7bc0
leaq 0x325ebf6(%rip), %rsi   # 0x3261bd0
leaq 0x8f72def(%rip), %rdi   # 0x8f75dd0
leaq 0x90f97e8(%rip), %r8    # 0x90fc7d0
vmovsd 0x2038(%rip), %xmm0     # 0x5028
vmovsd 0x2038(%rip), %xmm1     # 0x5030
vmovsd 0x2038(%rip), %xmm2     # 0x5038
vmovsd 0x2038(%rip), %xmm3     # 0x5040
vxorpd %xmm4, %xmm4, %xmm4
movq %rcx, %r9
shlq $0x6, %r9
movslq (%rsi,%rcx,4), %r10
testq %r10, %r10
jle 0x30e2
vmovapd (%r9,%rdx), %xmm7
vmovsd 0x10(%r9,%rdx), %xmm8
movslq (%rdi,%rcx,4), %r11
shlq $0x2, %r11
vxorpd %xmm6, %xmm6, %xmm6
vxorpd %xmm5, %xmm5, %xmm5
xorl %ebx, %ebx
leaq (%r11,%rbx,4), %r14
movslq (%r8,%r14), %r14
shlq $0x6, %r14
vmovapd (%r14,%rdx), %xmm9
vmovsd 0x10(%r14,%rdx), %xmm10
vsubpd %xmm7, %xmm9, %xmm9
vsubsd %xmm8, %xmm10, %xmm10
vmulpd %xmm9, %xmm9, %xmm11
vshufpd $0x1, %xmm11, %xmm11, %xmm11 # xmm11 = xmm11[1,0]
vfmadd231sd %xmm9, %xmm9, %xmm11 # xmm11 = (xmm9 * xmm9) + xmm11
vfmadd231sd %xmm10, %xmm10, %xmm11 # xmm11 = (xmm10 * xmm10) + xmm11
vmulsd %xmm11, %xmm11, %xmm12
vmulsd %xmm12, %xmm11, %xmm12
vmovapd %xmm0, %xmm13
vfmadd213sd %xmm1, %xmm12, %xmm13 # xmm13 = (xmm12 * xmm13) + xmm1
vmulsd %xmm12, %xmm12, %xmm12
vmulsd %xmm12, %xmm11, %xmm12
vdivsd %xmm12, %xmm13, %xmm12
vmulsd %xmm2, %xmm12, %xmm12
vcmpgtsd %xmm3, %xmm11, %k1
vmovsd %xmm4, %xmm12, %xmm12 {%k1}
vmovddup %xmm12, %xmm11          # xmm11 = xmm12[0,0]
vfmadd231sd %xmm12, %xmm10, %xmm5 # xmm5 = (xmm10 * xmm12) + xmm5
vfmadd231pd %xmm9, %xmm11, %xmm6 # xmm6 = (xmm11 * xmm9) + xmm6
vfnmadd213pd 0x20(%r14,%rdx), %xmm11, %xmm9 # xmm9 = -(xmm11 * xmm9) + mem
vmovapd %xmm9, 0x20(%r14,%rdx)
vfnmadd213sd 0x30(%r14,%rdx), %xmm12, %xmm10 # xmm10 = -(xmm12 * xmm10) + mem
vmovsd %xmm10, 0x30(%r14,%rdx)
incq %rbx
cmpq %rbx, %r10
jne 0x303f
jmp 0x30ea
vxorpd %xmm6, %xmm6, %xmm6
vxorpd %xmm5, %xmm5, %xmm5
addq %rdx, %r9
vaddpd 0x20(%r9), %xmm6, %xmm6
vmovapd %xmm6, 0x20(%r9)
vaddsd 0x30(%r9), %xmm5, %xmm5
vmovsd %xmm5, 0x30(%r9)
incq %rcx
cmpq %rax, %rcx
jne 0x300c
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]lj_simd/force_aos.cpp
// Function: AoSDataManager::print_results(int)
void
    print_results(int particle_number) {
      for (int i = 0; i < 5; i++) {
        printf("%.10f %.10f %.10f\n", p[i][X], p[i][Y], p[i][Z]);
      }
      for (int i = particle_number - 5; i < particle_number; i++) {
        printf("%.10f %.10f %.10f\n", p[i][X], p[i][Y], p[i][Z]);
      }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movl $0x10, %r12d
leaq 0xe12(%rip), %r15       # 0x5106
movq 0x8(%rbx), %rax
vmovsd -0x10(%rax,%r12), %xmm0
vmovsd -0x8(%rax,%r12), %xmm1
vmovsd (%rax,%r12), %xmm2
movq %r15, %rdi
movb $0x3, %al
callq 0x2040
addq $0x20, %r12
cmpq $0xb0, %r12
jne 0x42f4
leal -0x5(%r14), %eax
movslq %eax, %r15
movslq %r14d, %r12
movq %r15, %r13
shlq $0x5, %r13
orq $0x10, %r13
leaq 0xdc7(%rip), %r14       # 0x5106
movq 0x8(%rbx), %rax
vmovsd -0x10(%rax,%r13), %xmm0
vmovsd -0x8(%rax,%r13), %xmm1
vmovsd (%rax,%r13), %xmm2
movq %r14, %rdi
movb $0x3, %al
callq 0x2040
incq %r15
addq $0x20, %r13
cmpq %r12, %r15
jl 0x433f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]lj_simd/force_aos.cpp
// Function: AoSDataManager::add_particle(double, double, double, int&)
void
    add_particle(double x, double y, double z, int &particle_number) {
      static std::mt19937 mt(2);
      std::uniform_real_distribution<double> ud(0.0, 0.1);
      q[particle_number][X] = x + ud(mt);
      q[particle_number][Y] = y + ud(mt);
      q[particle_number][Z] = z + ud(mt);
      particle_number++;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
vmovsd %xmm2, 0x18(%rsp)
vmovsd %xmm1, 0x10(%rsp)
vmovsd %xmm0, 0x8(%rsp)
movq %rdi, %r14
movb 0xbec03b9(%rip), %al    # 0xbec4758
testb %al, %al
je 0x4440
leaq 0xbebf022(%rip), %r15   # 0xbec33d0
movq %r15, %rdi
callq 0x448d
vxorpd %xmm1, %xmm1, %xmm1
vfmadd132sd 0xc95(%rip), %xmm1, %xmm0 # xmm0 = (xmm0 * mem) + xmm1
vaddsd 0x8(%rsp), %xmm0, %xmm0
movq 0x10(%r14), %rax
movslq (%rbx), %rcx
shlq $0x5, %rcx
vmovsd %xmm0, (%rax,%rcx)
movq %r15, %rdi
callq 0x448d
vxorpd %xmm1, %xmm1, %xmm1
vfmadd132sd 0xc6a(%rip), %xmm1, %xmm0 # xmm0 = (xmm0 * mem) + xmm1
vaddsd 0x10(%rsp), %xmm0, %xmm0
movq 0x10(%r14), %rax
movslq (%rbx), %rcx
shlq $0x5, %rcx
vmovsd %xmm0, 0x8(%rax,%rcx)
movq %r15, %rdi
callq 0x448d
vxorpd %xmm1, %xmm1, %xmm1
vfmadd132sd 0xc3e(%rip), %xmm1, %xmm0 # xmm0 = (xmm0 * mem) + xmm1
vaddsd 0x18(%rsp), %xmm0, %xmm0
movq 0x10(%r14), %rax
movslq (%rbx), %rcx
leal 0x1(%rcx), %edx
shlq $0x5, %rcx
vmovsd %xmm0, 0x10(%rax,%rcx)
movl %edx, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x231b
jmp 0x43a7
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]lj_simd/force_aos.cpp
// Function: AoSDataManager::calc_distance(int, int)
double
    calc_distance(int i, int j) {
      const double dx = q[i][X] - q[j][X];
      const double dy = q[i][Y] - q[j][Y];
      const double dz = q[i][Z] - q[j][Z];
      return dx * dx + dy * dy + dz * dz;
    }

// Assembly:
movq 0x10(%rdi), %rax
movslq %esi, %rcx
shlq $0x5, %rcx
movslq %edx, %rdx
shlq $0x5, %rdx
vmovsd (%rax,%rcx), %xmm0
vmovsd 0x8(%rax,%rcx), %xmm1
vsubsd (%rax,%rdx), %xmm0, %xmm2
vsubsd 0x8(%rax,%rdx), %xmm1, %xmm0
vmovsd 0x10(%rax,%rcx), %xmm1
vsubsd 0x10(%rax,%rdx), %xmm1, %xmm1
vmulsd %xmm0, %xmm0, %xmm0
vfmadd231sd %xmm2, %xmm2, %xmm0 # xmm0 = (xmm2 * xmm2) + xmm0
vfmadd231sd %xmm1, %xmm1, %xmm0 # xmm0 = (xmm1 * xmm1) + xmm0
retq