LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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), %xmm1
xorpd %xmm0, %xmm0
movsd %xmm1, (%rsp)
ucomisd %xmm0, %xmm1
jne 0x877b
jnp 0x87ef
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %r13d
leaq (,%r13,8), %r12
testl %r13d, %r13d
movq $-0x1, %rdi
cmovnsq %r12, %rdi
callq 0x2030
movq %rax, (%rbx)
movl %r13d, 0x8(%rbx)
testl %r13d, %r13d
jle 0x87dd
movq %rax, %r15
xorl %ebp, %ebp
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x20a0
movsd (%rsp), %xmm1
movq (%r14), %rax
movsd (%rax,%rbp,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%r15,%rbp,8)
incq %rbp
cmpq %rbp, %r13
jne 0x87c6
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 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xdb8(%rip), %rsi       # 0x95c4
leaq 0xdb6(%rip), %rdx       # 0x95c9
leaq 0x8(%rsp), %rdi
callq 0x8150
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xd9c(%rip), %rsi       # 0x95ca
leaq 0xdae(%rip), %rdx       # 0x95e3
leaq 0x28(%rsp), %rdi
callq 0x8150
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x8ecc
xorl %ebp, %ebp
leaq 0x453b(%rip), %rsi      # 0xcd98
leaq -0x73e(%rip), %rdx      # 0x8126
movq %rbx, %rdi
callq 0x21c0
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x887e
callq 0x2140
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x888d
callq 0x2140
testb %bpl, %bpl
jne 0x88ab
jmp 0x88b3
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x88ab
callq 0x2140
jmp 0x88ab
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rsi), %r13d
leaq (,%r13,8), %r12
testl %r13d, %r13d
movq $-0x1, %rdi
cmovnsq %r12, %rdi
callq 0x2030
movq %rax, (%rbx)
movl %r13d, 0x8(%rbx)
testl %r13d, %r13d
jle 0x8928
movq %rax, %r14
xorl %ebp, %ebp
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x20a0
movq (%r15), %rax
movaps 0x74d(%rip), %xmm0      # 0x9060
movsd (%rax,%rbp,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%r14,%rbp,8)
incq %rbp
cmpq %rbp, %r13
jne 0x8913
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_O3/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 0x89f6
movq %rdi, %rbx
cmpl %eax, %ecx
jge 0x89c8
testl %ecx, %ecx
jle 0x897a
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 0x8968
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 0x4652(%rip), %r14      # 0xcff0
leaq 0xc7b(%rip), %rsi       # 0x9620
movl $0x38, %edx
movq %r14, %rdi
callq 0x2160
leaq 0xca0(%rip), %rsi       # 0x9659
movl $0x23, %edx
movq %r14, %rdi
callq 0x2160
jmp 0x89e6
testl %eax, %eax
jle 0x89e6
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 0x89d4
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 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6c8(%rip), %rsi       # 0x90db
leaq 0x6d0(%rip), %rdx       # 0x90ea
movq %rsp, %rdi
callq 0x8150
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xbb1(%rip), %rsi       # 0x95e4
leaq 0xbe5(%rip), %rdx       # 0x961f
leaq 0x20(%rsp), %rdi
callq 0x8150
movb $0x1, %bpl
movq %rsp, %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x8ecc
xorl %ebp, %ebp
leaq 0x4338(%rip), %rsi      # 0xcd98
leaq -0x941(%rip), %rdx      # 0x8126
movq %rbx, %rdi
callq 0x21c0
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x8a81
callq 0x2140
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x8a8f
callq 0x2140
testb %bpl, %bpl
jne 0x8aac
jmp 0x8ab4
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x8aac
callq 0x2140
jmp 0x8aac
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8af5
cmpl %esi, 0x8(%rdi)
jl 0x8b74
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 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x58e(%rip), %rsi       # 0x90a0
leaq 0x593(%rip), %rdx       # 0x90ac
leaq 0x20(%rsp), %rdi
callq 0x8150
leaq 0x70(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x579(%rip), %rsi       # 0x90ad
leaq 0x59f(%rip), %rdx       # 0x90da
leaq 0x60(%rsp), %rdi
callq 0x8150
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
leaq 0x60(%rsp), %rdx
movq %rbx, %rdi
callq 0x8ecc
xorl %ebp, %ebp
leaq 0x4235(%rip), %rsi      # 0xcd98
leaq -0xa44(%rip), %rdx      # 0x8126
movq %rbx, %rdi
callq 0x21c0
jmp 0x8bed
movl $0x40, %edi
callq 0x2080
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x54a(%rip), %rsi       # 0x90db
leaq 0x552(%rip), %rdx       # 0x90ea
movq %rsp, %rdi
callq 0x8150
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x53a(%rip), %rsi       # 0x90eb
leaq 0x55f(%rip), %rdx       # 0x9117
leaq 0x40(%rsp), %rdi
callq 0x8150
movb $0x1, %bpl
movq %rsp, %rsi
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x8ecc
xorl %ebp, %ebp
leaq 0x41ba(%rip), %rsi      # 0xcd98
leaq -0xabf(%rip), %rdx      # 0x8126
movq %rbx, %rdi
callq 0x21c0
movq %rax, %r14
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0x8bff
callq 0x2140
movq (%rsp), %rdi
jmp 0x8c25
movq %rax, %r14
movq (%rsp), %rdi
jmp 0x8c3e
movq %rax, %r14
movq 0x60(%rsp), %rdi
cmpq %r12, %rdi
je 0x8c20
callq 0x2140
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x8c2f
callq 0x2140
testb %bpl, %bpl
jne 0x8c4f
jmp 0x8c57
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x8c4f
callq 0x2140
jmp 0x8c4f
jmp 0x8c4c
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa19(%rip), %rsi       # 0x968e
movl $0x1, %edx
callq 0x2160
cmpl $0x0, 0x8(%r14)
jle 0x8cdc
xorl %r13d, %r13d
leaq 0x5f2(%rip), %r15       # 0x9282
leaq 0x9e6(%rip), %r12       # 0x967d
movq (%r14), %rax
movsd (%rax,%r13,8), %xmm0
movq %rbx, %rdi
callq 0x21a0
movl 0x8(%r14), %eax
decl %eax
cmpq %rax, %r13
jne 0x8cc0
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
jmp 0x8ccb
movl $0x2, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2160
incq %r13
movslq 0x8(%r14), %rax
cmpq %rax, %r13
jl 0x8c97
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8d42
movq %rdi, %rbx
xorpd %xmm2, %xmm2
xorl %ebp, %ebp
movsd %xmm2, 0x10(%rsp)
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8abc
movsd (%rax), %xmm0
andpd 0x7da(%rip), %xmm0      # 0x9500
movsd 0x8(%rsp), %xmm1
callq 0x21e0
movsd 0x10(%rsp), %xmm2
addsd %xmm0, %xmm2
cmpl 0x8(%rbx), %ebp
jl 0x8d08
jmp 0x8d46
xorpd %xmm2, %xmm2
movsd 0x2ca(%rip), %xmm1      # 0x9018
divsd 0x8(%rsp), %xmm1
movapd %xmm2, %xmm0
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8dd2
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 0x761(%rip), %xmm0      # 0x9500
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 0x8d88
jmp 0x8dd5
xorps %xmm0, %xmm0
movsd 0x23b(%rip), %xmm1      # 0x9018
divsd %xmm2, %xmm1
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r12d
leaq (,%r12,8), %r15
testl %esi, %esi
movq $-0x1, %rdi
cmovnsq %r15, %rdi
callq 0x2030
movq %rax, (%rbx)
movl %ebp, 0x8(%rbx)
testl %ebp, %ebp
jle 0x8e4d
movq %rax, %r14
xorl %r13d, %r13d
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x20a0
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%r14,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x8e41
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8eb0
xorl %r12d, %r12d
callq 0x2060
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss 0x1d5(%rip), %xmm0      # 0x9070
cvtss2sd %xmm0, %xmm0
movq (%r14), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x8e87
movq %rbx, %rdi
movq %r14, %rsi
callq 0x822a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x2f0e(%rip), %rsi      # 0x512c
cqto
idivq %rcx
movq 0x4da6(%rip), %rcx      # 0x6fd0
movl %ebp, %edx
movq (%rcx), %rdi
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_O3/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)
leaq 0x2c46(%rip), %r15      # 0x5119
movl %esi, %ebp
movl %edi, %esi
movl %r8d, %r12d
movl %ecx, %r13d
movl %edx, %ebx
movl 0x48(%rsp), %eax
movq %r15, %rdi
movl %eax, 0x4(%rsp)
xorl %eax, %eax
movl 0x40(%rsp), %r14d
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
movl (%rsp), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2040
movq %r15, %rdi
movl %r14d, %esi
xorl %eax, %eax
callq 0x2040
movl 0x4(%rsp), %esi
leaq 0x2bd2(%rip), %rdi      # 0x511f
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_O3/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
leaq 0x2ba1(%rip), %rbx      # 0x5119
xorl %r14d, %r14d
vmovaps %ymm0, (%rsp)
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_O3/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
leaq 0x2b6c(%rip), %rbx      # 0x5125
movb $0x1, %al
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)
movq %rbx, %rdi
callq 0x2040
vmovsd 0x8(%rsp), %xmm0
movb $0x1, %al
movq %rbx, %rdi
callq 0x2040
vmovsd 0x10(%rsp), %xmm0
movb $0x1, %al
movq %rbx, %rdi
callq 0x2040
vmovsd 0x18(%rsp), %xmm0
movb $0x1, %al
movq %rbx, %rdi
callq 0x2040
vmovsd 0x20(%rsp), %xmm0
movb $0x1, %al
movq %rbx, %rdi
callq 0x2040
vmovsd 0x28(%rsp), %xmm0
movb $0x1, %al
movq %rbx, %rdi
callq 0x2040
vmovsd 0x30(%rsp), %xmm0
movb $0x1, %al
movq %rbx, %rdi
callq 0x2040
vmovsd 0x38(%rsp), %xmm0
leaq 0x2ab8(%rip), %rdi      # 0x5112
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
jmp 0x2040
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x2aa9(%rip), %rbx      # 0x5125
xorl %r14d, %r14d
vmovaps %ymm0, (%rsp)
vmovsd (%rsp,%r14,8), %xmm0
movb $0x1, %al
movq %rbx, %rdi
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_O3/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 %rdx, %r14
movq %rsi, %r15
leaq 0x2a70(%rip), %rsi      # 0x5140
leaq 0x8(%rsp), %r13
movl $0x4, %edx
movq %rdi, %r12
movq %rcx, %rbx
movq %r13, %rdi
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
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x2060
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdx, %r14
movq %rsi, %r15
leaq 0xc(%rsp), %r12
leaq 0x29c0(%rip), %rsi      # 0x5140
leaq 0x10(%rsp), %r13
movl $0x4, %edx
movq %rcx, %rbx
movl %edi, (%r12)
movq %r13, %rdi
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
leaq 0x18(%rsp), %rdi
movq (%rax), %rcx
movq 0x18(%rax), %rax
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
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0x2170
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
testl %edi, %edi
jle 0x290a
movq %rdx, %r12
movl %edi, %edx
shlq $0x2, %rdx
movq %rsi, %r13
movl %edi, %ebp
movq %r9, %rbx
xorl %r14d, %r14d
movq %r12, %rdi
xorl %esi, %esi
callq 0x2090
cmpl $0x1, %ebp
je 0x290a
leal -0x2(%rbp), %eax
movl %eax, (%rsp)
leal 0x1(%r14), %r15d
movl %r15d, 0x4(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq *0x8(%rax)
vmovsd 0x2748(%rip), %xmm1     # 0x5008
vucomisd %xmm0, %xmm1
jbe 0x28f7
movslq (%r13), %rdx
movq 0x8(%rsp), %rsi
cmpl %r15d, %r14d
movl %r15d, %eax
movl %r15d, %ecx
cmovll %r14d, %eax
cmovgl %r14d, %ecx
movl %eax, (%rsi,%rdx,4)
movq 0x10(%rsp), %rsi
movslq (%r13), %rdx
movl %ecx, (%rsi,%rdx,4)
incl (%r12,%rax,4)
incl (%r13)
incl %r15d
cmpl %r15d, %ebp
jne 0x28a9
cmpl (%rsp), %r14d
movl 0x4(%rsp), %r14d
jne 0x28a0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rsi, %rbx
movl %edi, %ebp
leaq 0x280a(%rip), %rdi      # 0x5140
leaq 0x8(%rsp), %rsi
movq %r9, %r13
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
callq 0x20f0
testl %eax, %eax
je 0x29c0
movq %r13, (%rsp)
movq 0x4695(%rip), %r13      # 0x6ff0
leaq 0x2807(%rip), %rsi      # 0x5169
movl $0xe, %edx
movq %r13, %rdi
callq 0x2120
movq (%r13), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %r13, %rdi
callq 0x2100
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq (%rsp), %r9
movl %ebp, %edi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x2857
movl (%rbx), %edi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x275e
jmp 0x2a14
movq 0x4629(%rip), %r13      # 0x6ff0
leaq 0x277b(%rip), %rsi      # 0x5149
movl $0x1f, %edx
movq %r13, %rdi
callq 0x2120
movq (%r13), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %r13, %rdi
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 0x45d5(%rip), %r14      # 0x6ff0
leaq 0x2756(%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
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %rbx, %rdi
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_O3/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 0x2aaa
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 0x2a9b
testl %edi, %edi
jle 0x2ac2
movl %edi, %edx
shlq $0x2, %rdx
leaq 0x46d5(%rip), %rdi      # 0x7190
xorl %esi, %esi
callq 0x2090
movslq (%r12), %rax
testq %rax, %rax
jle 0x2b00
movq 0x30(%rsp), %rcx
leaq 0x46b9(%rip), %rsi      # 0x7190
xorl %edx, %edx
movslq (%r15,%rdx,4), %rdi
movl (%r14,%rdx,4), %r8d
incq %rdx
movslq (%rbx,%rdi,4), %r9
movslq (%rsi,%rdi,4), %r10
addq %r10, %r9
movl %r8d, (%rcx,%r9,4)
leal 0x1(%r10), %r9d
movl %r9d, (%rsi,%rdi,4)
cmpq %rdx, %rax
jne 0x2ad9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x45d6(%rip), %xmm0     # 0x70f8
vdivsd 0x24e6(%rip), %xmm0, %xmm0 # 0x5010
vcvttsd2si %xmm0, %ebp
testl %ebp, %ebp
jle 0x2c78
vmovsd 0x24d2(%rip), %xmm1     # 0x5010
vmovsd 0x24d2(%rip), %xmm4     # 0x5018
vxorpd %xmm0, %xmm0, %xmm0
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
vmulsd %xmm1, %xmm0, %xmm2
vmovsd %xmm0, 0x30(%rsp)
xorl %r12d, %r12d
vaddsd %xmm4, %xmm2, %xmm0
vmovsd %xmm2, 0x18(%rsp)
vmovsd %xmm0, 0x10(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vmovsd %xmm0, 0x38(%rsp)
vmulsd %xmm1, %xmm0, %xmm0
movl %ebp, %r13d
vmovsd %xmm0, 0x28(%rsp)
vaddsd %xmm4, %xmm0, %xmm0
vmovsd %xmm0, 0x20(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vmovsd %xmm0, 0x40(%rsp)
vmulsd %xmm1, %xmm0, %xmm0
vmovsd 0x28(%rsp), %xmm1
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
vmovsd %xmm0, 0x8(%rsp)
callq *(%rax)
vmovsd 0x8(%rsp), %xmm0
vmovsd 0x20(%rsp), %xmm1
vmovsd 0x10(%rsp), %xmm2
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
vmovsd 0x8(%rsp), %xmm0
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x10(%rsp), %xmm2
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
vaddsd 0x2422(%rip), %xmm0, %xmm0 # 0x5018
vmovsd %xmm0, 0x8(%rsp)
callq *(%rax)
vmovsd 0x8(%rsp), %xmm0
vmovsd 0x20(%rsp), %xmm1
vmovsd 0x18(%rsp), %xmm2
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
vmovsd 0x40(%rsp), %xmm0
vmovsd 0x23f7(%rip), %xmm3     # 0x5020
vmovsd 0x18(%rsp), %xmm2
vmovsd 0x23d9(%rip), %xmm1     # 0x5010
decl %r13d
vaddsd %xmm3, %xmm0, %xmm0
jne 0x2b95
vmovsd 0x38(%rsp), %xmm0
vmovsd 0x23c6(%rip), %xmm4     # 0x5018
incl %r12d
vaddsd %xmm3, %xmm0, %xmm0
cmpl %ebp, %r12d
jne 0x2b74
vmovsd 0x30(%rsp), %xmm0
incl %r15d
vaddsd %xmm3, %xmm0, %xmm0
cmpl %ebp, %r15d
jne 0x2b53
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x325ef32(%rip), %rax   # 0x3261bc0
testq %rax, %rax
jle 0x2ce4
shlq $0x5, %rax
leaq 0x18aef2(%rip), %rdx    # 0x18db90
leaq 0x19f4f1b(%rip), %rsi   # 0x19f7bc0
leaq 0xdbfee4(%rip), %rdi    # 0xdc2b90
xorl %ecx, %ecx
vmovaps (%rcx,%rdx), %xmm0
vmovsd 0x10(%rcx,%rdx), %xmm1
vmovaps (%rcx,%rdi), %xmm2
vmovaps %xmm0, (%rsi,%rcx,2)
vmovsd %xmm1, 0x10(%rsi,%rcx,2)
vmovsd 0x10(%rcx,%rdi), %xmm1
vmovaps %xmm2, 0x20(%rsi,%rcx,2)
vmovsd %xmm1, 0x30(%rsi,%rcx,2)
addq $0x20, %rcx
cmpq %rcx, %rax
jne 0x2cae
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x325eed4(%rip), %rax   # 0x3261bc0
testq %rax, %rax
jle 0x2d42
shlq $0x5, %rax
leaq 0x19f4ec4(%rip), %rdx   # 0x19f7bc0
leaq 0x18ae8d(%rip), %rsi    # 0x18db90
leaq 0xdbfe86(%rip), %rdi    # 0xdc2b90
xorl %ecx, %ecx
vmovaps (%rdx,%rcx,2), %xmm0
vmovsd 0x10(%rdx,%rcx,2), %xmm1
vmovaps 0x20(%rdx,%rcx,2), %xmm2
vmovaps %xmm0, (%rcx,%rsi)
vmovsd %xmm1, 0x10(%rcx,%rsi)
vmovsd 0x30(%rdx,%rcx,2), %xmm1
vmovaps %xmm2, (%rcx,%rdi)
vmovsd %xmm1, 0x10(%rcx,%rdi)
addq $0x20, %rcx
cmpq %rcx, %rax
jne 0x2d0c
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x325ee7a(%rip), %rax   # 0x3261bc4
testq %rax, %rax
jle 0x2e56
vmovsd 0x22cd(%rip), %xmm0     # 0x5028
vmovsd 0x22cd(%rip), %xmm1     # 0x5030
vmovsd 0x22cd(%rip), %xmm2     # 0x5038
vmovsd 0x22cd(%rip), %xmm3     # 0x5040
shlq $0x2, %rax
leaq 0x33e5852(%rip), %rdx   # 0x33e85d0
leaq 0x61ac44b(%rip), %rsi   # 0x61af1d0
leaq 0x18ae04(%rip), %rdi    # 0x18db90
leaq 0xdbfdfd(%rip), %r8     # 0xdc2b90
vxorpd %xmm4, %xmm4, %xmm4
xorl %ecx, %ecx
movslq (%rcx,%rsi), %r9
movslq (%rcx,%rdx), %r10
vmovapd %xmm0, %xmm9
addq $0x4, %rcx
shlq $0x5, %r9
shlq $0x5, %r10
vmovapd (%r9,%rdi), %xmm6
vmovsd 0x10(%r9,%rdi), %xmm5
vsubpd (%r10,%rdi), %xmm6, %xmm6
vsubsd 0x10(%r10,%rdi), %xmm5, %xmm5
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
vcmpgtsd %xmm3, %xmm7, %k1
vmulsd %xmm7, %xmm8, %xmm8
vmulsd %xmm8, %xmm8, %xmm10
vfmadd213sd %xmm1, %xmm8, %xmm9 # xmm9 = (xmm8 * xmm9) + xmm1
vmulsd %xmm7, %xmm10, %xmm8
vdivsd %xmm8, %xmm9, %xmm8
vmovapd (%r10,%r8), %xmm9
vmulsd %xmm2, %xmm8, %xmm8
vmovsd %xmm4, %xmm8, %xmm8 {%k1}
vmovddup %xmm8, %xmm7            # xmm7 = xmm8[0,0]
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)
cmpq %rcx, %rax
jne 0x2d99
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x325ebff(%rip), %rax   # 0x3261bc0
testq %rax, %rax
jle 0x3117
pushq %r14
pushq %rbx
vmovsd 0x2053(%rip), %xmm0     # 0x5028
vmovsd 0x2053(%rip), %xmm1     # 0x5030
vmovsd 0x2053(%rip), %xmm2     # 0x5038
vmovsd 0x2053(%rip), %xmm3     # 0x5040
leaq 0x19f4bcc(%rip), %rdx   # 0x19f7bc0
leaq 0x325ebd5(%rip), %rsi   # 0x3261bd0
leaq 0x8f72dce(%rip), %rdi   # 0x8f75dd0
leaq 0x90f97c7(%rip), %r8    # 0x90fc7d0
vxorpd %xmm4, %xmm4, %xmm4
xorl %ecx, %ecx
movslq (%rsi,%rcx,4), %r10
movq %rcx, %r9
shlq $0x6, %r9
testq %r10, %r10
jle 0x30e5
vmovapd (%r9,%rdx), %xmm7
vmovsd 0x10(%r9,%rdx), %xmm8
movslq (%rdi,%rcx,4), %r11
vxorpd %xmm6, %xmm6, %xmm6
vxorpd %xmm5, %xmm5, %xmm5
xorl %ebx, %ebx
shlq $0x2, %r11
leaq (%r11,%rbx,4), %r14
vmovapd %xmm0, %xmm13
incq %rbx
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
vcmpgtsd %xmm3, %xmm11, %k1
vmulsd %xmm12, %xmm11, %xmm12
vfmadd213sd %xmm1, %xmm12, %xmm13 # xmm13 = (xmm12 * xmm13) + xmm1
vmulsd %xmm12, %xmm12, %xmm12
vmulsd %xmm12, %xmm11, %xmm12
vdivsd %xmm12, %xmm13, %xmm12
vmulsd %xmm2, %xmm12, %xmm12
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)
cmpq %rbx, %r10
jne 0x3042
jmp 0x30ed
vxorpd %xmm6, %xmm6, %xmm6
vxorpd %xmm5, %xmm5, %xmm5
addq %rdx, %r9
incq %rcx
vaddpd 0x20(%r9), %xmm6, %xmm6
vmovapd %xmm6, 0x20(%r9)
vaddsd 0x30(%r9), %xmm5, %xmm5
vmovsd %xmm5, 0x30(%r9)
cmpq %rax, %rcx
jne 0x300f
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x10, %r12d
leaq 0xda6(%rip), %r15       # 0x5106
movl %esi, %r14d
movq %rdi, %rbx
movq 0x8(%rbx), %rax
movq %r15, %rdi
vmovsd -0x10(%rax,%r12), %xmm0
vmovsd -0x8(%rax,%r12), %xmm1
vmovsd (%rax,%r12), %xmm2
movb $0x3, %al
callq 0x2040
addq $0x20, %r12
cmpq $0xb0, %r12
jne 0x4366
leal -0x5(%r14), %eax
movslq %r14d, %r12
leaq 0xd63(%rip), %r14       # 0x5106
movslq %eax, %r15
movq %r15, %r13
shlq $0x5, %r13
orq $0x10, %r13
movq 0x8(%rbx), %rax
movq %r14, %rdi
vmovsd -0x10(%rax,%r13), %xmm0
vmovsd -0x8(%rax,%r13), %xmm1
vmovsd (%rax,%r13), %xmm2
movb $0x3, %al
callq 0x2040
incq %r15
addq $0x20, %r13
cmpq %r12, %r15
jl 0x43b1
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
vmovsd %xmm2, 0x18(%rsp)
vmovsd %xmm1, 0x10(%rsp)
vmovsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movb 0xbec0347(%rip), %al    # 0xbec4758
testb %al, %al
je 0x44b2
leaq 0xbebefb0(%rip), %r15   # 0xbec33d0
movq %r15, %rdi
callq 0x44ff
vxorpd %xmm1, %xmm1, %xmm1
vfmadd132sd 0xc23(%rip), %xmm1, %xmm0 # xmm0 = (xmm0 * mem) + xmm1
movslq (%rbx), %rcx
movq 0x10(%r14), %rax
movq %r15, %rdi
vaddsd 0x8(%rsp), %xmm0, %xmm0
shlq $0x5, %rcx
vmovsd %xmm0, (%rax,%rcx)
callq 0x44ff
vxorpd %xmm1, %xmm1, %xmm1
vfmadd132sd 0xbf8(%rip), %xmm1, %xmm0 # xmm0 = (xmm0 * mem) + xmm1
movslq (%rbx), %rcx
movq 0x10(%r14), %rax
movq %r15, %rdi
vaddsd 0x10(%rsp), %xmm0, %xmm0
shlq $0x5, %rcx
vmovsd %xmm0, 0x8(%rax,%rcx)
callq 0x44ff
vxorpd %xmm1, %xmm1, %xmm1
vfmadd132sd 0xbcc(%rip), %xmm1, %xmm0 # xmm0 = (xmm0 * mem) + xmm1
movslq (%rbx), %rcx
movq 0x10(%r14), %rax
vaddsd 0x18(%rsp), %xmm0, %xmm0
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 0x4419
// File: /workspace/github_cpp_makefile_star2_O3/mniip[P]sandbox/main.cpp
// Function: set_limits()
void set_limits()
{
	dup2(in_pipe[0], 0);
	dup2(out_pipe[1], 1);
	dup2(out_pipe[1], 2);
	close(in_pipe[0]);
	close(in_pipe[1]);
	close(out_pipe[0]);
	close(out_pipe[1]);

	if(conf_closefds)
	{
		DIR *fds = opendir("/proc/self/fd/");
		if(fds)
		{
			struct dirent *dent;
			while(dent = readdir(fds))
				if(atoi(dent->d_name) > 2)
					close(atoi(dent->d_name));
			closedir(fds);
		}
	}

	fflush(stdout);

	if(conf_clearenv)
		clearenv();
	for(std::vector<std::pair<std::string, std::string>>::const_iterator i = conf_setenv.begin(), end = conf_setenv.end(); i != end; i++)
		setenv(i->first.c_str(), i->second.c_str(), 1);
	for(std::vector<std::string>::const_iterator i = conf_unsetenv.begin(), end = conf_unsetenv.end(); i != end; i++)
		unsetenv(i->c_str());

	if(conf_chdir)
		chdir(conf_chdirto.c_str());

	struct rlimit limit;
	for(std::vector<std::pair<int, rlim_t>>::const_iterator i = conf_rlimit.begin(), end = conf_rlimit.end(); i != end; i++)
	{
		limit.rlim_max = limit.rlim_cur = i->second;
		setrlimit(i->first, &limit);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xe56c(%rip), %rbx      # 0x13478
movl (%rbx), %edi
xorl %esi, %esi
callq 0x43b0
leaq 0xe564(%rip), %r14      # 0x13480
movl 0x4(%r14), %edi
movl $0x1, %esi
callq 0x43b0
movl 0x4(%r14), %edi
movl $0x2, %esi
callq 0x43b0
movl (%rbx), %edi
callq 0x47e0
movl 0x4(%rbx), %edi
callq 0x47e0
movl (%r14), %edi
callq 0x47e0
movl 0x4(%r14), %edi
callq 0x47e0
leaq 0xe589(%rip), %rax      # 0x134e8
cmpb $0x1, (%rax)
jne 0x4fa7
leaq 0x958d(%rip), %rdi      # 0xe4f8
callq 0x4610
testq %rax, %rax
je 0x4fa7
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4640
testq %rax, %rax
je 0x4f9f
addq $0x13, %rax
movq %rax, %rdi
callq 0x4670
cmpl $0x3, %eax
jl 0x4f78
movl %eax, %edi
callq 0x47e0
jmp 0x4f78
movq %rbx, %rdi
callq 0x46b0
movq 0xdfda(%rip), %rax      # 0x12f88
movq (%rax), %rdi
callq 0x4470
leaq 0xe52c(%rip), %rax      # 0x134e9
cmpb $0x1, (%rax)
jne 0x4fc7
callq 0x41f0
leaq 0xe522(%rip), %rax      # 0x134f0
movq (%rax), %rbx
movq 0x8(%rax), %r14
cmpq %r14, %rbx
je 0x4ff1
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
movl $0x1, %edx
callq 0x4620
addq $0x40, %rbx
jmp 0x4fd5
leaq 0xe510(%rip), %rax      # 0x13508
movq (%rax), %rbx
movq 0x8(%rax), %r14
cmpq %r14, %rbx
je 0x5012
movq (%rbx), %rdi
callq 0x4550
addq $0x20, %rbx
jmp 0x4fff
leaq 0xe537(%rip), %rax      # 0x13550
cmpb $0x0, (%rax)
je 0x502d
leaq 0xe533(%rip), %rax      # 0x13558
movq (%rax), %rdi
callq 0x4600
leaq 0xe544(%rip), %rax      # 0x13578
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x5064
movq %rsp, %rbx
movq 0x8(%r14), %rax
movq %rax, (%rsp)
movq %rax, 0x8(%rsp)
movl (%r14), %edi
movq %rbx, %rsi
callq 0x4380
addq $0x10, %r14
cmpq %r15, %r14
jne 0x5043
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mniip[P]sandbox/./fs.h
// Function: FsThread<TracedThread>::on_syscall_exit(Sandbox<TracedThread>&)
virtual void on_syscall_exit(Sandbox<T> &s)
	{
		SyscallInfo i(*this);
		if(restore_data.size())
		{
			i.emplace_array((void *)(uintptr_t)restore_addr, restore_data);
			restore_data.clear();
			after_replace_path(true);
		}
		if(ret_override)
		{
			i.ret() = ret_val;
			i.save();
			ret_override = false;
		}
		check_startup();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movq %rdi, %rbx
addq $0x8, %rdi
leaq 0x28(%rsp), %rax
movq %rdi, 0xd8(%rax)
leaq 0xa3c2(%rip), %rcx      # 0x12bd0
movq %rcx, -0x8(%rax)
movw $0x0, 0xe0(%rax)
leaq 0x110(%rsp), %r14
movq %rax, (%r14)
movq $0xd8, 0x8(%r14)
movl $0x1, %esi
movq %r14, %rdx
callq 0xa618
cmpq $0x44, 0x8(%r14)
jne 0x88e7
movw $0x101, 0x108(%rsp)     # imm = 0x101
movl 0x28(%rsp), %eax
movl 0x3c(%rsp), %ecx
movl 0x40(%rsp), %edx
movsd 0x2c(%rsp), %xmm0
xorps %xmm1, %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movups %xmm0, 0x80(%rsp)
movsd 0x34(%rsp), %xmm0
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movups %xmm0, 0x90(%rsp)
movq %rdx, 0x78(%rsp)
movsd 0x44(%rsp), %xmm0
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movups %xmm0, 0xe0(%rsp)
movsd 0x4c(%rsp), %xmm0
movq %rcx, 0x48(%rsp)
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movups %xmm0, 0xf0(%rsp)
movsd 0x54(%rsp), %xmm0
movq %rax, 0x50(%rsp)
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movups %xmm0, 0xa0(%rsp)
movsd 0x5c(%rsp), %xmm0
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movups %xmm0, 0xb0(%rsp)
movsd 0x64(%rsp), %xmm0
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movups %xmm0, 0xc0(%rsp)
jmp 0x88f7
cmpq $0x0, 0x58(%rsp)
jne 0x88f7
movb $0x1, 0x109(%rsp)
movq 0x30(%rbx), %rax
cmpq 0x28(%rbx), %rax
je 0x8959
leaq 0x28(%rbx), %rsi
movq 0x20(%rbx), %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x8d9a
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x8c60
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x893d
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x43e0
movq 0x28(%rbx), %rax
cmpq %rax, 0x30(%rbx)
je 0x894b
movq %rax, 0x30(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x1, %esi
callq *0x70(%rax)
cmpb $0x1, 0x10(%rbx)
jne 0x8975
movq 0x18(%rbx), %rax
leaq 0x20(%rsp), %rdi
movq %rax, 0x58(%rdi)
callq 0x8de6
movb $0x0, 0x10(%rbx)
callq 0xc0e5
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x89a1
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x43e0
movq %rbx, %rdi
callq 0x4770
nop
// File: /workspace/github_cpp_makefile_star2_O3/mniip[P]sandbox/./arch/arch_base.h
// Function: SyscallInfoBase<regs_x86_64, unsigned long>::fetch_cstr(void*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool fetch_cstr(void *addr, std::string &r)
	{
		long word;
		void *read_addr = (void *)((uintptr_t)addr & ~(sizeof word - 1));
		int off = (uintptr_t)addr & (sizeof word - 1);

		r = "";

		if(!thread.ptrace_peekdata(read_addr, word))
			return false;

		uint8_t b;
		do
		{
			b = ((uint8_t *)&word)[off];
			if(b)
				r.push_back(b);
			if(++off == sizeof word)
			{
				off = 0;
				read_addr = (void *)((long *)read_addr + 1);
				if(!thread.ptrace_peekdata(read_addr, word))
					return false;
			}
		}
		while(b);
		return true;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %r15
andq $-0x8, %r15
movq 0x8(%rdx), %rdx
leaq 0x5b65(%rip), %rcx      # 0xe563
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x4660
movq 0xe0(%r14), %rdi
movq %rsp, %rdx
movq %r15, %rsi
callq 0xa598
testb %al, %al
je 0x8a76
andl $0x7, %r12d
movq %rsp, %r13
movslq %r12d, %rax
movb (%rsp,%rax), %bpl
testb %bpl, %bpl
je 0x8a43
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x4360
incl %r12d
cmpl $0x8, %r12d
jne 0x8a69
addq $0x8, %r15
movq 0xe0(%r14), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xa598
xorl %r12d, %r12d
testb %al, %al
je 0x8a73
testb %bpl, %bpl
jne 0x8a2b
movb $0x1, %r13b
jmp 0x8a76
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mniip[P]sandbox/./arch/arch_base.h
// Function: SyscallInfoBase<regs_x86_64, unsigned long>::fetch_array(void*, unsigned long)
std::vector<uint8_t> fetch_array(void *addr, size_t length)
	{
		long word;
		void *read_addr = (void *)((uintptr_t)addr & ~(sizeof word - 1));
		int off = (uintptr_t)addr & (sizeof word - 1);
		
		std::vector<uint8_t> r;
		r.reserve(length);

		if(!thread.ptrace_peekdata(read_addr, word))
			return r;

		uint8_t b;
		for(size_t i = 0; i < length; i++)
		{
			b = ((uint8_t *)&word)[off];
			r.push_back(b);
			if(++off == sizeof word)
			{
				off = 0;
				read_addr = (void *)((long *)read_addr + 1);
				if(!thread.ptrace_peekdata(read_addr, word))
					return r;
			}
		}
		return r;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rcx, %rsi
callq 0x8f70
movq %r13, %r12
andq $-0x8, %r12
movq 0xe0(%r15), %rdi
leaq 0x10(%rsp), %rdx
movq %r12, %rsi
callq 0xa598
testb %al, %al
je 0x8b68
testq %r14, %r14
je 0x8b68
andl $0x7, %r13d
leaq 0x10(%rsp), %rbp
movslq %r13d, %rax
movb 0x10(%rsp,%rax), %al
movb %al, 0xf(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x8b30
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x8b3d
movq %rbx, %rdi
leaq 0xf(%rsp), %rdx
callq 0x9002
incl %r13d
cmpl $0x8, %r13d
jne 0x8b63
addq $0x8, %r12
movq 0xe0(%r15), %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0xa598
xorl %r13d, %r13d
testb %al, %al
je 0x8b68
decq %r14
jne 0x8b13
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8b7c
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8b93
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x43e0
movq %r14, %rdi
callq 0x4770
nop