// File: /workspace/github_cpp_makefile_star2_O3/kaityo256[P]lj_simd/force_aos.cpp
// Function: force_sorted_z_avx2()
void
force_sorted_z_avx2(void) {
  const v4df vzero = _mm256_set1_pd(0.0);
  const v4df vcl2 = _mm256_set1_pd(CL2);
  const v4df vc24 = _mm256_set1_pd(24 * dt);
  const v4df vc48 = _mm256_set1_pd(48 * dt);
  const int pn = particle_number;
  for (int i = 0; i < pn; i++) {
    const v4df vqi = _mm256_load_pd((double *)(z + i));
    v4df vpi = _mm256_load_pd((double *)(&z[i][PX]));
    const int np = number_of_partners[i];
    const int kp = pointer[i];
    for (int k = 0; k < (np / 4) * 4; k += 4) {
      const int j_1 = sorted_list[kp + k];
      const int j_2 = sorted_list[kp + k + 1];
      const int j_3 = sorted_list[kp + k + 2];
      const int j_4 = sorted_list[kp + k + 3];
      v4df vqj_1 = _mm256_load_pd((double *)(&z[j_1][X]));
      v4df vqj_2 = _mm256_load_pd((double *)(&z[j_2][X]));
      v4df vqj_3 = _mm256_load_pd((double *)(&z[j_3][X]));
      v4df vqj_4 = _mm256_load_pd((double *)(&z[j_4][X]));

      v4df vdq_1 = (vqj_1 - vqi);
      v4df vdq_2 = (vqj_2 - vqi);
      v4df vdq_3 = (vqj_3 - vqi);
      v4df vdq_4 = (vqj_4 - vqi);

      v4df tmp0 = _mm256_unpacklo_pd(vdq_1, vdq_2);
      v4df tmp1 = _mm256_unpackhi_pd(vdq_1, vdq_2);
      v4df tmp2 = _mm256_unpacklo_pd(vdq_3, vdq_4);
      v4df tmp3 = _mm256_unpackhi_pd(vdq_3, vdq_4);

      v4df vdx = _mm256_permute2f128_pd(tmp0, tmp2, 0x20);
      v4df vdy = _mm256_permute2f128_pd(tmp1, tmp3, 0x20);
      v4df vdz = _mm256_permute2f128_pd(tmp0, tmp2, 0x31);

      v4df vr2 = vdx * vdx + vdy * vdy + vdz * vdz;
      v4df vr6 = vr2 * vr2 * vr2;
      v4df vdf = (vc24 * vr6 - vc48) / (vr6 * vr6 * vr2);
      v4df mask = vcl2 - vr2;
      vdf = _mm256_blendv_pd(vdf, vzero, mask);

      v4df vdf_1 = _mm256_permute4x64_pd(vdf, 0);
      v4df vdf_2 = _mm256_permute4x64_pd(vdf, 85);
      v4df vdf_3 = _mm256_permute4x64_pd(vdf, 170);
      v4df vdf_4 = _mm256_permute4x64_pd(vdf, 255);

      v4df vpj_1 = _mm256_load_pd((double *)(&z[j_1][PX]));
      v4df vpj_2 = _mm256_load_pd((double *)(&z[j_2][PX]));
      v4df vpj_3 = _mm256_load_pd((double *)(&z[j_3][PX]));
      v4df vpj_4 = _mm256_load_pd((double *)(&z[j_4][PX]));

      vpi += vdq_1 * vdf_1;
      vpi += vdq_2 * vdf_2;
      vpi += vdq_3 * vdf_3;
      vpi += vdq_4 * vdf_4;

      vpj_1 -= vdq_1 * vdf_1;
      vpj_2 -= vdq_2 * vdf_2;
      vpj_3 -= vdq_3 * vdf_3;
      vpj_4 -= vdq_4 * vdf_4;

      _mm256_store_pd((double *)(&z[j_1][PX]), vpj_1);
      _mm256_store_pd((double *)(&z[j_2][PX]), vpj_2);
      _mm256_store_pd((double *)(&z[j_3][PX]), vpj_3);
      _mm256_store_pd((double *)(&z[j_4][PX]), vpj_4);
    }
    _mm256_store_pd((double *)(&z[i][PX]), vpi);
    for (int k = (np / 4) * 4; k < np; k++) {
      const int j = sorted_list[kp + k];
      double dx = z[j][X] - z[i][X];
      double dy = z[j][Y] - z[i][Y];
      double dz = z[j][Z] - z[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;
      z[i][PX] += df * dx;
      z[i][PY] += df * dy;
      z[i][PZ] += df * dz;
      z[j][PX] -= df * dx;
      z[j][PY] -= df * dy;
      z[j][PZ] -= df * dz;
    }
  }
}

// Assembly:
movslq 0x325e07c(%rip), %rax   # 0x3261bc0
testq %rax, %rax
jle 0x3e25
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
vbroadcastsd 0x14e8(%rip), %ymm0 # 0x5048
vbroadcastsd 0x14e6(%rip), %ymm20 # 0x5050
vbroadcastsd 0x14cd(%rip), %ymm2 # 0x5040
vmovsd 0x14ad(%rip), %xmm4     # 0x5028
vmovsd 0x14ad(%rip), %xmm5     # 0x5030
vmovsd 0x14ad(%rip), %xmm6     # 0x5038
vmovsd 0x14ad(%rip), %xmm7     # 0x5040
leaq 0x19f4026(%rip), %rdx   # 0x19f7bc0
leaq 0x90f8c2f(%rip), %r8    # 0x90fc7d0
vxorpd %xmm3, %xmm3, %xmm3
vxorpd %xmm8, %xmm8, %xmm8
xorl %ecx, %ecx
movq %rcx, %rbx
shlq $0x6, %rbx
leaq 0x325e016(%rip), %rsi   # 0x3261bd0
movslq (%rsi,%rcx,4), %r9
vmovapd (%rbx,%rdx), %ymm9
vmovapd 0x20(%rbx,%rdx), %ymm10
leaq 0x8f72200(%rip), %rsi   # 0x8f75dd0
movslq (%rsi,%rcx,4), %r10
leal 0x3(%r9), %r11d
testq %r9, %r9
cmovnsl %r9d, %r11d
andl $-0x4, %r11d
cmpq $0x4, %r9
jl 0x3d31
leaq 0xc(%r8,%r10,4), %r15
movl %r11d, %r14d
xorl %r12d, %r12d
movslq -0xc(%r15,%r12,4), %r13
movslq -0x8(%r15,%r12,4), %rbp
movslq -0x4(%r15,%r12,4), %rsi
movslq (%r15,%r12,4), %rdi
addq $0x4, %r12
shlq $0x6, %r13
shlq $0x6, %rbp
shlq $0x6, %rsi
shlq $0x6, %rdi
vmovapd (%r13,%rdx), %ymm11
vmovapd (%rbp,%rdx), %ymm12
vmovapd (%rsi,%rdx), %ymm13
vmovapd (%rdi,%rdx), %ymm14
vsubpd %ymm9, %ymm11, %ymm11
vsubpd %ymm9, %ymm12, %ymm12
vsubpd %ymm9, %ymm13, %ymm13
vsubpd %ymm9, %ymm14, %ymm14
vinsertf32x4 $0x1, %xmm14, %ymm12, %ymm18
vinsertf32x4 $0x1, %xmm13, %ymm11, %ymm19
vunpcklpd %ymm12, %ymm11, %ymm15 # ymm15 = ymm11[0],ymm12[0],ymm11[2],ymm12[2]
vunpcklpd %ymm14, %ymm13, %ymm16 # ymm16 = ymm13[0],ymm14[0],ymm13[2],ymm14[2]
vinsertf32x4 $0x1, %xmm16, %ymm15, %ymm17
vshuff64x2 $0x3, %ymm16, %ymm15, %ymm15 # ymm15 = ymm15[2,3],ymm16[2,3]
vunpckhpd %ymm18, %ymm19, %ymm18 # ymm18 = ymm19[1],ymm18[1],ymm19[3],ymm18[3]
vmulpd %ymm18, %ymm18, %ymm16
vfmadd231pd %ymm17, %ymm17, %ymm16 # ymm16 = (ymm17 * ymm17) + ymm16
vmovapd %ymm0, %ymm17
vfmadd231pd %ymm15, %ymm15, %ymm16 # ymm16 = (ymm15 * ymm15) + ymm16
vmulpd %ymm16, %ymm16, %ymm15
vsubpd %ymm16, %ymm2, %ymm1
vmulpd %ymm15, %ymm16, %ymm15
vfmadd213pd %ymm20, %ymm15, %ymm17 # ymm17 = (ymm15 * ymm17) + ymm20
vmulpd %ymm15, %ymm15, %ymm15
vmulpd %ymm15, %ymm16, %ymm15
vdivpd %ymm15, %ymm17, %ymm15
vblendvpd %ymm1, %ymm3, %ymm15, %ymm1
vbroadcastsd %xmm1, %ymm15
vpermpd $0x55, %ymm1, %ymm16    # ymm16 = ymm1[1,1,1,1]
vpermpd $0xaa, %ymm1, %ymm17    # ymm17 = ymm1[2,2,2,2]
vpermpd $0xff, %ymm1, %ymm1     # ymm1 = ymm1[3,3,3,3]
vfmadd231pd %ymm15, %ymm11, %ymm10 # ymm10 = (ymm11 * ymm15) + ymm10
vfnmadd213pd 0x20(%r13,%rdx), %ymm11, %ymm15 # ymm15 = -(ymm11 * ymm15) + mem
vfmadd231pd %ymm16, %ymm12, %ymm10 # ymm10 = (ymm12 * ymm16) + ymm10
vfnmadd213pd 0x20(%rbp,%rdx), %ymm12, %ymm16 # ymm16 = -(ymm12 * ymm16) + mem
vfmadd231pd %ymm17, %ymm13, %ymm10 # ymm10 = (ymm13 * ymm17) + ymm10
vfnmadd213pd 0x20(%rsi,%rdx), %ymm13, %ymm17 # ymm17 = -(ymm13 * ymm17) + mem
vfmadd231pd %ymm1, %ymm14, %ymm10 # ymm10 = (ymm14 * ymm1) + ymm10
vfnmadd213pd 0x20(%rdi,%rdx), %ymm14, %ymm1 # ymm1 = -(ymm14 * ymm1) + mem
vmovapd %ymm15, 0x20(%r13,%rdx)
vmovapd %ymm16, 0x20(%rbp,%rdx)
vmovapd %ymm17, 0x20(%rsi,%rdx)
vmovapd %ymm1, 0x20(%rdi,%rdx)
cmpq %r14, %r12
jb 0x3bf8
vmovsd 0x10(%rbx,%rdx), %xmm11
leaq (%rdx,%rbx), %r14
vmovapd %ymm10, 0x20(%r14)
cmpl %r9d, %r11d
jge 0x3e0f
movslq %r11d, %rsi
addq %rsi, %r10
subq %rsi, %r9
xorl %esi, %esi
shlq $0x2, %r10
leaq (%r10,%rsi,4), %rdi
vmovapd %xmm4, %xmm14
incq %rsi
movslq (%r8,%rdi), %rdi
shlq $0x6, %rdi
vmovapd (%rdi,%rdx), %xmm10
vmovsd 0x10(%rdi,%rdx), %xmm1
vsubpd %xmm9, %xmm10, %xmm10
vsubsd %xmm11, %xmm1, %xmm1
vmulpd %xmm10, %xmm10, %xmm12
vshufpd $0x1, %xmm12, %xmm12, %xmm12 # xmm12 = xmm12[1,0]
vfmadd231sd %xmm10, %xmm10, %xmm12 # xmm12 = (xmm10 * xmm10) + xmm12
vfmadd231sd %xmm1, %xmm1, %xmm12 # xmm12 = (xmm1 * xmm1) + xmm12
vmulsd %xmm12, %xmm12, %xmm13
vcmpgtsd %xmm7, %xmm12, %k1
vmulsd %xmm13, %xmm12, %xmm13
vmulsd %xmm13, %xmm13, %xmm15
vfmadd213sd %xmm5, %xmm13, %xmm14 # xmm14 = (xmm13 * xmm14) + xmm5
vmulsd %xmm15, %xmm12, %xmm13
vdivsd %xmm13, %xmm14, %xmm13
vmovapd 0x20(%r14), %xmm14
vmulsd %xmm6, %xmm13, %xmm13
vmovsd %xmm8, %xmm13, %xmm13 {%k1}
vmovddup %xmm13, %xmm12          # xmm12 = xmm13[0,0]
vfmadd231pd %xmm10, %xmm12, %xmm14 # xmm14 = (xmm12 * xmm10) + xmm14
vmovapd %xmm14, 0x20(%r14)
vmovsd 0x30(%r14), %xmm14
vfmadd231sd %xmm1, %xmm13, %xmm14 # xmm14 = (xmm13 * xmm1) + xmm14
vmovsd %xmm14, 0x30(%r14)
vfnmadd213pd 0x20(%rdi,%rdx), %xmm12, %xmm10 # xmm10 = -(xmm12 * xmm10) + mem
vmovapd %xmm10, 0x20(%rdi,%rdx)
vfnmadd213sd 0x30(%rdi,%rdx), %xmm1, %xmm13 # xmm13 = -(xmm1 * xmm13) + mem
vmovsd %xmm13, 0x30(%rdi,%rdx)
cmpq %rsi, %r9
jne 0x3d59
incq %rcx
cmpq %rax, %rcx
jne 0x3bac
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq