LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0xe3a3
movq 0x8(%rsp), %rax
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movaps 0x1161(%rip), %xmm1     # 0xf4d0
pand %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
cvtsi2sdl 0x2c(%rsp), %xmm1
callq 0x21d0
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xe348
movsd 0x18(%rsp), %xmm0
cvtsi2sdl 0x2c(%rsp), %xmm2
movsd 0xc79(%rip), %xmm1      # 0xf030
divsd %xmm2, %xmm1
callq 0x21d0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movb $0x0, 0x2b(%rsp)
movl 0x2c(%rsp), %esi
callq 0xd040
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jg 0xe448
movq (%rsp), %rdi
movl 0x24(%rsp), %esi
movsd 0xc17(%rip), %xmm0      # 0xf030
callq 0xe480
jmp 0xe420
jmp 0xe422
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xe3ff
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0xd170
jmp 0xe467
movb $0x1, 0x2b(%rsp)
testb $0x1, 0x2b(%rsp)
jne 0xe45d
movq (%rsp), %rdi
callq 0xd170
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x21e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0xe310
movl %eax, 0x24(%rsp)
movl $0x1, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x24(%rsp), %eax
jg 0xe52f
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x2060
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
cvtsi2ss %eax, %xmm0
movss 0xb4f(%rip), %xmm1      # 0xf064
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0xe480
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0xe4e1
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xd0d0
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movl 0x28(%rsp), %eax
movl 0x20(%rsp), %eax
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl %ecx, 0x8(%rsp)
movl %r8d, 0x4(%rsp)
movl %r9d, (%rsp)
movl 0x14(%rsp), %esi
leaq 0x7d29(%rip), %rdi      # 0xa089
movb $0x0, %al
callq 0x2030
movl 0x10(%rsp), %esi
leaq 0x7d17(%rip), %rdi      # 0xa089
movb $0x0, %al
callq 0x2030
movl 0xc(%rsp), %esi
leaq 0x7d05(%rip), %rdi      # 0xa089
movb $0x0, %al
callq 0x2030
movl 0x8(%rsp), %esi
leaq 0x7cf3(%rip), %rdi      # 0xa089
movb $0x0, %al
callq 0x2030
movl 0x4(%rsp), %esi
leaq 0x7ce1(%rip), %rdi      # 0xa089
movb $0x0, %al
callq 0x2030
movl (%rsp), %esi
leaq 0x7cd0(%rip), %rdi      # 0xa089
movb $0x0, %al
callq 0x2030
movl 0x20(%rsp), %esi
leaq 0x7cbe(%rip), %rdi      # 0xa089
movb $0x0, %al
callq 0x2030
movl 0x28(%rsp), %esi
leaq 0x7cb2(%rip), %rdi      # 0xa08f
movb $0x0, %al
callq 0x2030
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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
andq $-0x20, %rsp
subq $0x60, %rsp
vmovdqa %ymm0, 0x20(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x8, 0x14(%rsp)
jge 0x2446
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x7c5a(%rip), %rdi      # 0xa089
movb $0x0, %al
vzeroupper
callq 0x2030
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2414
leaq 0x7c61(%rip), %rdi      # 0xa0ae
movb $0x0, %al
vzeroupper
callq 0x2030
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
vmovsd %xmm0, 0x40(%rsp)
vmovsd %xmm1, 0x38(%rsp)
vmovsd %xmm2, 0x30(%rsp)
vmovsd %xmm3, 0x28(%rsp)
vmovsd %xmm4, 0x20(%rsp)
vmovsd %xmm5, 0x18(%rsp)
vmovsd %xmm6, 0x10(%rsp)
vmovsd %xmm7, 0x8(%rsp)
vmovsd 0x40(%rsp), %xmm0
leaq 0x7bf4(%rip), %rdi      # 0xa095
movb $0x1, %al
callq 0x2030
vmovsd 0x38(%rsp), %xmm0
leaq 0x7be0(%rip), %rdi      # 0xa095
movb $0x1, %al
callq 0x2030
vmovsd 0x30(%rsp), %xmm0
leaq 0x7bcc(%rip), %rdi      # 0xa095
movb $0x1, %al
callq 0x2030
vmovsd 0x28(%rsp), %xmm0
leaq 0x7bb8(%rip), %rdi      # 0xa095
movb $0x1, %al
callq 0x2030
vmovsd 0x20(%rsp), %xmm0
leaq 0x7ba4(%rip), %rdi      # 0xa095
movb $0x1, %al
callq 0x2030
vmovsd 0x18(%rsp), %xmm0
leaq 0x7b90(%rip), %rdi      # 0xa095
movb $0x1, %al
callq 0x2030
vmovsd 0x10(%rsp), %xmm0
leaq 0x7b7c(%rip), %rdi      # 0xa095
movb $0x1, %al
callq 0x2030
vmovsd 0x8(%rsp), %xmm0
leaq 0x7b55(%rip), %rdi      # 0xa082
movb $0x1, %al
callq 0x2030
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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
andq $-0x20, %rsp
subq $0x60, %rsp
vmovapd %ymm0, 0x20(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x4, 0x14(%rsp)
jge 0x2598
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
vmovsd (%rax,%rcx,8), %xmm0
leaq 0x7b14(%rip), %rdi      # 0xa095
movb $0x1, %al
vzeroupper
callq 0x2030
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2564
leaq 0x7b0f(%rip), %rdi      # 0xa0ae
movb $0x0, %al
vzeroupper
callq 0x2030
movq %rbp, %rsp
popq %rbp
retq
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
callq 0x2040
movq %rax, 0x28(%rsp)
movl $0x64, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
cmpl $0x64, 0x20(%rsp)
jge 0x2603
movl 0x9b5b(%rip), %eax      # 0xc144
addl $0x1, %eax
movl %eax, 0x9b52(%rip)      # 0xc144
callq *0x40(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x25dc
callq 0x2040
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x8cd0
movq %rax, (%rsp)
movq %rsp, %rdi
callq 0x8ca0
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x8d20
movq %rax, 0x10(%rsp)
movq 0x998d(%rip), %rax      # 0xbfd0
movq (%rax), %rdi
movl 0x34(%rsp), %edx
movq 0x38(%rsp), %rcx
movq 0x10(%rsp), %r8
leaq 0x7a41(%rip), %rsi      # 0xa09c
movb $0x0, %al
callq 0x2110
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x248, %rsp            # imm = 0x248
movq %rdi, 0x240(%rsp)
movq %rsi, 0x238(%rsp)
movq %rdx, 0x230(%rsp)
movq %rcx, 0x228(%rsp)
leaq 0x7a12(%rip), %rsi      # 0xa0b0
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x4, %edx
callq 0x2180
movq 0x8(%rsp), %rdi
movq 0x240(%rsp), %rsi
movl $0x4, %edx
callq 0x20f0
jmp 0x26cb
movq 0x238(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movl $0x186a00, %edx         # imm = 0x186A00
callq 0x20f0
jmp 0x26e4
movq 0x230(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movl $0x2dc6c00, %edx        # imm = 0x2DC6C00
callq 0x20f0
jmp 0x26fd
movq 0x228(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movl $0x2dc6c00, %edx        # imm = 0x2DC6C00
callq 0x20f0
jmp 0x2716
leaq 0x20(%rsp), %rdi
callq 0x2050
addq $0x248, %rsp            # imm = 0x248
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2050
movq 0x18(%rsp), %rdi
callq 0x2160
nopw (%rax,%rax)
// File: 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:
subq $0x238, %rsp            # imm = 0x238
movl %edi, 0x234(%rsp)
movq %rsi, 0x228(%rsp)
movq %rdx, 0x220(%rsp)
movq %rcx, 0x218(%rsp)
leaq 0x7933(%rip), %rsi      # 0xa0b0
leaq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x4, %edx
callq 0x20e0
movq (%rsp), %rdi
leaq 0x234(%rsp), %rsi
movl $0x4, %edx
callq 0x2100
jmp 0x27a8
movq 0x228(%rsp), %rsi
leaq 0x18(%rsp), %rdi
movl $0x186a00, %edx         # imm = 0x186A00
callq 0x2100
jmp 0x27c1
movq 0x220(%rsp), %rsi
leaq 0x18(%rsp), %rdi
movl $0x2dc6c00, %edx        # imm = 0x2DC6C00
callq 0x2100
jmp 0x27da
movq 0x218(%rsp), %rsi
leaq 0x18(%rsp), %rdi
movl $0x2dc6c00, %edx        # imm = 0x2DC6C00
callq 0x2100
jmp 0x27f3
leaq 0x18(%rsp), %rdi
callq 0x2120
addq $0x238, %rsp            # imm = 0x238
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x2120
movq 0x10(%rsp), %rdi
callq 0x2160
nopw (%rax,%rax)
// File: kaityo256[P]lj_simd/./conf.hpp
// Function: register_pair(int, int, int&, int*, int*, int*)
void
register_pair(int index1, int index2, int &number_of_pairs, int number_of_partners[N], int i_particles[MAX_PAIRS], int j_particles[MAX_PAIRS]) {
  int i, j;
  if (index1 < index2) {
    i = index1;
    j = index2;
  } else {
    i = index2;
    j = index1;
  }
  i_particles[number_of_pairs] = i;
  j_particles[number_of_pairs] = j;
  number_of_partners[i]++;
  number_of_pairs++;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movq %rdx, -0x10(%rsp)
movq %rcx, -0x18(%rsp)
movq %r8, -0x20(%rsp)
movq %r9, -0x28(%rsp)
movl -0x4(%rsp), %eax
cmpl -0x8(%rsp), %eax
jge 0x2868
movl -0x4(%rsp), %eax
movl %eax, -0x2c(%rsp)
movl -0x8(%rsp), %eax
movl %eax, -0x30(%rsp)
jmp 0x2878
movl -0x8(%rsp), %eax
movl %eax, -0x2c(%rsp)
movl -0x4(%rsp), %eax
movl %eax, -0x30(%rsp)
movl -0x2c(%rsp), %edx
movq -0x20(%rsp), %rax
movq -0x10(%rsp), %rcx
movslq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x30(%rsp), %edx
movq -0x28(%rsp), %rax
movq -0x10(%rsp), %rcx
movslq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rsp), %rax
movslq -0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
retq
// File: 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:
subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
vmovsd 0x771f(%rip), %xmm0     # 0xa008
vmovsd %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x54(%rsp), %eax
jge 0x291f
movq 0x40(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x28f7
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl 0x54(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x29ba
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x54(%rsp), %eax
jge 0x29a8
movq 0x28(%rsp), %rdi
movl 0x18(%rsp), %esi
movl 0x14(%rsp), %edx
movq (%rdi), %rax
callq *0x8(%rax)
vmovsd %xmm0, 0x8(%rsp)
vmovsd 0x7698(%rip), %xmm0     # 0xa008
vucomisd 0x8(%rsp), %xmm0
jbe 0x2999
movl 0x18(%rsp), %edi
movl 0x14(%rsp), %esi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x30(%rsp), %r9
callq 0x2830
jmp 0x299b
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2945
jmp 0x29aa
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x2927
addq $0x58, %rsp
retq
nop
// File: 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:
subq $0xc8, %rsp
movl %edi, 0xc4(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rcx, 0xa8(%rsp)
movq %r8, 0xa0(%rsp)
movq %r9, 0x98(%rsp)
leaq 0x76b3(%rip), %rdi      # 0xa0b0
leaq 0x8(%rsp), %rsi
callq 0x20b0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x2a5b
movq 0x95d7(%rip), %rdi      # 0xbff0
leaq 0x7699(%rip), %rsi      # 0xa0b9
callq 0x20c0
movq %rax, %rdi
movq 0x9591(%rip), %rsi      # 0xbfc0
callq 0x20d0
movq 0xb8(%rsp), %rdi
movq 0xb0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
movq 0xa0(%rsp), %rcx
callq 0x2670
jmp 0x2ad8
movq 0x958e(%rip), %rdi      # 0xbff0
leaq 0x7670(%rip), %rsi      # 0xa0d9
callq 0x20c0
movq %rax, %rdi
movq 0x9548(%rip), %rsi      # 0xbfc0
callq 0x20d0
movl 0xc4(%rsp), %edi
movq 0xb8(%rsp), %rsi
movq 0xb0(%rsp), %rdx
movq 0xa8(%rsp), %rcx
movq 0xa0(%rsp), %r8
movq 0x98(%rsp), %r9
callq 0x28c0
movq 0xb8(%rsp), %rax
movl (%rax), %edi
movq 0xb0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
movq 0xa0(%rsp), %rcx
callq 0x2750
movq 0x9511(%rip), %rdi      # 0xbff0
leaq 0x7602(%rip), %rsi      # 0xa0e8
callq 0x20c0
movq %rax, %rdi
movq 0xb8(%rsp), %rax
movl (%rax), %esi
callq 0x2140
movq %rax, %rdi
movq 0x94b9(%rip), %rsi      # 0xbfc0
callq 0x20d0
addq $0xc8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
movq 0x8(%rsp), %rax
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq %r9, -0x30(%rsp)
movl $0x0, -0x34(%rsp)
movq -0x30(%rsp), %rax
movl $0x0, (%rax)
movl $0x0, -0x38(%rsp)
movl -0x38(%rsp), %eax
movl -0x4(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2ba4
movq -0x18(%rsp), %rax
movslq -0x38(%rsp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x34(%rsp), %eax
movl %eax, -0x34(%rsp)
movl -0x34(%rsp), %edx
movq -0x30(%rsp), %rax
movl -0x38(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rsp)
jmp 0x2b5d
movl $0x0, -0x3c(%rsp)
movl -0x3c(%rsp), %eax
cmpl -0x4(%rsp), %eax
jge 0x2bd6
movslq -0x3c(%rsp), %rcx
leaq 0x958e(%rip), %rax      # 0xc150
movl $0x0, (%rax,%rcx,4)
movl -0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rsp)
jmp 0x2bac
movq -0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, -0x40(%rsp)
movl $0x0, -0x44(%rsp)
movl -0x44(%rsp), %eax
cmpl -0x40(%rsp), %eax
jge 0x2c72
movq -0x20(%rsp), %rax
movslq -0x44(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x48(%rsp)
movq -0x28(%rsp), %rax
movslq -0x44(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4c(%rsp)
movq -0x30(%rsp), %rax
movslq -0x48(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movslq -0x48(%rsp), %rdx
leaq 0x9522(%rip), %rcx      # 0xc150
addl (%rcx,%rdx,4), %eax
movl %eax, -0x50(%rsp)
movl -0x4c(%rsp), %edx
movq 0x8(%rsp), %rax
movslq -0x50(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movslq -0x48(%rsp), %rcx
leaq 0x94fe(%rip), %rax      # 0xc150
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
leaq 0x94f1(%rip), %rax      # 0xc150
movl %edx, (%rax,%rcx,4)
movl -0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rsp)
jmp 0x2be9
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
vmovsd 0x738a(%rip), %xmm0     # 0xa020
vmovsd 0x738a(%rip), %xmm1     # 0xa028
callq 0x2150
vmovaps %xmm0, %xmm1
vmovsd 0x7369(%rip), %xmm0     # 0xa018
vdivsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, 0x40(%rsp)
vmovsd 0x734f(%rip), %xmm0     # 0xa010
vmulsd 0x40(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0x38(%rsp)
vmovsd 0x9403(%rip), %xmm0     # 0xc0d8
vdivsd 0x40(%rsp), %xmm0, %xmm0
vcvttsd2si %xmm0, %eax
movl %eax, 0x34(%rsp)
vmovsd 0x93ed(%rip), %xmm0     # 0xc0d8
vdivsd 0x40(%rsp), %xmm0, %xmm0
vcvttsd2si %xmm0, %eax
movl %eax, 0x30(%rsp)
vmovsd 0x93d7(%rip), %xmm0     # 0xc0d8
vdivsd 0x40(%rsp), %xmm0, %xmm0
vcvttsd2si %xmm0, %eax
movl %eax, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x2e63
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x30(%rsp), %eax
jge 0x2e51
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0x2e3f
vcvtsi2sdl 0x20(%rsp), %xmm0, %xmm0
vmulsd 0x40(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0x18(%rsp)
vcvtsi2sdl 0x24(%rsp), %xmm0, %xmm0
vmulsd 0x40(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0x10(%rsp)
vcvtsi2sdl 0x28(%rsp), %xmm0, %xmm0
vmulsd 0x40(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0x8(%rsp)
movq 0x50(%rsp), %rdi
vmovsd 0x18(%rsp), %xmm0
vmovsd 0x10(%rsp), %xmm1
vmovsd 0x8(%rsp), %xmm2
movq 0x48(%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
movq 0x50(%rsp), %rdi
vmovsd 0x18(%rsp), %xmm0
vmovsd 0x10(%rsp), %xmm1
vaddsd 0x38(%rsp), %xmm1, %xmm1
vmovsd 0x8(%rsp), %xmm2
vaddsd 0x38(%rsp), %xmm2, %xmm2
movq 0x48(%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
movq 0x50(%rsp), %rdi
vmovsd 0x18(%rsp), %xmm0
vaddsd 0x38(%rsp), %xmm0, %xmm0
vmovsd 0x10(%rsp), %xmm1
vmovsd 0x8(%rsp), %xmm2
vaddsd 0x38(%rsp), %xmm2, %xmm2
movq 0x48(%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
movq 0x50(%rsp), %rdi
vmovsd 0x18(%rsp), %xmm0
vaddsd 0x38(%rsp), %xmm0, %xmm0
vmovsd 0x10(%rsp), %xmm1
vaddsd 0x38(%rsp), %xmm1, %xmm1
vmovsd 0x8(%rsp), %xmm2
movq 0x48(%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x2d43
jmp 0x2e41
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x2d2d
jmp 0x2e53
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x2d17
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: 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:
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
cmpl 0x3263cfe(%rip), %eax   # 0x3266b80
jge 0x2fb5
movslq -0x4(%rsp), %rcx
leaq 0x18fcbc(%rip), %rax    # 0x192b50
shlq $0x5, %rcx
addq %rcx, %rax
vmovsd (%rax), %xmm0
movslq -0x4(%rsp), %rcx
leaq 0x19f9cd5(%rip), %rax   # 0x19fcb80
shlq $0x6, %rcx
addq %rcx, %rax
vmovsd %xmm0, (%rax)
movslq -0x4(%rsp), %rcx
leaq 0x18fc8e(%rip), %rax    # 0x192b50
shlq $0x5, %rcx
addq %rcx, %rax
vmovsd 0x8(%rax), %xmm0
movslq -0x4(%rsp), %rcx
leaq 0x19f9ca6(%rip), %rax   # 0x19fcb80
shlq $0x6, %rcx
addq %rcx, %rax
vmovsd %xmm0, 0x8(%rax)
movslq -0x4(%rsp), %rcx
leaq 0x18fc5e(%rip), %rax    # 0x192b50
shlq $0x5, %rcx
addq %rcx, %rax
vmovsd 0x10(%rax), %xmm0
movslq -0x4(%rsp), %rcx
leaq 0x19f9c76(%rip), %rax   # 0x19fcb80
shlq $0x6, %rcx
addq %rcx, %rax
vmovsd %xmm0, 0x10(%rax)
movslq -0x4(%rsp), %rcx
leaq 0xdc4c2e(%rip), %rax    # 0xdc7b50
shlq $0x5, %rcx
addq %rcx, %rax
vmovsd (%rax), %xmm0
movslq -0x4(%rsp), %rcx
leaq 0x19f9c47(%rip), %rax   # 0x19fcb80
shlq $0x6, %rcx
addq %rcx, %rax
vmovsd %xmm0, 0x20(%rax)
movslq -0x4(%rsp), %rcx
leaq 0xdc4bff(%rip), %rax    # 0xdc7b50
shlq $0x5, %rcx
addq %rcx, %rax
vmovsd 0x8(%rax), %xmm0
movslq -0x4(%rsp), %rcx
leaq 0x19f9c17(%rip), %rax   # 0x19fcb80
shlq $0x6, %rcx
addq %rcx, %rax
vmovsd %xmm0, 0x28(%rax)
movslq -0x4(%rsp), %rcx
leaq 0xdc4bcf(%rip), %rax    # 0xdc7b50
shlq $0x5, %rcx
addq %rcx, %rax
vmovsd 0x10(%rax), %xmm0
movslq -0x4(%rsp), %rcx
leaq 0x19f9be7(%rip), %rax   # 0x19fcb80
shlq $0x6, %rcx
addq %rcx, %rax
vmovsd %xmm0, 0x30(%rax)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x2e78
retq
nopw %cs:(%rax,%rax)
// File: 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:
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
cmpl 0x3263bae(%rip), %eax   # 0x3266b80
jge 0x3105
movslq -0x4(%rsp), %rcx
leaq 0x19f9b9c(%rip), %rax   # 0x19fcb80
shlq $0x6, %rcx
addq %rcx, %rax
vmovsd (%rax), %xmm0
movslq -0x4(%rsp), %rcx
leaq 0x18fb55(%rip), %rax    # 0x192b50
shlq $0x5, %rcx
addq %rcx, %rax
vmovsd %xmm0, (%rax)
movslq -0x4(%rsp), %rcx
leaq 0x19f9b6e(%rip), %rax   # 0x19fcb80
shlq $0x6, %rcx
addq %rcx, %rax
vmovsd 0x8(%rax), %xmm0
movslq -0x4(%rsp), %rcx
leaq 0x18fb26(%rip), %rax    # 0x192b50
shlq $0x5, %rcx
addq %rcx, %rax
vmovsd %xmm0, 0x8(%rax)
movslq -0x4(%rsp), %rcx
leaq 0x19f9b3e(%rip), %rax   # 0x19fcb80
shlq $0x6, %rcx
addq %rcx, %rax
vmovsd 0x10(%rax), %xmm0
movslq -0x4(%rsp), %rcx
leaq 0x18faf6(%rip), %rax    # 0x192b50
shlq $0x5, %rcx
addq %rcx, %rax
vmovsd %xmm0, 0x10(%rax)
movslq -0x4(%rsp), %rcx
leaq 0x19f9b0e(%rip), %rax   # 0x19fcb80
shlq $0x6, %rcx
addq %rcx, %rax
vmovsd 0x20(%rax), %xmm0
movslq -0x4(%rsp), %rcx
leaq 0xdc4ac6(%rip), %rax    # 0xdc7b50
shlq $0x5, %rcx
addq %rcx, %rax
vmovsd %xmm0, (%rax)
movslq -0x4(%rsp), %rcx
leaq 0x19f9adf(%rip), %rax   # 0x19fcb80
shlq $0x6, %rcx
addq %rcx, %rax
vmovsd 0x28(%rax), %xmm0
movslq -0x4(%rsp), %rcx
leaq 0xdc4a97(%rip), %rax    # 0xdc7b50
shlq $0x5, %rcx
addq %rcx, %rax
vmovsd %xmm0, 0x8(%rax)
movslq -0x4(%rsp), %rcx
leaq 0x19f9aaf(%rip), %rax   # 0x19fcb80
shlq $0x6, %rcx
addq %rcx, %rax
vmovsd 0x30(%rax), %xmm0
movslq -0x4(%rsp), %rcx
leaq 0xdc4a67(%rip), %rax    # 0xdc7b50
shlq $0x5, %rcx
addq %rcx, %rax
vmovsd %xmm0, 0x10(%rax)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x2fc8
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x18(%rsp)
cmpl $0x5, 0x18(%rsp)
jge 0x8e04
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movslq 0x18(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
vmovsd (%rcx), %xmm0
movq 0x8(%rax), %rcx
movslq 0x18(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
vmovsd 0x8(%rcx), %xmm1
movq 0x8(%rax), %rax
movslq 0x18(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
vmovsd 0x10(%rax), %xmm2
leaq 0x1286(%rip), %rdi      # 0xa076
movb $0x3, %al
callq 0x2030
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x8d9f
movl 0x1c(%rsp), %eax
subl $0x5, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x8e77
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movslq 0x14(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
vmovsd (%rcx), %xmm0
movq 0x8(%rax), %rcx
movslq 0x14(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
vmovsd 0x8(%rcx), %xmm1
movq 0x8(%rax), %rax
movslq 0x14(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
vmovsd 0x10(%rax), %xmm2
leaq 0x1213(%rip), %rdi      # 0xa076
movb $0x3, %al
callq 0x2030
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x8e0f
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
vmovsd %xmm0, 0x58(%rsp)
vmovsd %xmm1, 0x50(%rsp)
vmovsd %xmm2, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpb $0x0, 0xbec0727(%rip)   # 0xbec9718
jne 0x9023
leaq 0xbec071e(%rip), %rdi   # 0xbec9718
callq 0x2170
cmpl $0x0, %eax
je 0x9023
leaq 0xbebf385(%rip), %rdi   # 0xbec8390
movl $0x2, %esi
callq 0x9220
jmp 0x9017
leaq 0xbec06fa(%rip), %rdi   # 0xbec9718
callq 0x2080
leaq 0x20(%rsp), %rdi
vpxor %xmm0, %xmm0, %xmm0
vmovsd 0x1024(%rip), %xmm1     # 0xa058
callq 0x9250
vmovsd 0x58(%rsp), %xmm0
vmovsd %xmm0, (%rsp)
leaq 0x20(%rsp), %rdi
leaq 0xbebf340(%rip), %rsi   # 0xbec8390
callq 0x9280
movq 0x18(%rsp), %rax
vmovaps %xmm0, %xmm1
vmovsd (%rsp), %xmm0
vaddsd %xmm1, %xmm0, %xmm0
movq 0x10(%rax), %rax
movq 0x40(%rsp), %rcx
movslq (%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
vmovsd %xmm0, (%rax)
vmovsd 0x50(%rsp), %xmm0
vmovsd %xmm0, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0xbebf2fa(%rip), %rsi   # 0xbec8390
callq 0x9280
movq 0x18(%rsp), %rax
vmovaps %xmm0, %xmm1
vmovsd 0x8(%rsp), %xmm0
vaddsd %xmm1, %xmm0, %xmm0
movq 0x10(%rax), %rax
movq 0x40(%rsp), %rcx
movslq (%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
vmovsd %xmm0, 0x8(%rax)
vmovsd 0x48(%rsp), %xmm0
vmovsd %xmm0, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0xbebf2b2(%rip), %rsi   # 0xbec8390
callq 0x9280
movq 0x18(%rsp), %rax
vmovaps %xmm0, %xmm1
vmovsd 0x10(%rsp), %xmm0
vaddsd %xmm1, %xmm0, %xmm0
movq 0x10(%rax), %rax
movq 0x40(%rsp), %rcx
movslq (%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
vmovsd %xmm0, 0x10(%rax)
movq 0x40(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0xbec05e4(%rip), %rdi   # 0xbec9718
callq 0x2070
movq 0x38(%rsp), %rdi
callq 0x2160
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movslq -0xc(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
vmovsd (%rcx), %xmm0
movq 0x10(%rax), %rcx
movslq -0x10(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
vsubsd (%rcx), %xmm0, %xmm0
vmovsd %xmm0, -0x18(%rsp)
movq 0x10(%rax), %rcx
movslq -0xc(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
vmovsd 0x8(%rcx), %xmm0
movq 0x10(%rax), %rcx
movslq -0x10(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
vsubsd 0x8(%rcx), %xmm0, %xmm0
vmovsd %xmm0, -0x20(%rsp)
movq 0x10(%rax), %rcx
movslq -0xc(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
vmovsd 0x10(%rcx), %xmm0
movq 0x10(%rax), %rax
movslq -0x10(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
vsubsd 0x10(%rax), %xmm0, %xmm0
vmovsd %xmm0, -0x28(%rsp)
vmovsd -0x18(%rsp), %xmm0
vmovsd -0x18(%rsp), %xmm2
vmovsd -0x20(%rsp), %xmm1
vmulsd -0x20(%rsp), %xmm1, %xmm1
vfmadd213sd %xmm1, %xmm0, %xmm2 # xmm2 = (xmm0 * xmm2) + xmm1
vmovsd -0x28(%rsp), %xmm1
vmovsd -0x28(%rsp), %xmm0
vfmadd213sd %xmm2, %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + xmm2
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x130(%rbp)
addq $0x8, %rsi
leaq -0x100(%rbp), %rdi
callq 0xcc00
movq -0x130(%rbp), %rdi
addq $0x28, %rdi
callq 0xd1c0
cmpq $0x0, %rax
je 0xc86d
movq -0x130(%rbp), %rsi
movq 0x20(%rsi), %rax
movq %rax, -0x140(%rbp)
addq $0x28, %rsi
leaq -0x118(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0xd680
movq -0x140(%rbp), %rsi
movq -0x138(%rbp), %rdx
leaq -0x100(%rbp), %rdi
callq 0xd410
jmp 0xc81d
leaq -0x118(%rbp), %rdi
callq 0x90a0
movq -0x130(%rbp), %rdi
addq $0x28, %rdi
callq 0xd770
movq -0x130(%rbp), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x70(%rax)
jmp 0xc86d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x90a0
jmp 0xc8c7
movq -0x130(%rbp), %rax
testb $0x1, 0x10(%rax)
je 0xc8b9
movq -0x130(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x148(%rbp)
leaq -0x100(%rbp), %rdi
callq 0xda60
movq -0x148(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x100(%rbp), %rdi
callq 0xd790
movq -0x130(%rbp), %rax
movb $0x0, 0x10(%rax)
callq 0x155d0
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
movq -0x120(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mniip[P]sandbox/./arch/x86_64.h
// Function: SyscallInfo::SyscallInfo(ThreadData&)
inline SyscallInfo(ThreadData &thread):
		SyscallInfoBase(thread, false),
		is_compat_regset(false),
		is_compat_table(false)
	{
		struct iovec iov = { .iov_base = (void *)&regs, .iov_len = sizeof regs };
		thread.ptrace_getregset(NT_PRSTATUS, iov);
		if(iov.iov_len == sizeof(regs_x86_32))
		{
			is_compat_regset = true;
			is_compat_table = true;
			struct regs_x86_32 tmp;
			memcpy(&tmp, &regs, sizeof tmp);

			regs.rbx = tmp.ebx;
			regs.rcx = tmp.ecx;
			regs.rdx = tmp.edx;
			regs.rsi = tmp.esi;
			regs.rdi = tmp.edi;
			regs.rbp = tmp.ebp;
			regs.rax = tmp.eax;
			regs.ds = tmp.ds;
			regs.es = tmp.es;
			regs.fs = tmp.fs;
			regs.gs = tmp.gs;
			regs.orig_rax = tmp.orig_eax;
			regs.rip = tmp.eip;
			regs.cs = tmp.cs;
			regs.eflags = tmp.eflags;
			regs.rsp = tmp.esp;
			regs.ss = tmp.ss;
		}
		else if(!regs.r11)
		{
			is_compat_table = true;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0xda20
movq -0x70(%rbp), %rax
leaq 0x19f22(%rip), %rcx     # 0x26b50
addq $0x10, %rcx
movq %rcx, (%rax)
movb $0x0, 0xe8(%rax)
movb $0x0, 0xe9(%rax)
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq $0xd8, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq -0x20(%rbp), %rdx
callq 0x133e0
cmpq $0x44, -0x18(%rbp)
jne 0xcd2f
movq -0x70(%rbp), %rsi
movb $0x1, 0xe8(%rsi)
movb $0x1, 0xe9(%rsi)
addq $0x8, %rsi
leaq -0x64(%rbp), %rdi
movl $0x44, %edx
callq 0x5400
movq -0x70(%rbp), %rax
movl -0x64(%rbp), %ecx
movq %rcx, 0x30(%rax)
movl -0x60(%rbp), %ecx
movq %rcx, 0x60(%rax)
movl -0x5c(%rbp), %ecx
movq %rcx, 0x68(%rax)
movl -0x58(%rbp), %ecx
movq %rcx, 0x70(%rax)
movl -0x54(%rbp), %ecx
movq %rcx, 0x78(%rax)
movl -0x50(%rbp), %ecx
movq %rcx, 0x28(%rax)
movl -0x4c(%rbp), %ecx
movq %rcx, 0x58(%rax)
movl -0x48(%rbp), %ecx
movq %rcx, 0xc0(%rax)
movl -0x44(%rbp), %ecx
movq %rcx, 0xc8(%rax)
movl -0x40(%rbp), %ecx
movq %rcx, 0xd0(%rax)
movl -0x3c(%rbp), %ecx
movq %rcx, 0xd8(%rax)
movl -0x38(%rbp), %ecx
movq %rcx, 0x80(%rax)
movl -0x34(%rbp), %ecx
movq %rcx, 0x88(%rax)
movl -0x30(%rbp), %ecx
movq %rcx, 0x90(%rax)
movl -0x2c(%rbp), %ecx
movq %rcx, 0x98(%rax)
movl -0x28(%rbp), %ecx
movq %rcx, 0xa0(%rax)
movl -0x24(%rbp), %ecx
movq %rcx, 0xa8(%rax)
jmp 0xcd47
movq -0x70(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0xcd45
movq -0x70(%rbp), %rax
movb $0x1, 0xe9(%rax)
jmp 0xcd47
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: mniip[P]sandbox/./fs.h
// Function: FsThread<TracedThread>::block(SyscallInfo&, long)
void block(SyscallInfo &i, long val)
	{
		i.sysnum() = -1;
		i.save();
		ret_override = true;
		ret_val = val;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq $-0x1, (%rax)
movq -0x10(%rbp), %rdi
callq 0xd790
movq -0x20(%rbp), %rax
movb $0x1, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
andq $-0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
andq $0x7, %rax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rdi
leaq 0xf2a1(%rip), %rsi      # 0x1c09f
callq 0x56d0
movq -0x40(%rbp), %rax
movq 0xe0(%rax), %rdi
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x13330
testb $0x1, %al
jne 0xce25
movb $0x0, -0x1(%rbp)
jmp 0xce99
jmp 0xce27
movslq -0x34(%rbp), %rax
movb -0x28(%rbp,%rax), %al
movb %al, -0x35(%rbp)
cmpb $0x0, -0x35(%rbp)
je 0xce45
movq -0x20(%rbp), %rdi
movsbl -0x35(%rbp), %esi
callq 0x5440
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
cltq
cmpq $0x8, %rax
jne 0xce8d
movq -0x40(%rbp), %rax
movl $0x0, -0x34(%rbp)
movq -0x30(%rbp), %rcx
addq $0x8, %rcx
movq %rcx, -0x30(%rbp)
movq 0xe0(%rax), %rdi
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x13330
testb $0x1, %al
jne 0xce8b
movb $0x0, -0x1(%rbp)
jmp 0xce99
jmp 0xce8d
jmp 0xce8f
cmpb $0x0, -0x35(%rbp)
jne 0xce27
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: mniip[P]sandbox/./arch/x86_64.h
// Function: SyscallInfo::arg(int)
virtual inline uint64_t &arg(int arg)
	{
		if(is_compat_table)
			switch(arg)
			{
				case 1: return regs.rbx;
				case 2: return regs.rcx;
				case 3: return regs.rdx;
				case 4: return regs.rsi;
				case 5: return regs.rdi;
				case 6: return regs.rbp;
			}
		else
			switch(arg)
			{
				case 1: return regs.rdi;
				case 2: return regs.rsi;
				case 3: return regs.rdx;
				case 4: return regs.r10;
				case 5: return regs.r8;
				case 6: return regs.r9;
			}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0xe9(%rax)
je 0xcf7b
movl -0x14(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x5, %eax
ja 0xcf76
movq -0x28(%rbp), %rax
leaq 0xf12d(%rip), %rcx      # 0x1c01c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
addq $0x8, %rax
addq $0x28, %rax
movq %rax, -0x8(%rbp)
jmp 0xd013
movq -0x20(%rbp), %rax
addq $0x8, %rax
addq $0x58, %rax
movq %rax, -0x8(%rbp)
jmp 0xd013
movq -0x20(%rbp), %rax
addq $0x8, %rax
addq $0x60, %rax
movq %rax, -0x8(%rbp)
jmp 0xd013
movq -0x20(%rbp), %rax
addq $0x8, %rax
addq $0x68, %rax
movq %rax, -0x8(%rbp)
jmp 0xd013
movq -0x20(%rbp), %rax
addq $0x8, %rax
addq $0x70, %rax
movq %rax, -0x8(%rbp)
jmp 0xd013
movq -0x20(%rbp), %rax
addq $0x8, %rax
addq $0x20, %rax
movq %rax, -0x8(%rbp)
jmp 0xd013
jmp 0xd011
movl -0x14(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x5, %eax
ja 0xd00f
movq -0x30(%rbp), %rax
leaq 0xf06a(%rip), %rcx      # 0x1c004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
addq $0x8, %rax
addq $0x70, %rax
movq %rax, -0x8(%rbp)
jmp 0xd013
movq -0x20(%rbp), %rax
addq $0x8, %rax
addq $0x68, %rax
movq %rax, -0x8(%rbp)
jmp 0xd013
movq -0x20(%rbp), %rax
addq $0x8, %rax
addq $0x60, %rax
movq %rax, -0x8(%rbp)
jmp 0xd013
movq -0x20(%rbp), %rax
addq $0x8, %rax
addq $0x38, %rax
movq %rax, -0x8(%rbp)
jmp 0xd013
movq -0x20(%rbp), %rax
addq $0x8, %rax
addq $0x48, %rax
movq %rax, -0x8(%rbp)
jmp 0xd013
movq -0x20(%rbp), %rax
addq $0x8, %rax
addq $0x40, %rax
movq %rax, -0x8(%rbp)
jmp 0xd013
jmp 0xd011
ud2
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
andq $-0x8, %rax
movq %rax, -0x30(%rbp)
movl -0x18(%rbp), %eax
andl $0x7, %eax
movl %eax, -0x34(%rbp)
movb $0x0, -0x35(%rbp)
callq 0xda80
movq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xdaa0
jmp 0xd09b
movq -0x68(%rbp), %rax
movq 0xe0(%rax), %rdi
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x13330
movb %al, -0x71(%rbp)
jmp 0xd0b8
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0xd0eb
jmp 0xd0c1
movb $0x1, -0x35(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0xd192
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x90a0
jmp 0xd1ae
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xd187
movq -0x60(%rbp), %rdi
movslq -0x34(%rbp), %rax
movb -0x28(%rbp,%rax), %al
movb %al, -0x49(%rbp)
leaq -0x49(%rbp), %rsi
callq 0xdb80
jmp 0xd11b
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
cltq
cmpq $0x8, %rax
jne 0xd174
movq -0x68(%rbp), %rax
movl $0x0, -0x34(%rbp)
movq -0x30(%rbp), %rcx
addq $0x8, %rcx
movq %rcx, -0x30(%rbp)
movq 0xe0(%rax), %rdi
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x13330
movb %al, -0x72(%rbp)
jmp 0xd15c
movb -0x72(%rbp), %al
testb $0x1, %al
jne 0xd172
jmp 0xd165
movb $0x1, -0x35(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0xd192
jmp 0xd174
jmp 0xd176
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0xd0f3
movb $0x1, -0x35(%rbp)
movl $0x1, -0x48(%rbp)
testb $0x1, -0x35(%rbp)
jne 0xd1a1
movq -0x60(%rbp), %rdi
callq 0x90a0
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x58f0
nopw (%rax,%rax)
// File: mniip[P]sandbox/./arch/arch_base.h
// Function: SyscallInfoBase<regs_x86_64, unsigned long>::emplace_array(void*, std::vector<unsigned char, std::allocator<unsigned char>>)
bool emplace_array(void *addr, std::vector<uint8_t> array)
	{
		long word;
		void *write_addr = (void *)((uintptr_t)addr & ~(sizeof word - 1));
		int off = (uintptr_t)addr & (sizeof word - 1);

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

		size_t i = 0;
		while(write_addr < (char *)addr + array.size())
		{
			((uint8_t *)&word)[off] = array[i++];
			if(++off == sizeof word)
			{
				off = 0;
				if(!thread.ptrace_pokedata(write_addr, word))
					return false;
				write_addr = (void *)((long *)write_addr + 1);
				if(write_addr < (char *)addr + array.size() && write_addr > (char *)addr + array.size() - 8)
					if(!thread.ptrace_peekdata(write_addr, word))
						return false;
			}
		}
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
andq $-0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
andq $0x7, %rax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0xd477
movq -0x48(%rbp), %rax
movq 0xe0(%rax), %rdi
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x13330
testb $0x1, %al
jne 0xd475
movb $0x0, -0x1(%rbp)
jmp 0xd5a9
jmp 0xd477
movq $0x0, -0x40(%rbp)
movq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0xd1c0
movq -0x60(%rbp), %rcx
movq %rax, %rdx
movq -0x58(%rbp), %rax
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0xd5a5
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
callq 0xeb90
movb (%rax), %cl
movslq -0x34(%rbp), %rax
movb %cl, -0x28(%rbp,%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
cltq
cmpq $0x8, %rax
jne 0xd5a0
movq -0x48(%rbp), %rax
movl $0x0, -0x34(%rbp)
movq 0xe0(%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x13390
testb $0x1, %al
jne 0xd512
movb $0x0, -0x1(%rbp)
jmp 0xd5a9
movq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0xd1c0
movq -0x70(%rbp), %rcx
movq %rax, %rdx
movq -0x68(%rbp), %rax
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0xd59e
movq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0xd1c0
movq -0x80(%rbp), %rcx
movq %rax, %rdx
movq -0x78(%rbp), %rax
addq %rdx, %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
jbe 0xd59e
movq -0x48(%rbp), %rax
movq 0xe0(%rax), %rdi
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x13330
testb $0x1, %al
jne 0xd59c
movb $0x0, -0x1(%rbp)
jmp 0xd5a9
jmp 0xd59e
jmp 0xd5a0
jmp 0xd47f
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mniip[P]sandbox/./arch/x86_64.h
// Function: SyscallInfo::save()
bool save()
    {
		if(is_compat_regset)
		{
			struct regs_x86_32 tmp;
			tmp.ebx = regs.rbx;
			tmp.ecx = regs.rcx;
			tmp.edx = regs.rdx;
			tmp.esi = regs.rsi;
			tmp.edi = regs.rdi;
			tmp.ebp = regs.rbp;
			tmp.eax = regs.rax;
			tmp.ds = regs.ds;
			tmp.es = regs.es;
			tmp.fs = regs.fs;
			tmp.gs = regs.gs;
			tmp.orig_eax = regs.orig_rax;
			tmp.eip = regs.rip;
			tmp.cs = regs.cs;
			tmp.eflags = regs.eflags;
			tmp.esp = regs.rsp;
			tmp.ss = regs.ss;
			struct iovec iov = { .iov_base = (void *)&tmp, .iov_len = sizeof tmp };
			return thread.ptrace_setregset(NT_PRSTATUS, iov);
		}
		else
		{
			struct iovec iov = { .iov_base = (void *)&regs, .iov_len = sizeof regs };
			return thread.ptrace_setregset(NT_PRSTATUS, iov);
		}
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
testb $0x1, 0xe8(%rax)
je 0xd879
movq -0x80(%rbp), %rax
movq 0x30(%rax), %rcx
movl %ecx, -0x54(%rbp)
movq 0x60(%rax), %rcx
movl %ecx, -0x50(%rbp)
movq 0x68(%rax), %rcx
movl %ecx, -0x4c(%rbp)
movq 0x70(%rax), %rcx
movl %ecx, -0x48(%rbp)
movq 0x78(%rax), %rcx
movl %ecx, -0x44(%rbp)
movq 0x28(%rax), %rcx
movl %ecx, -0x40(%rbp)
movq 0x58(%rax), %rcx
movl %ecx, -0x3c(%rbp)
movq 0xc0(%rax), %rcx
movl %ecx, -0x38(%rbp)
movq 0xc8(%rax), %rcx
movl %ecx, -0x34(%rbp)
movq 0xd0(%rax), %rcx
movl %ecx, -0x30(%rbp)
movq 0xd8(%rax), %rcx
movl %ecx, -0x2c(%rbp)
movq 0x80(%rax), %rcx
movl %ecx, -0x28(%rbp)
movq 0x88(%rax), %rcx
movl %ecx, -0x24(%rbp)
movq 0x90(%rax), %rcx
movl %ecx, -0x20(%rbp)
movq 0x98(%rax), %rcx
movl %ecx, -0x1c(%rbp)
movq 0xa0(%rax), %rcx
movl %ecx, -0x18(%rbp)
movq 0xa8(%rax), %rcx
movl %ecx, -0x14(%rbp)
leaq -0x54(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movq $0x44, -0x60(%rbp)
movq 0xe0(%rax), %rdi
movl $0x1, %esi
leaq -0x68(%rbp), %rdx
callq 0x13420
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xd8aa
movq -0x80(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x78(%rbp)
movq $0xd8, -0x70(%rbp)
movq 0xe0(%rax), %rdi
movl $0x1, %esi
leaq -0x78(%rbp), %rdx
callq 0x13420
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)