LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2d92(%rip), %r15      # 0x4085
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 0x1030
movq %r15, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x1030
movq %r15, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x1030
movq %r15, %rdi
movl %r13d, %esi
xorl %eax, %eax
callq 0x1030
movq %r15, %rdi
movl %r12d, %esi
xorl %eax, %eax
callq 0x1030
movl (%rsp), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x1030
movq %r15, %rdi
movl %r14d, %esi
xorl %eax, %eax
callq 0x1030
movl 0x4(%rsp), %esi
leaq 0x2d1e(%rip), %rdi      # 0x408b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2ced(%rip), %rbx      # 0x4085
xorl %r14d, %r14d
vmovaps %ymm0, (%rsp)
cmpq $0x8, %r14
je 0x13bc
movl (%rsp,%r14,4), %esi
movq %rbx, %rdi
xorl %eax, %eax
vzeroupper
callq 0x1030
incq %r14
jmp 0x13a0
pushq $0xa
popq %rdi
vzeroupper
callq 0x1110
leaq -0x10(%rbp), %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2cb5(%rip), %rbx      # 0x4091
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 0x1030
vmovsd 0x8(%rsp), %xmm0
movb $0x1, %al
movq %rbx, %rdi
callq 0x1030
vmovsd 0x10(%rsp), %xmm0
movb $0x1, %al
movq %rbx, %rdi
callq 0x1030
vmovsd 0x18(%rsp), %xmm0
movb $0x1, %al
movq %rbx, %rdi
callq 0x1030
vmovsd 0x20(%rsp), %xmm0
movb $0x1, %al
movq %rbx, %rdi
callq 0x1030
vmovsd 0x28(%rsp), %xmm0
movb $0x1, %al
movq %rbx, %rdi
callq 0x1030
vmovsd 0x30(%rsp), %xmm0
movb $0x1, %al
movq %rbx, %rdi
callq 0x1030
vmovsd 0x38(%rsp), %xmm0
leaq 0x2c01(%rip), %rdi      # 0x407e
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
jmp 0x1030
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2bf2(%rip), %rbx      # 0x4091
xorl %r14d, %r14d
vmovaps %ymm0, (%rsp)
cmpq $0x4, %r14
je 0x14c5
vmovsd (%rsp,%r14,8), %xmm0
movb $0x1, %al
movq %rbx, %rdi
vzeroupper
callq 0x1030
incq %r14
jmp 0x14a7
pushq $0xa
popq %rdi
vzeroupper
callq 0x1110
leaq -0x10(%rbp), %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1040
movq %rax, %r14
subl $0x1, %r12d
jb 0x1506
incl 0x4c43(%rip)            # 0x6144
callq *%r15
jmp 0x14f5
callq 0x1040
subq %r14, %rax
movl $0xf4240, %ecx          # imm = 0xF4240
leaq 0x2b7e(%rip), %rsi      # 0x4098
cqto
idivq %rcx
movq 0x4aaa(%rip), %rcx      # 0x5fd0
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 0x1120
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r15
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r12
leaq 0x2b49(%rip), %rsi      # 0x40ac
leaq 0x8(%rsp), %r13
pushq $0x4
popq %rdx
movq %r13, %rdi
callq 0x1180
pushq $0x4
popq %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x10f0
leaq 0x8(%rsp), %rdi
movl $0x186a00, %edx         # imm = 0x186A00
movq %r15, %rsi
callq 0x10f0
leaq 0x8(%rsp), %rdi
movl $0x2dc6c00, %edx        # imm = 0x2DC6C00
movq %r14, %rsi
callq 0x10f0
leaq 0x8(%rsp), %rdi
movl $0x2dc6c00, %edx        # imm = 0x2DC6C00
movq %rbx, %rsi
callq 0x10f0
leaq 0x8(%rsp), %rdi
callq 0x1050
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x1050
movq %rbx, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0xc(%rsp), %r12
movq %rsi, %r15
movq %rcx, %rbx
movq %rdx, %r14
leaq 0x2aa0(%rip), %rsi      # 0x40ac
leaq 0x10(%rsp), %r13
movl %edi, (%r12)
pushq $0x4
popq %rdx
movq %r13, %rdi
callq 0x10e0
pushq $0x4
popq %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x1100
leaq 0x10(%rsp), %rdi
movl $0x186a00, %edx         # imm = 0x186A00
movq %r15, %rsi
callq 0x1100
leaq 0x10(%rsp), %rdi
movl $0x2dc6c00, %edx        # imm = 0x2DC6C00
movq %r14, %rsi
callq 0x1100
leaq 0x10(%rsp), %rdi
movl $0x2dc6c00, %edx        # imm = 0x2DC6C00
movq %rbx, %rsi
callq 0x1100
leaq 0x10(%rsp), %rdi
callq 0x1130
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0x1130
movq %rbx, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %edi, %eax
sarl $0x1f, %eax
movq %rcx, 0x8(%rsp)
movq %r9, %rbx
movq %r8, 0x10(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movl %edi, %ebp
xorl %ecx, %ecx
andnl %edi, %eax, %eax
cmpq %rcx, %rax
je 0x16f2
andl $0x0, (%r12,%rcx,4)
incq %rcx
jmp 0x16e3
cmpl $0x2, %ebp
pushq $0x1
popq %rax
cmovgel %ebp, %eax
xorl %r14d, %r14d
decl %eax
movl %eax, (%rsp)
cmpl (%rsp), %r14d
je 0x175d
leal 0x1(%r14), %r15d
movl %r15d, 0x4(%rsp)
cmpl %ebp, %r15d
jge 0x1754
movq (%rbx), %rax
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq *0x8(%rax)
vmovsd 0x28da(%rip), %xmm1     # 0x4008
vucomisd %xmm0, %xmm1
jbe 0x174f
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
movl %r14d, %edi
movl %r15d, %esi
movq %r13, %rdx
movq %r12, %rcx
callq 0x1694
incl %r15d
jmp 0x1712
movl 0x4(%rsp), %eax
movl %eax, %r14d
jmp 0x1703
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2923(%rip), %rdi      # 0x40ac
leaq 0x8(%rsp), %rsi
movq %r9, %r13
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
callq 0x10c0
movq 0x484a(%rip), %rdi      # 0x5ff0
testl %eax, %eax
je 0x17e6
leaq 0x2924(%rip), %rsi      # 0x40d5
callq 0x10d0
movq %rax, %rdi
callq 0x1060
movl %ebp, %edi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %r13, %r9
callq 0x16b4
movl (%rbx), %edi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x15e7
jmp 0x180b
leaq 0x28c8(%rip), %rsi      # 0x40b5
callq 0x10d0
movq %rax, %rdi
callq 0x1060
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1540
movq 0x47de(%rip), %rdi      # 0x5ff0
leaq 0x28cb(%rip), %rsi      # 0x40e4
callq 0x10d0
movl (%rbx), %esi
movq %rax, %rdi
callq 0x1150
movq %rax, %rdi
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1060
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
andl $0x0, (%r9)
movq 0x18(%rsp), %rax
cmpl $0x2, %edi
movl $0x1, %r10d
cmovgel %edi, %r10d
xorl %r11d, %r11d
xorl %ebx, %ebx
decl %r10d
cmpq %r11, %r10
je 0x1875
addl (%rdx,%r11,4), %ebx
movl %ebx, 0x4(%r9,%r11,4)
incq %r11
jmp 0x1862
movl %edi, %edx
sarl $0x1f, %edx
xorl %r10d, %r10d
andnl %edi, %edx, %edi
leaq 0x48c7(%rip), %rdx      # 0x6150
shlq $0x2, %rdi
cmpq %r10, %rdi
je 0x189d
andl $0x0, (%r10,%rdx)
addq $0x4, %r10
jmp 0x188d
movl (%rsi), %esi
movl %esi, %edi
sarl $0x1f, %edi
andnl %esi, %edi, %esi
xorl %edi, %edi
cmpq %rdi, %rsi
je 0x18d4
movslq (%rcx,%rdi,4), %r10
movl (%r8,%rdi,4), %r11d
incq %rdi
movslq (%r9,%r10,4), %rbx
movslq (%rdx,%r10,4), %r14
addq %r14, %rbx
movl %r11d, (%rax,%rbx,4)
leal 0x1(%r14), %ebx
movl %ebx, (%rdx,%r10,4)
jmp 0x18ab
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x47ea(%rip), %xmm0     # 0x60d8
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
vdivsd 0x2711(%rip), %xmm0, %xmm0 # 0x4010
vcvttsd2si %xmm0, %r15d
vxorpd %xmm0, %xmm0, %xmm0
movl %r15d, %eax
sarl $0x1f, %eax
vmovsd %xmm0, 0x8(%rsp)
andnl %r15d, %eax, %eax
movl %eax, 0x1c(%rsp)
cmpl 0x1c(%rsp), %r12d
je 0x1a67
vmovsd 0x26e1(%rip), %xmm0     # 0x4010
xorl %r13d, %r13d
vmulsd 0x8(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0x28(%rsp)
vaddsd 0x26d2(%rip), %xmm0, %xmm0 # 0x4018
vmovsd %xmm0, 0x20(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vmovsd %xmm0, 0x10(%rsp)
cmpl %r15d, %r13d
je 0x1a4b
vmovsd 0x10(%rsp), %xmm0
vxorpd %xmm1, %xmm1, %xmm1
movl %r15d, %ebp
vmulsd 0x269c(%rip), %xmm0, %xmm0 # 0x4010
vmovsd %xmm0, 0x38(%rsp)
vaddsd 0x2696(%rip), %xmm0, %xmm0 # 0x4018
vmovsd %xmm0, 0x30(%rsp)
subl $0x1, %ebp
jb 0x1a2f
vmulsd 0x2677(%rip), %xmm1, %xmm0 # 0x4010
vmovsd %xmm1, 0x40(%rsp)
vmovsd 0x38(%rsp), %xmm1
vmovsd 0x28(%rsp), %xmm2
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
vmovsd %xmm0, (%rsp)
callq *(%rax)
vmovsd (%rsp), %xmm0
vmovsd 0x30(%rsp), %xmm1
vmovsd 0x20(%rsp), %xmm2
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
vmovsd (%rsp), %xmm0
vmovsd 0x38(%rsp), %xmm1
vmovsd 0x20(%rsp), %xmm2
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
vaddsd 0x261f(%rip), %xmm0, %xmm0 # 0x4018
vmovsd %xmm0, (%rsp)
callq *(%rax)
vmovsd (%rsp), %xmm0
vmovsd 0x30(%rsp), %xmm1
vmovsd 0x28(%rsp), %xmm2
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
vmovsd 0x40(%rsp), %xmm1
vaddsd 0x25f6(%rip), %xmm1, %xmm1 # 0x4020
jmp 0x1988
vmovsd 0x10(%rsp), %xmm0
incl %r13d
vaddsd 0x25e0(%rip), %xmm0, %xmm0 # 0x4020
vmovsd %xmm0, 0x10(%rsp)
jmp 0x1956
vmovsd 0x8(%rsp), %xmm0
incl %r12d
vaddsd 0x25c4(%rip), %xmm0, %xmm0 # 0x4020
vmovsd %xmm0, 0x8(%rsp)
jmp 0x191c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x325f103(%rip), %rax   # 0x3260b80
pushq $0x10
popq %rcx
leaq 0x18b0c9(%rip), %rsi    # 0x18cb50
leaq 0x19f50f2(%rip), %rdi   # 0x19f6b80
leaq 0xdc00bb(%rip), %r8     # 0xdc1b50
xorl %edx, %edx
cmpq %rax, %rdx
jge 0x1ad4
vmovaps -0x10(%rcx,%rsi), %xmm0
vmovsd (%rcx,%rsi), %xmm1
vmovaps -0x10(%rcx,%r8), %xmm2
incq %rdx
vmovaps %xmm0, -0x20(%rdi,%rcx,2)
vmovsd %xmm1, -0x10(%rdi,%rcx,2)
vmovsd (%rcx,%r8), %xmm1
vmovaps %xmm2, (%rdi,%rcx,2)
vmovsd %xmm1, 0x10(%rdi,%rcx,2)
addq $0x20, %rcx
jmp 0x1a97
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x325f0a4(%rip), %rax   # 0x3260b80
pushq $0x10
popq %rcx
leaq 0x19f509a(%rip), %rsi   # 0x19f6b80
leaq 0x18b063(%rip), %rdi    # 0x18cb50
leaq 0xdc005c(%rip), %r8     # 0xdc1b50
xorl %edx, %edx
cmpq %rax, %rdx
jge 0x1b33
vmovaps -0x20(%rsi,%rcx,2), %xmm0
vmovsd -0x10(%rsi,%rcx,2), %xmm1
vmovaps (%rsi,%rcx,2), %xmm2
incq %rdx
vmovaps %xmm0, -0x10(%rcx,%rdi)
vmovsd %xmm1, (%rcx,%rdi)
vmovsd 0x10(%rsi,%rcx,2), %xmm1
vmovaps %xmm2, -0x10(%rcx,%r8)
vmovsd %xmm1, (%rcx,%r8)
addq $0x20, %rcx
jmp 0x1af6
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
vmovsd 0x24ec(%rip), %xmm0     # 0x4028
vmovsd 0x24ec(%rip), %xmm1     # 0x4030
vmovsd 0x24ec(%rip), %xmm2     # 0x4038
vmovsd 0x24ec(%rip), %xmm3     # 0x4040
movslq 0x325f029(%rip), %rax   # 0x3260b84
leaq 0x33e5a2e(%rip), %rdx   # 0x33e7590
leaq 0x61ac627(%rip), %rsi   # 0x61ae190
leaq 0x18afe0(%rip), %rdi    # 0x18cb50
leaq 0xdbffd9(%rip), %r8     # 0xdc1b50
vxorpd %xmm4, %xmm4, %xmm4
xorl %ecx, %ecx
xorl %r9d, %r9d
cmpq %rax, %r9
jge 0x1c45
movslq (%rcx,%rsi), %r10
movslq (%rcx,%rdx), %r11
vmovapd %xmm0, %xmm9
incq %r9
addq $0x4, %rcx
shlq $0x5, %r10
shlq $0x5, %r11
vmovapd (%r10,%rdi), %xmm6
vmovsd 0x10(%r10,%rdi), %xmm5
vsubpd (%r11,%rdi), %xmm6, %xmm6
vsubsd 0x10(%r11,%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
vfmadd213sd %xmm1, %xmm8, %xmm9 # xmm9 = (xmm8 * xmm9) + xmm1
vmulsd %xmm8, %xmm8, %xmm8
vmulsd %xmm7, %xmm8, %xmm8
vdivsd %xmm8, %xmm9, %xmm8
vmovapd (%r11,%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, (%r11,%r8)
vmovsd 0x10(%r11,%r8), %xmm9
vfmadd231sd %xmm5, %xmm8, %xmm9 # xmm9 = (xmm8 * xmm5) + xmm9
vmovsd %xmm9, 0x10(%r11,%r8)
vfnmadd213pd (%r10,%r8), %xmm7, %xmm6 # xmm6 = -(xmm7 * xmm6) + mem
vmovapd %xmm6, (%r10,%r8)
vfnmadd213sd 0x10(%r10,%r8), %xmm8, %xmm5 # xmm5 = -(xmm8 * xmm5) + mem
vmovsd %xmm5, 0x10(%r10,%r8)
jmp 0x1b80
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
vmovsd 0x2270(%rip), %xmm0     # 0x4028
vmovsd 0x2270(%rip), %xmm1     # 0x4030
vmovsd 0x2270(%rip), %xmm2     # 0x4038
vmovsd 0x2270(%rip), %xmm3     # 0x4040
movl 0x325edaa(%rip), %eax   # 0x3260b80
leaq 0x19f4da3(%rip), %rdx   # 0x19f6b80
leaq 0x325edac(%rip), %rsi   # 0x3260b90
leaq 0x8f72fa5(%rip), %rdi   # 0x8f74d90
leaq 0x90f999e(%rip), %r8    # 0x90fb790
vxorpd %xmm4, %xmm4, %xmm4
movl %eax, %ecx
sarl $0x1f, %ecx
andnl %eax, %ecx, %eax
xorl %ecx, %ecx
cmpq %rax, %rcx
je 0x1f0a
movq %rcx, %r10
shlq $0x6, %r10
movl (%rsi,%rcx,4), %r11d
vxorpd %xmm8, %xmm8, %xmm8
vxorpd %xmm7, %xmm7, %xmm7
vmovapd (%r10,%rdx), %xmm5
vmovsd 0x10(%r10,%rdx), %xmm6
leaq (%rdx,%r10), %r9
movslq (%rdi,%rcx,4), %r10
movl %r11d, %ebx
sarl $0x1f, %ebx
andnl %r11d, %ebx, %r11d
shlq $0x2, %r10
xorl %ebx, %ebx
cmpq %rbx, %r11
je 0x1eea
leaq (%r10,%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 %xmm5, %xmm9, %xmm9
vsubsd %xmm6, %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, %xmm7 # xmm7 = (xmm10 * xmm12) + xmm7
vfmadd231pd %xmm9, %xmm11, %xmm8 # xmm8 = (xmm11 * xmm9) + xmm8
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)
jmp 0x1e45
vaddpd 0x20(%r9), %xmm8, %xmm5
incq %rcx
vmovapd %xmm5, 0x20(%r9)
vaddsd 0x30(%r9), %xmm7, %xmm5
vmovsd %xmm5, 0x30(%r9)
jmp 0x1e02
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/kaityo256[P]lj_simd/force_aos.cpp
// Function: AoSDataManager::print_results(int)
void
    print_results(int particle_number) {
      for (int i = 0; i < 5; i++) {
        printf("%.10f %.10f %.10f\n", p[i][X], p[i][Y], p[i][Z]);
      }
      for (int i = particle_number - 5; i < particle_number; i++) {
        printf("%.10f %.10f %.10f\n", p[i][X], p[i][Y], p[i][Z]);
      }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
pushq $0x10
popq %r12
leaq 0xf80(%rip), %r15       # 0x4072
cmpq $0xb0, %r12
je 0x3123
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 0x1030
addq $0x20, %r12
jmp 0x30f2
leal -0x5(%r14), %eax
movslq %r14d, %r12
leaq 0xf41(%rip), %r14       # 0x4072
movslq %eax, %r15
movq %r15, %r13
shlq $0x5, %r13
orq $0x10, %r13
cmpq %r12, %r15
jge 0x316f
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 0x1030
incq %r15
addq $0x20, %r13
jmp 0x313f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x38, %rsp
vmovsd %xmm2, 0x18(%rsp)
vmovsd %xmm1, 0x10(%rsp)
vmovsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movb 0xbec0575(%rip), %al    # 0xbec3718
testb %al, %al
je 0x323e
vxorpd %xmm0, %xmm0, %xmm0
vmovhpd 0xea1(%rip), %xmm0, %xmm0 # xmm0 = xmm0[0],mem[0]
leaq 0x20(%rsp), %r15
leaq 0xbebf1cd(%rip), %r12   # 0xbec2390
movq %r15, %rdi
movq %r12, %rsi
vmovapd %xmm0, (%r15)
callq 0x32ce
vaddsd 0x8(%rsp), %xmm0, %xmm0
movslq (%rbx), %rcx
movq 0x10(%r14), %rax
movq %r15, %rdi
movq %r12, %rsi
shlq $0x5, %rcx
vmovsd %xmm0, (%rax,%rcx)
callq 0x32ce
vaddsd 0x10(%rsp), %xmm0, %xmm0
movslq (%rbx), %rcx
movq 0x10(%r14), %rax
movq %r15, %rdi
movq %r12, %rsi
shlq $0x5, %rcx
vmovsd %xmm0, 0x8(%rax,%rcx)
callq 0x32ce
vaddsd 0x18(%rsp), %xmm0, %xmm0
movslq (%rbx), %rcx
movq 0x10(%r14), %rax
leal 0x1(%rcx), %edx
shlq $0x5, %rcx
vmovsd %xmm0, 0x10(%rax,%rcx)
movl %edx, (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xbec04d3(%rip), %rdi   # 0xbec3718
callq 0x1170
testl %eax, %eax
je 0x31ab
leaq 0xbebf137(%rip), %rdi   # 0xbec2390
pushq $0x2
popq %rsi
callq 0x32d6
leaq 0xbec04b0(%rip), %rdi   # 0xbec3718
callq 0x1090
jmp 0x31ab
leaq 0xbec049f(%rip), %rdi   # 0xbec3718
movq %rax, %rbx
callq 0x1080
movq %rbx, %rdi
callq 0x1160
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd63c(%rip), %rbx      # 0x12488
movl (%rbx), %edi
xorl %esi, %esi
callq 0x43f0
leaq 0xd634(%rip), %r14      # 0x12490
movl 0x4(%r14), %edi
pushq $0x1
popq %rsi
callq 0x43f0
movl 0x4(%r14), %edi
pushq $0x2
popq %rsi
callq 0x43f0
movl (%rbx), %edi
callq 0x4800
movl 0x4(%rbx), %edi
callq 0x4800
movl (%r14), %edi
callq 0x4800
movl 0x4(%r14), %edi
callq 0x4800
leaq 0xd65d(%rip), %rax      # 0x124f8
cmpb $0x1, (%rax)
jne 0x4ee3
leaq 0x7651(%rip), %rdi      # 0xc4f8
callq 0x4630
testq %rax, %rax
je 0x4ee3
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4650
testq %rax, %rax
je 0x4edb
addq $0x13, %rax
movq %rax, %rdi
callq 0x4670
cmpl $0x3, %eax
jl 0x4eb4
movl %eax, %edi
callq 0x4800
jmp 0x4eb4
movq %rbx, %rdi
callq 0x46b0
movq 0xd0b6(%rip), %rax      # 0x11fa0
movq (%rax), %rdi
callq 0x4480
leaq 0xd600(%rip), %rax      # 0x124f9
cmpb $0x1, (%rax)
jne 0x4f03
callq 0x4230
leaq 0xd5f6(%rip), %rax      # 0x12500
movq (%rax), %r14
movq 0x8(%rax), %r15
pushq $0x1
popq %rbx
cmpq %r15, %r14
je 0x4f2d
movq (%r14), %rdi
movq 0x20(%r14), %rsi
movl %ebx, %edx
callq 0x4640
addq $0x40, %r14
jmp 0x4f14
leaq 0xd5e4(%rip), %rax      # 0x12518
movq (%rax), %rbx
movq 0x8(%rax), %r14
cmpq %r14, %rbx
je 0x4f4e
movq (%rbx), %rdi
callq 0x4580
addq $0x20, %rbx
jmp 0x4f3b
leaq 0xd60b(%rip), %rax      # 0x12560
cmpb $0x0, (%rax)
je 0x4f69
leaq 0xd607(%rip), %rax      # 0x12568
movq (%rax), %rdi
callq 0x4620
leaq 0xd618(%rip), %rax      # 0x12588
movq (%rax), %r14
movq 0x8(%rax), %r15
movq %rsp, %rbx
cmpq %r15, %r14
je 0x4f9d
movq 0x8(%r14), %rax
movq %rax, (%rsp)
movq %rax, 0x8(%rsp)
movl (%r14), %edi
movq %rbx, %rsi
callq 0x43c0
addq $0x10, %r14
jmp 0x4f7a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
leaq 0x8(%rdi), %rsi
leaq 0x20(%rsp), %rdi
callq 0x7688
movq 0x30(%rbx), %rax
cmpq 0x28(%rbx), %rax
je 0x75f2
leaq 0x28(%rbx), %rsi
movq 0x20(%rbx), %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x7b2a
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x7a06
leaq 0x8(%rsp), %rdi
callq 0x765c
movq 0x28(%rbx), %rax
cmpq %rax, 0x30(%rbx)
je 0x75e6
movq %rax, 0x30(%rbx)
movq (%rbx), %rax
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq *0x70(%rax)
cmpb $0x1, 0x10(%rbx)
jne 0x760e
movq 0x18(%rbx), %rax
leaq 0x20(%rsp), %rdi
movq %rax, 0x58(%rdi)
callq 0x7b74
movb $0x0, 0x10(%rbx)
callq 0xa25c
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x765c
movq %rbx, %rdi
callq 0x4770
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq %rsi, 0xe0(%rdi)
leaq 0xa545(%rip), %rcx      # 0x11be8
movq %rcx, (%rdi)
andw $0x0, 0xe8(%rdi)
leaq 0x8(%rdi), %rcx
leaq 0x8(%rsp), %r14
movq %rcx, (%r14)
movq $0xd8, 0x8(%r14)
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x8ff4
cmpq $0x44, 0x8(%r14)
jne 0x7761
movw $0x101, 0xe8(%rbx)      # imm = 0x101
movl 0x8(%rbx), %eax
movl 0x1c(%rbx), %ecx
movl 0x20(%rbx), %edx
movsd 0xc(%rbx), %xmm0
xorps %xmm1, %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movups %xmm0, 0x60(%rbx)
movsd 0x14(%rbx), %xmm0
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movups %xmm0, 0x70(%rbx)
movq %rdx, 0x58(%rbx)
movsd 0x24(%rbx), %xmm0
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movups %xmm0, 0xc0(%rbx)
movsd 0x2c(%rbx), %xmm0
movq %rcx, 0x28(%rbx)
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movups %xmm0, 0xd0(%rbx)
movsd 0x34(%rbx), %xmm0
movq %rax, 0x30(%rbx)
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movups %xmm0, 0x80(%rbx)
movsd 0x3c(%rbx), %xmm0
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movups %xmm0, 0x90(%rbx)
movsd 0x44(%rbx), %xmm0
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movups %xmm0, 0xa0(%rbx)
jmp 0x776f
cmpq $0x0, 0x38(%rbx)
jne 0x776f
movb $0x1, 0xe9(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq %rsi, %rdi
callq *(%rax)
orq $-0x1, (%rax)
movq %r14, %rdi
callq 0x7b74
movb $0x1, 0x10(%r15)
movq %rbx, 0x18(%r15)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rdi, %r15
movq %rsi, %r12
andq $-0x8, %r12
leaq 0x4d8f(%rip), %rsi      # 0xc563
movq %rdx, %rdi
callq 0x47d0
movq 0xe0(%r15), %rdi
movq %rsp, %rdx
movq %r12, %rsi
callq 0x8f7c
testb %al, %al
je 0x7841
andl $0x7, %r14d
movq %rsp, %r13
movslq %r14d, %rax
movb (%rsp,%rax), %bpl
testb %bpl, %bpl
je 0x7811
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x43a0
incl %r14d
cmpl $0x8, %r14d
jne 0x7837
addq $0x8, %r12
movq 0xe0(%r15), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x8f7c
xorl %r14d, %r14d
testb %al, %al
je 0x7844
testb %bpl, %bpl
jne 0x77f9
movb $0x1, %r14b
jmp 0x7844
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
movq %rcx, %rsi
callq 0x7c68
movq %r13, %r12
andq $-0x8, %r12
movq 0xe0(%r15), %rdi
leaq 0x10(%rsp), %rdx
movq %r12, %rsi
callq 0x8f7c
testb %al, %al
je 0x791d
andl $0x7, %r13d
leaq 0xf(%rsp), %rbp
subq $0x1, %r14
jb 0x791d
movslq %r13d, %rax
movb 0x10(%rsp,%rax), %al
movb %al, 0xf(%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x7cf2
incl %r13d
cmpl $0x8, %r13d
jne 0x78d9
addq $0x8, %r12
movq 0xe0(%r15), %rdi
movq %r12, %rsi
leaq 0x10(%rsp), %rdx
callq 0x8f7c
xorl %r13d, %r13d
testb %al, %al
jne 0x78d9
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7931
movq %rax, %r14
movq %rbx, %rdi
callq 0x765c
movq %r14, %rdi
callq 0x4770
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r13
movq %rsi, %r12
andq $-0x8, %r12
movl %r14d, %r15d
andl $0x7, %r15d
je 0x7a49
movq 0xe0(%r13), %rdi
leaq 0x8(%rsp), %rdx
movq %r12, %rsi
callq 0x8f7c
testb %al, %al
je 0x7ae4
movq %r13, 0x10(%rsp)
xorl %r13d, %r13d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
addq %r14, %rcx
cmpq %rcx, %r12
setae %bpl
movl %r15d, %edx
cmpq %rcx, %r12
jae 0x7ae6
movb (%rax,%r13), %sil
incq %r13
movb %sil, 0x8(%rsp,%rdx)
incq %rdx
cmpl $0x8, %edx
jne 0x7a68
movq 0x10(%rsp), %rax
movq 0xe0(%rax), %rdi
movq 0x8(%rsp), %rdx
movq %r12, %rsi
callq 0x8fc0
testb %al, %al
je 0x7ae6
movq 0x8(%rbx), %rax
subq (%rbx), %rax
addq $0x8, %r12
leaq (%r14,%rax), %rcx
xorl %r15d, %r15d
cmpq %rcx, %r12
jae 0x7a51
addq %r14, %rax
addq $-0x8, %rax
cmpq %rax, %r12
jbe 0x7a51
movq 0x10(%rsp), %rax
movq 0xe0(%rax), %rdi
movq %r12, %rsi
leaq 0x8(%rsp), %rdx
callq 0x8f7c
testb %al, %al
jne 0x7a51
jmp 0x7ae6
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
subq $0x58, %rsp
cmpb $0x1, 0xe8(%rdi)
jne 0x7bf5
movl 0x30(%rdi), %eax
leaq 0x10(%rsp), %rcx
movl %eax, (%rcx)
movups 0x60(%rdi), %xmm0
movups 0x70(%rdi), %xmm1
shufps $0x88, %xmm1, %xmm0     # xmm0 = xmm0[0,2],xmm1[0,2]
movups %xmm0, 0x4(%rcx)
movl 0x28(%rdi), %eax
movl %eax, 0x14(%rcx)
movl 0x58(%rdi), %eax
movl %eax, 0x18(%rcx)
movups 0xc0(%rdi), %xmm0
movups 0xd0(%rdi), %xmm1
shufps $0x88, %xmm1, %xmm0     # xmm0 = xmm0[0,2],xmm1[0,2]
movups %xmm0, 0x1c(%rcx)
movups 0x80(%rdi), %xmm0
movups 0x90(%rdi), %xmm1
shufps $0x88, %xmm1, %xmm0     # xmm0 = xmm0[0,2],xmm1[0,2]
movups %xmm0, 0x2c(%rcx)
movdqu 0xa0(%rdi), %xmm0
pshufd $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3]
movq %xmm0, 0x3c(%rcx)
movq %rsp, %rdx
movq %rcx, (%rdx)
movq $0x44, 0x8(%rdx)
jmp 0x7c09
leaq 0x8(%rdi), %rax
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movq $0xd8, 0x8(%rdx)
movq 0xe0(%rdi), %rdi
pushq $0x1
popq %rsi
callq 0x900e
addq $0x58, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mniip[P]sandbox/main.cpp
// Function: TracedThread::can_see_path(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int&)
bool can_see_path(std::string path, int at, int &error)
	{
		std::string canon = canon_path_at(tid, at, path);
		for(std::vector<std::string>::const_iterator i = conf_see.begin(), end = conf_see.end(); i != end; i++)
			if(in_dir(*i, canon))
				return true;
//		if(canon == "/")
//			return true;
		if(conf_report)
			if(at == AT_FDCWD)
				printf("[See %s=%s]\n", path.c_str(), canon.c_str());
			else
				printf("[See (%d)%s=%s]\n", at, path.c_str(), canon.c_str());
		return false;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %edx, %r14d
movl 0x8(%rdi), %ebp
leaq 0x78(%rsp), %rbx
movq %rbx, %rdi
movq %rsi, 0x10(%rsp)
callq 0x4590
leaq 0x18(%rsp), %rdi
movl %ebp, %esi
movl %r14d, 0xc(%rsp)
movl %r14d, %edx
movq %rbx, %rcx
callq 0x91e0
leaq 0x78(%rsp), %rdi
callq 0x4828
leaq 0xa3e3(%rip), %rcx      # 0x12530
movq (%rcx), %rax
movq 0x8(%rcx), %r14
leaq 0x58(%rsp), %r12
leaq 0x38(%rsp), %r13
leaq 0x18(%rsp), %rbx
movq %rax, %r15
cmpq %r14, %rax
je 0x81a9
movq %r12, %rdi
movq %r15, %rsi
callq 0x4590
movq %r13, %rdi
movq %rbx, %rsi
callq 0x4590
movq %r12, %rdi
movq %r13, %rsi
callq 0x972f
movl %eax, %ebp
movq %r13, %rdi
callq 0x4828
movq %r12, %rdi
callq 0x4828
leaq 0x20(%r15), %rax
testb %bpl, %bpl
je 0x8163
jmp 0x81ef
leaq 0xa449(%rip), %rax      # 0x125f9
cmpb $0x1, (%rax)
jne 0x81ef
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movq 0x18(%rsp), %rcx
movl 0xc(%rsp), %esi
cmpl $-0x64, %esi
jne 0x81e1
leaq 0x4451(%rip), %rdi      # 0xc623
movq %rdx, %rsi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x4060
jmp 0x81ef
leaq 0x4448(%rip), %rdi      # 0xc630
xorl %eax, %eax
callq 0x4060
cmpq %r14, %r15
setne %bl
leaq 0x18(%rsp), %rdi
callq 0x4828
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8215
movq %rax, %r14
jmp 0x8236
movq %rax, %r14
jmp 0x822c
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x4828
leaq 0x58(%rsp), %rdi
callq 0x4828
movq %rbx, %rdi
callq 0x4828
movq %r14, %rdi
callq 0x4770
// File: /workspace/github_cpp_makefile_star2_O2/mniip[P]sandbox/main.cpp
// Function: TracedThread::should_replace_stat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, stat&, int, int)
bool should_replace_stat(std::string path, struct stat &st, int at, int flags)
	{
		if(path.compare(0, strlen("http:/"), "http:/") == 0 && path.compare(0, strlen("http://"), "http://") != 0)
			path = "http://" + path.substr(strlen("http:/"));
		else if(path.compare(0, strlen("https:/"), "https:/") == 0 && path.compare(0, strlen("https://"), "https://") != 0)
			path = "https://" + path.substr(strlen("https:/"));
		for(std::vector<std::string>::const_iterator i = conf_http.begin(), end = conf_http.end(); i != end; i++)
			if(path.compare(0, i->size(), *i) == 0)
			{
				st.st_dev = 0;
				st.st_ino = 0;
				st.st_mode = 0755 | S_IFREG;
				st.st_nlink = 1;
				st.st_uid = 0;
				st.st_gid = 0;
				st.st_rdev = 0;
				st.st_size = 0;
				st.st_blksize = 0;
				st.st_blocks = 0;

				clock_gettime(CLOCK_REALTIME, &st.st_mtim);
				st.st_atim = st.st_ctim = st.st_mtim;

				return true;
			}
		return false;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x3dee(%rip), %rcx      # 0xc672
pushq $0x6
popq %rdx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x4540
testl %eax, %eax
je 0x88f9
leaq 0x3de5(%rip), %rcx      # 0xc681
pushq $0x7
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x4540
testl %eax, %eax
jne 0x895d
leaq 0x3dd1(%rip), %rcx      # 0xc689
pushq $0x8
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x4540
testl %eax, %eax
je 0x895d
leaq 0x8(%rsp), %r15
pushq $0x7
popq %rdx
pushq $-0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x4430
leaq 0x3d9f(%rip), %rsi      # 0xc689
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq 0x8a3d
jmp 0x893b
leaq 0x3d79(%rip), %rcx      # 0xc679
pushq $0x7
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x4540
testl %eax, %eax
je 0x8895
leaq 0x8(%rsp), %r15
pushq $0x6
popq %rdx
pushq $-0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x4430
leaq 0x3d4b(%rip), %rsi      # 0xc679
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq 0x8a3d
leaq 0x28(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x44c0
movq %r15, %rdi
callq 0x4828
leaq 0x8(%rsp), %rdi
callq 0x4828
leaq 0x9c3c(%rip), %rax      # 0x125a0
movq (%rax), %rcx
movq 0x8(%rax), %r12
movq %rcx, %r15
cmpq %r12, %rcx
je 0x89c5
movq 0x8(%r15), %rdx
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x4520
leaq 0x20(%r15), %rcx
testl %eax, %eax
jne 0x896b
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movl $0x81ed, 0x18(%rbx)     # imm = 0x81ED
movq $0x1, 0x10(%rbx)
andq $0x0, 0x1c(%rbx)
leaq 0x58(%rbx), %rsi
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
xorl %edi, %edi
callq 0x43e0
movups 0x58(%rbx), %xmm0
movups %xmm0, 0x68(%rbx)
movups %xmm0, 0x48(%rbx)
cmpq %r12, %r15
setne %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x89d9
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4828
movq %rbx, %rdi
callq 0x4770
// File: /workspace/github_cpp_makefile_star2_O2/mniip[P]sandbox/sandbox.cpp
// Function: ThreadData::ptrace(int, void*, void*)
long ThreadData::ptrace(int request, void *addr, void *data)
{
	errno = 0;
	long result = ::ptrace((enum __ptrace_request)request, tid, addr, data);
	if(errno == ESRCH)
		throw ThreadGone(tid);
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
callq 0x4050
movq %rax, %r12
andl $0x0, (%rax)
movl (%rbx), %esi
movl %ebp, %edi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x4390
cmpl $0x3, (%r12)
je 0x8ed9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x18
popq %rdi
callq 0x4220
movq %rax, %r14
movl (%rbx), %esi
movq %rax, %rdi
callq 0x90a4
leaq 0x8e1b(%rip), %rsi      # 0x11d10
movq 0x90d4(%rip), %rdx      # 0x11fd0
movq %r14, %rdi
callq 0x4750
movq %rax, %rbx
movq %r14, %rdi
callq 0x42e0
movq %rbx, %rdi
callq 0x4770
nop
// File: /workspace/github_cpp_makefile_star2_O2/mniip[P]sandbox/sandbox.cpp
// Function: ThreadData::set_options()
void ThreadData::set_options()
{
	if(!set_opts)
	{
		if(!ptrace_setoptions(PTRACE_O_EXITKILL | PTRACE_O_TRACECLONE | PTRACE_O_TRACEEXEC | PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORK))
			panic_errno("ptrace SETOPTIONS");
		set_opts = true;
	}
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
cmpb $0x0, 0x5(%rdi)
jne 0x9048
movq %rdi, %rbx
movl $0x10001e, %esi         # imm = 0x10001E
callq 0x8f18
testb %al, %al
je 0x904e
movb $0x1, 0x5(%rbx)
addq $0x30, %rsp
popq %rbx
retq
leaq 0x386e(%rip), %rsi      # 0xc8c3
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x5422
movq %rbx, %rdi
callq 0x8e3a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4828
movq %rbx, %rdi
callq 0x4770