void make_nh123_real(const int norb, const double *h4e, double *nh1e,
                     double *nh2e, double *nh3e) {
  const int twon = 2 * norb;
  const int s2 = twon * twon;
  const int s3 = s2 * twon;
  const int s4 = s3 * twon;
  const int s5 = s4 * twon;
  const int s6 = s5 * twon;
  const int s7 = s6 * twon;
  for (int i = 0; i < twon; ++i)
    for (int j = 0; j < twon; ++j)
      for (int k = 0; k < twon; ++k) {
        for (int xx = 0; xx < twon; ++xx)
          for (int yy = 0; yy < twon; ++yy) {
            nh1e[xx * twon + yy] -= h4e[xx * s7 + j * s6 + i * s5 + k * s4 +
                                        j * s3 + i * s2 + k * twon + yy];
          }
      }
#pragma omp parallel for schedule(static) collapse(2)
  for (int i = 0; i < twon; ++i)
    for (int j = 0; j < twon; ++j)
      for (int k = 0; k < twon; ++k) {
        double *temp2 = nh2e + i * s3 + j * s2;
        double *temp3 = nh3e + i * s5 + j * s4 + k * s3;
        for (int l = 0; l < twon; ++l) {
          const double *h4jlik = h4e + j * s7 + l * s6 + i * s5 + k * s4;
          const double *h4ijlk = h4e + i * s7 + j * s6 + l * s5 + k * s4;
          const double *h4ilkj = h4e + i * s7 + l * s6 + k * s5 + j * s4;
          const double *h4ikjl = h4e + i * s7 + k * s6 + j * s5 + l * s4;
          const double *h4jikl = h4e + j * s7 + i * s6 + k * s5 + l * s4;
          const double *h4ijkl = h4e + i * s7 + j * s6 + k * s5 + l * s4;
          for (int xx = 0; xx < twon; ++xx)
            for (int yy = 0; yy < twon; ++yy) {
              double temp;
              const int o1 = l * s3 + k * s2 + xx * twon + yy;
              temp = h4jlik[o1];
              temp += h4ijlk[o1];
              temp += h4ilkj[o1];
              temp += h4jikl[o1];
              const int o2 = k * s3 + xx * s2 + l * twon + yy;
              temp += h4ikjl[o2];
              temp += h4jikl[o2];
              const int o3 = xx * s3 + k * s2 + l * twon + yy;
              temp += h4ijkl[o3];
              temp2[xx * twon + yy] += temp;
            }
          const double *h4kijl = h4e + k * s7 + i * s6 + j * s5 + l * s4;
          const double *h4jilk = h4e + j * s7 + i * s6 + l * s5 + k * s4;
          const double *h4iljk = h4e + i * s7 + l * s6 + j * s5 + k * s4;
          for (int xx = 0; xx < twon; ++xx)
            for (int yy = 0; yy < twon; ++yy)
              for (int zz = 0; zz < twon; ++zz) {
                const int o1 = l * s3 + xx * s2 + yy * twon + zz;
                double temp;
                temp = h4kijl[o1];
                temp += h4jilk[o1];
                temp += h4iljk[o1];
                const int o2 = xx * s3 + l * s2 + yy * twon + zz;
                temp += h4ikjl[o2];
                temp += h4ijlk[o2];
                const int o3 = xx * s3 + yy * s2 + l * twon + zz;
                temp += h4ijkl[o3];
                temp3[xx * s2 + yy * twon + zz] += temp;
              }
        }
      }
}


x86 assembly (clang, -O0):
<make_nh123_real>:
push   %rbp
mov    %rsp,%rbp
sub    $0x88,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
imul   -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
imul   -0x2c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
imul   -0x2c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
imul   -0x2c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
imul   -0x2c(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1287 <make_nh123_real+0x187>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1274 <make_nh123_real+0x174>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1261 <make_nh123_real+0x161>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    124e <make_nh123_real+0x14e>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    123b <make_nh123_real+0x13b>
mov    -0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x44(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
mov    -0x48(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
mov    -0x50(%rbp),%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
mov    -0x4c(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
mov    -0x48(%rbp),%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
mov    -0x50(%rbp),%edx
imul   -0x2c(%rbp),%edx
add    %edx,%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    11b6 <make_nh123_real+0xb6>
jmp    1240 <make_nh123_real+0x140>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    11a3 <make_nh123_real+0xa3>
jmp    1253 <make_nh123_real+0x153>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1190 <make_nh123_real+0x90>
jmp    1266 <make_nh123_real+0x166>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    117d <make_nh123_real+0x7d>
jmp    1279 <make_nh123_real+0x179>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    116a <make_nh123_real+0x6a>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1a49 <make_nh123_real+0x949>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1a36 <make_nh123_real+0x936>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1a23 <make_nh123_real+0x923>
mov    -0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x34(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x60(%rbp),%ecx
imul   -0x30(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x60(%rbp),%ecx
imul   -0x38(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x64(%rbp),%ecx
imul   -0x34(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1a10 <make_nh123_real+0x910>
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0x44(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x7c(%rbp),%ecx
imul   -0x40(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x5c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x64(%rbp),%ecx
imul   -0x38(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x44(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x60(%rbp),%ecx
imul   -0x40(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x7c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x64(%rbp),%ecx
imul   -0x38(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x44(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x7c(%rbp),%ecx
imul   -0x40(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x64(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x60(%rbp),%ecx
imul   -0x38(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x44(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x64(%rbp),%ecx
imul   -0x40(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x60(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x7c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0x44(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x5c(%rbp),%ecx
imul   -0x40(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x64(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x7c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x44(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x60(%rbp),%ecx
imul   -0x40(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x64(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x7c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb0(%rbp)
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    16ff <make_nh123_real+0x5ff>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    16e6 <make_nh123_real+0x5e6>
mov    -0x7c(%rbp),%eax
imul   -0x34(%rbp),%eax
mov    -0x64(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    %ecx,%eax
mov    -0xb4(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    %ecx,%eax
add    -0xb8(%rbp),%eax
mov    %eax,-0xc4(%rbp)
mov    -0x88(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x90(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x98(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0xa8(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x64(%rbp),%eax
imul   -0x34(%rbp),%eax
mov    -0xb4(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    %ecx,%eax
mov    -0x7c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    %ecx,%eax
add    -0xb8(%rbp),%eax
mov    %eax,-0xc8(%rbp)
mov    -0xa0(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0xa8(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0xb4(%rbp),%eax
imul   -0x34(%rbp),%eax
mov    -0x64(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    %ecx,%eax
mov    -0x7c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    %ecx,%eax
add    -0xb8(%rbp),%eax
mov    %eax,-0xcc(%rbp)
mov    -0xb0(%rbp),%rax
movslq -0xcc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x70(%rbp),%rax
mov    -0xb4(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0xb8(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    1535 <make_nh123_real+0x435>
jmp    16eb <make_nh123_real+0x5eb>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    151c <make_nh123_real+0x41c>
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
imul   -0x44(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x5c(%rbp),%ecx
imul   -0x40(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x60(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x7c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0x44(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x5c(%rbp),%ecx
imul   -0x40(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x7c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x64(%rbp),%ecx
imul   -0x38(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x44(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x7c(%rbp),%ecx
imul   -0x40(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x60(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x64(%rbp),%ecx
imul   -0x38(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
movl   $0x0,-0xec(%rbp)
mov    -0xec(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    19fd <make_nh123_real+0x8fd>
movl   $0x0,-0xf0(%rbp)
mov    -0xf0(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    19e4 <make_nh123_real+0x8e4>
movl   $0x0,-0xf4(%rbp)
mov    -0xf4(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    19cb <make_nh123_real+0x8cb>
mov    -0x7c(%rbp),%eax
imul   -0x34(%rbp),%eax
mov    -0xec(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    %ecx,%eax
mov    -0xf0(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    %ecx,%eax
add    -0xf4(%rbp),%eax
mov    %eax,-0xf8(%rbp)
mov    -0xd8(%rbp),%rax
movslq -0xf8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0xe0(%rbp),%rax
movslq -0xf8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0xe8(%rbp),%rax
movslq -0xf8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0xec(%rbp),%eax
imul   -0x34(%rbp),%eax
mov    -0x7c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    %ecx,%eax
mov    -0xf0(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    %ecx,%eax
add    -0xf4(%rbp),%eax
mov    %eax,-0x104(%rbp)
mov    -0xa0(%rbp),%rax
movslq -0x104(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x90(%rbp),%rax
movslq -0x104(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0xec(%rbp),%eax
imul   -0x34(%rbp),%eax
mov    -0xf0(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    %ecx,%eax
mov    -0x7c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    %ecx,%eax
add    -0xf4(%rbp),%eax
mov    %eax,-0x108(%rbp)
mov    -0xb0(%rbp),%rax
movslq -0x108(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
mov    -0x78(%rbp),%rax
mov    -0xec(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0xf0(%rbp),%edx
imul   -0x2c(%rbp),%edx
add    %edx,%ecx
add    -0xf4(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf4(%rbp)
jmp    1828 <make_nh123_real+0x728>
jmp    19d0 <make_nh123_real+0x8d0>
mov    -0xf0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf0(%rbp)
jmp    180f <make_nh123_real+0x70f>
jmp    19e9 <make_nh123_real+0x8e9>
mov    -0xec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xec(%rbp)
jmp    17f6 <make_nh123_real+0x6f6>
jmp    1a02 <make_nh123_real+0x902>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    132c <make_nh123_real+0x22c>
jmp    1a15 <make_nh123_real+0x915>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    12b4 <make_nh123_real+0x1b4>
jmp    1a28 <make_nh123_real+0x928>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    12a1 <make_nh123_real+0x1a1>
jmp    1a3b <make_nh123_real+0x93b>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    128e <make_nh123_real+0x18e>
add    $0x88,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<make_nh123_real>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x3f0,%rsp
mov    %r8,0x158(%rsp)
mov    %rcx,0x198(%rsp)
test   %edi,%edi
jle    2918 <make_nh123_real+0x1818>
mov    %rdx,%r11
lea    (%rdi,%rdi,1),%eax
mov    %eax,%r8d
imul   %r8d,%r8d
mov    %r8d,%r9d
imul   %eax,%r9d
mov    %r9d,%r15d
imul   %eax,%r15d
mov    %r15d,%r10d
imul   %eax,%r10d
mov    %r10d,%edx
imul   %eax,%edx
mov    %edx,%r14d
imul   %eax,%r14d
cmp    $0x2,%eax
mov    $0x1,%ecx
cmovge %eax,%ecx
mov    %edi,%ebp
imul   %edi,%ebp
mov    %ebp,%ebx
mov    %rdi,0xe8(%rsp)
imul   %edi,%ebx
mov    %ebp,-0x14(%rsp)
mov    %ebp,%edi
imul   %edi,%edi
mov    %ebx,0x54(%rsp)
imul   %ebx,%edi
shl    $0x7,%edi
mov    %rdi,-0x80(%rsp)
mov    %ecx,%edi
and    $0x7ffffffc,%edi
mov    %rdi,0x18(%rsp)
add    $0xfffffffffffffffc,%rdi
mov    %rdi,0x10(%rsp)
mov    %rdi,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
mov    %rbx,%rdi
mov    %rbx,0x8(%rsp)
and    $0xfffffffffffffffe,%rbx
mov    %rbx,-0x20(%rsp)
mov    %rcx,%rdi
neg    %rdi
mov    %rdi,-0x40(%rsp)
mov    %r15,0xe0(%rsp)
lea    (%r15,%rax,1),%edi
mov    %r9,0x28(%rsp)
mov    %rdx,-0x8(%rsp)
lea    (%rdx,%r9,1),%ebp
mov    %r8,0x120(%rsp)
mov    %r10,(%rsp)
add    %r8d,%r10d
mov    %r14d,%r8d
mov    %rax,0x130(%rsp)
movslq %eax,%r9
lea    -0x1(%rcx),%r15
lea    (%rsi,%rcx,8),%rax
mov    %rax,-0x48(%rsp)
lea    0x30(%r11),%rax
mov    %rax,0x98(%rsp)
mov    %r9,0x1a0(%rsp)
lea    0x0(,%r9,8),%rax
mov    %rax,0x1a8(%rsp)
lea    0x8(%r11),%rax
mov    %rax,0x90(%rsp)
mov    $0x4,%r9d
xor    %r14d,%r14d
xor    %eax,%eax
mov    %rsi,0xb8(%rsp)
mov    %rcx,0x20(%rsp)
mov    %r11,0x128(%rsp)
mov    %r8d,-0x38(%rsp)
mov    %r15,0x40(%rsp)
mov    %rdi,0x38(%rsp)
mov    %rbp,0x110(%rsp)
mov    %r10,0xf0(%rsp)
jmp    12b2 <make_nh123_real+0x1b2>
nop
mov    0xf8(%rsp),%rax
add    $0x1,%rax
mov    0xf0(%rsp),%r10
mov    0x108(%rsp),%r9d
add    %r10d,%r9d
mov    0x100(%rsp),%r14
add    %r10,%r14
cmp    %ecx,%eax
je     1620 <make_nh123_real+0x520>
mov    %r14d,%ebx
add    $0x1,%rbx
mov    %rax,%rdx
imul   %r10,%rdx
mov    %rdx,0x30(%rsp)
mov    %rax,0xf8(%rsp)
imul   %r10d,%eax
mov    %eax,0x118(%rsp)
mov    %r14,0x100(%rsp)
mov    %r9d,0x108(%rsp)
xor    %eax,%eax
jmp    1327 <make_nh123_real+0x227>
nopl   0x0(%rax)
mov    0x70(%rsp),%rax
add    $0x1,%rax
mov    0x110(%rsp),%rbp
mov    0x78(%rsp),%r9d
add    %ebp,%r9d
mov    0x88(%rsp),%rbx
add    %rbp,%rbx
mov    0x80(%rsp),%r14
add    %rbp,%r14
cmp    %ecx,%eax
je     1280 <make_nh123_real+0x180>
mov    %rax,%rdx
imul   %rbp,%rdx
add    0x30(%rsp),%rdx
mov    %rdx,-0x28(%rsp)
mov    %rax,0x70(%rsp)
imul   %ebp,%eax
add    0x118(%rsp),%eax
mov    %eax,-0x30(%rsp)
mov    %r14,0x80(%rsp)
mov    %rbx,0x88(%rsp)
mov    %rbx,%rbp
mov    %r9d,0x78(%rsp)
xor    %eax,%eax
jmp    139e <make_nh123_real+0x29e>
nopw   0x0(%rax,%rax,1)
mov    -0x78(%rsp),%rax
add    $0x1,%rax
mov    0x38(%rsp),%rdi
mov    -0x60(%rsp),%r9d
add    %edi,%r9d
mov    -0x58(%rsp),%rbp
add    %rdi,%rbp
mov    -0x50(%rsp),%r14
add    %rdi,%r14
cmp    %ecx,%eax
je     12f0 <make_nh123_real+0x1f0>
mov    %rax,%rdx
imul   %rdi,%rdx
add    -0x28(%rsp),%rdx
mov    %rdx,-0x70(%rsp)
mov    %rax,-0x78(%rsp)
imul   %edi,%eax
add    -0x30(%rsp),%eax
mov    %eax,-0x68(%rsp)
mov    0x90(%rsp),%r12
mov    %r14,-0x50(%rsp)
mov    %rbp,-0x58(%rsp)
mov    0x98(%rsp),%rdi
mov    %r9d,-0x60(%rsp)
xor    %r10d,%r10d
jmp    1419 <make_nh123_real+0x319>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r10
add    %r8d,%r9d
mov    0x1a8(%rsp),%rax
add    %rax,%rdi
mov    -0x80(%rsp),%rdx
add    %rdx,%rbp
add    %rdx,%r14
add    %rax,%r12
cmp    %rcx,%r10
je     1370 <make_nh123_real+0x270>
mov    %r10,%r15
imul   0x1a0(%rsp),%r15
mov    %r8d,%r13d
imul   %r10d,%r13d
add    -0x68(%rsp),%r13d
cmp    $0x4,%ecx
jae    14b0 <make_nh123_real+0x3b0>
xor    %ebx,%ebx
mov    %rbx,%rax
test   $0x1,%cl
je     1461 <make_nh123_real+0x361>
add    %ebx,%r13d
movslq %r13d,%rax
add    %rbx,%r15
movsd  (%r11,%r15,8),%xmm0
subsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%r11,%r15,8)
mov    %rbx,%rax
or     $0x1,%rax
not    %rbx
cmp    -0x40(%rsp),%rbx
je     13f0 <make_nh123_real+0x2f0>
nopl   0x0(%rax,%rax,1)
lea    (%r14,%rax,1),%edx
movslq %edx,%rdx
movsd  -0x8(%r12,%rax,8),%xmm0
movsd  (%r12,%rax,8),%xmm1
subsd  (%rsi,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%r12,%rax,8)
lea    0x0(%rbp,%rax,1),%edx
movslq %edx,%rdx
subsd  (%rsi,%rdx,8),%xmm1
movsd  %xmm1,(%r12,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1470 <make_nh123_real+0x370>
jmp    13f0 <make_nh123_real+0x2f0>
mov    %r10d,%eax
imul   -0x80(%rsp),%eax
add    -0x70(%rsp),%eax
mov    0x40(%rsp),%rdx
lea    (%rax,%rdx,1),%ebx
cmp    %eax,%ebx
jl     1436 <make_nh123_real+0x336>
mov    %rdx,%rax
shr    $0x20,%rax
mov    $0x0,%ebx
jne    1438 <make_nh123_real+0x338>
mov    %r10d,%eax
imul   -0x80(%rsp),%eax
add    -0x70(%rsp),%eax
lea    (%r11,%r15,8),%rbx
cltq
mov    -0x48(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
cmp    %rdx,%rbx
jae    1513 <make_nh123_real+0x413>
lea    (%r15,%rcx,1),%rdx
lea    (%r11,%rdx,8),%rdx
lea    (%rsi,%rax,8),%rax
cmp    %rdx,%rax
jb     1436 <make_nh123_real+0x336>
cmpq   $0x0,0x10(%rsp)
je     15a8 <make_nh123_real+0x4a8>
mov    -0x20(%rsp),%rax
mov    %r9d,%r11d
xor    %r8d,%r8d
nopw   0x0(%rax,%rax,1)
lea    -0x4(%r11),%edx
movslq %edx,%rdx
movupd (%rsi,%rdx,8),%xmm0
movupd 0x10(%rsi,%rdx,8),%xmm1
movupd -0x30(%rdi,%r8,8),%xmm2
subpd  %xmm0,%xmm2
movupd -0x20(%rdi,%r8,8),%xmm0
subpd  %xmm1,%xmm0
movupd -0x10(%rdi,%r8,8),%xmm1
movupd (%rdi,%r8,8),%xmm3
movupd %xmm2,-0x30(%rdi,%r8,8)
movupd %xmm0,-0x20(%rdi,%r8,8)
movslq %r11d,%r11
movupd (%rsi,%r11,8),%xmm0
subpd  %xmm0,%xmm1
movupd 0x10(%rsi,%r11,8),%xmm0
subpd  %xmm0,%xmm3
movupd %xmm1,-0x10(%rdi,%r8,8)
movupd %xmm3,(%rdi,%r8,8)
add    $0x8,%r8
add    $0x8,%r11d
add    $0xfffffffffffffffe,%rax
jne    1530 <make_nh123_real+0x430>
jmp    15ab <make_nh123_real+0x4ab>
xor    %r8d,%r8d
testb  $0x1,0x8(%rsp)
mov    0x128(%rsp),%r11
je     15f8 <make_nh123_real+0x4f8>
lea    (%r8,%r13,1),%eax
cltq
mov    0xb8(%rsp),%rdx
movupd (%rdx,%rax,8),%xmm0
movupd 0x10(%rdx,%rax,8),%xmm1
add    %r15,%r8
movupd (%r11,%r8,8),%xmm2
subpd  %xmm0,%xmm2
movupd 0x10(%r11,%r8,8),%xmm0
subpd  %xmm1,%xmm0
movupd %xmm2,(%r11,%r8,8)
movupd %xmm0,0x10(%r11,%r8,8)
mov    0x18(%rsp),%rax
mov    %rax,%rbx
mov    0x20(%rsp),%rcx
cmp    %rcx,%rax
mov    0xb8(%rsp),%rsi
mov    -0x38(%rsp),%r8d
je     13f0 <make_nh123_real+0x2f0>
jmp    1438 <make_nh123_real+0x338>
cmpl   $0x0,0xe8(%rsp)
mov    0x130(%rsp),%rdi
mov    0x120(%rsp),%r11
mov    0x28(%rsp),%r9
jle    2918 <make_nh123_real+0x1818>
cmp    $0x2,%edi
mov    $0x1,%eax
cmovge %edi,%eax
mov    %rax,-0x38(%rsp)
movslq %r9d,%rax
movslq -0x8(%rsp),%rdx
mov    %rdx,0x60(%rsp)
movslq (%rsp),%rdx
mov    %rdx,0x58(%rsp)
movslq 0xe0(%rsp),%rdx
mov    %rdx,0xb0(%rsp)
movslq %r8d,%rdx
mov    %rdx,0xa8(%rsp)
shll   $0x2,-0x14(%rsp)
shll   $0x3,0x54(%rsp)
mov    %r11d,%r8d
mov    %eax,%r15d
mov    %edi,%r13d
mov    %ecx,%edx
and    $0x7ffffffe,%edx
mov    %rdx,0x30(%rsp)
mov    %rax,0x150(%rsp)
lea    0x0(,%rax,8),%rax
mov    %rax,0x1b0(%rsp)
xor    %eax,%eax
mov    0x198(%rsp),%rdx
mov    %rdx,0xa0(%rsp)
mov    %r8,0xd0(%rsp)
mov    %r15,-0x10(%rsp)
mov    %r13,0xc8(%rsp)
jmp    1722 <make_nh123_real+0x622>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x1b8(%rsp),%rax
add    $0x1,%rax
mov    0xa0(%rsp),%rcx
add    0x1b0(%rsp),%rcx
mov    %rcx,0xa0(%rsp)
cmp    %r14,%rax
mov    0x20(%rsp),%rcx
je     2918 <make_nh123_real+0x1818>
mov    %rax,%rdx
imul   0x150(%rsp),%rdx
mov    %rdx,0x1f8(%rsp)
add    %rcx,%rdx
mov    %rdx,0x1f0(%rsp)
mov    %rax,%r10
imul   0xa8(%rsp),%r10
lea    (%r10,%rcx,1),%rdx
mov    %rdx,0x1e8(%rsp)
mov    %rax,%rbx
imul   0x60(%rsp),%rbx
lea    (%rbx,%rcx,1),%rdx
mov    %rdx,0x140(%rsp)
mov    %rax,0x1b8(%rsp)
mov    %rax,%rdx
imul   0x58(%rsp),%rdx
lea    (%rdx,%rcx,1),%rax
mov    %rax,0x1d0(%rsp)
mov    0x158(%rsp),%rax
mov    %rdx,0x1d8(%rsp)
lea    (%rax,%rdx,8),%rax
mov    %rax,0x1c8(%rsp)
mov    %r10,0x148(%rsp)
lea    (%rsi,%r10,8),%rax
mov    %rax,0x188(%rsp)
mov    %rbx,0x1e0(%rsp)
lea    (%rsi,%rbx,8),%rax
mov    %rax,0x1c0(%rsp)
xor    %eax,%eax
xor    %edx,%edx
jmp    17ff <make_nh123_real+0x6ff>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x200(%rsp),%rdx
add    $0x1,%rdx
mov    0x138(%rsp),%eax
add    %r11d,%eax
cmp    %r14,%rdx
je     16f0 <make_nh123_real+0x5f0>
mov    %eax,0x138(%rsp)
mov    %eax,%eax
mov    0xa0(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,0x2a8(%rsp)
mov    %r11d,%ebp
imul   %edx,%ebp
mov    0x1f8(%rsp),%rax
add    %rbp,%rax
mov    %rax,0x3c0(%rsp)
add    0x1f0(%rsp),%rbp
mov    %rbp,0x3c8(%rsp)
mov    %rdx,%r10
imul   0x60(%rsp),%r10
mov    0x148(%rsp),%rbx
lea    (%rbx,%r10,1),%rcx
mov    %rcx,0x178(%rsp)
mov    0x1e8(%rsp),%r14
lea    (%r14,%r10,1),%rcx
mov    %rcx,0x170(%rsp)
mov    %rdx,%rax
imul   0xa8(%rsp),%rax
mov    0x1e0(%rsp),%r12
lea    (%r12,%rax,1),%rbp
mov    %rbp,0x280(%rsp)
mov    0x140(%rsp),%rcx
lea    (%rcx,%rax,1),%rbp
mov    %rbp,0x278(%rsp)
mov    %rdx,%rcx
imul   0x58(%rsp),%rcx
lea    (%rbx,%rcx,1),%rbp
mov    %rbp,0x168(%rsp)
mov    %rdx,0x200(%rsp)
imul   0xb0(%rsp),%rdx
mov    0x1d8(%rsp),%rbx
lea    (%rbx,%rax,1),%rbp
mov    %rbp,0x270(%rsp)
mov    0x1d0(%rsp),%r15
lea    (%r15,%rax,1),%rbp
mov    %rbp,0x268(%rsp)
lea    (%rsi,%rax,8),%rax
mov    0x188(%rsp),%r11
lea    (%r11,%r10,8),%rbp
mov    %rbp,0x260(%rsp)
lea    (%rax,%r12,8),%rbp
mov    %rbp,0x258(%rsp)
lea    (%rax,%rbx,8),%rax
mov    %rax,0x250(%rsp)
lea    (%r14,%rcx,1),%rax
mov    %rax,0x160(%rsp)
mov    0x148(%rsp),%rax
lea    (%rax,%rdx,1),%rax
mov    %rax,0x248(%rsp)
lea    (%r14,%rdx,1),%rax
mov    %rax,0x240(%rsp)
lea    (%rbx,%rdx,1),%rax
mov    %rax,0x238(%rsp)
lea    (%r15,%rdx,1),%rax
mov    %rax,0x230(%rsp)
lea    (%r12,%rcx,1),%rax
mov    -0x10(%rsp),%r15
mov    %rax,0x228(%rsp)
mov    0x140(%rsp),%rax
lea    (%rax,%rcx,1),%rax
mov    %rax,0x220(%rsp)
mov    0x1c8(%rsp),%rax
mov    %rdx,0x298(%rsp)
lea    (%rax,%rdx,8),%rax
mov    %rax,0x218(%rsp)
lea    (%r11,%rcx,8),%rax
mov    %rax,0x210(%rsp)
mov    0x1c0(%rsp),%rax
mov    %rcx,0x2a0(%rsp)
lea    (%rax,%rcx,8),%rax
mov    %rax,0x208(%rsp)
xor    %eax,%eax
xor    %edx,%edx
xor    %ecx,%ecx
jmp    1a0e <make_nh123_real+0x90e>
nopl   (%rax)
mov    0x288(%rsp),%rcx
add    $0x1,%rcx
mov    0x180(%rsp),%rdx
add    %r8,%rdx
mov    0x290(%rsp),%rax
add    %r10,%rax
cmp    %r14,%rcx
mov    %r10,%r15
je     17e0 <make_nh123_real+0x6e0>
mov    %rdx,0x180(%rsp)
mov    %rcx,%rbx
imul   0x58(%rsp),%rbx
mov    0x178(%rsp),%rbp
add    %rbx,%rbp
mov    %rbp,0x388(%rsp)
mov    %rcx,%rbp
imul   %r8,%rbp
mov    %rbp,0x380(%rsp)
mov    0x170(%rsp),%rdx
lea    (%rdx,%rbx,1),%rbp
mov    %rbp,0x378(%rsp)
mov    %rcx,%rbp
imul   %r15,%rbp
mov    %rbp,0x370(%rsp)
mov    %rcx,%r14
imul   0x60(%rsp),%r14
mov    0x168(%rsp),%rdx
lea    (%rdx,%r14,1),%rbp
mov    %rbp,0x368(%rsp)
mov    0x160(%rsp),%rdx
lea    (%rdx,%r14,1),%rbp
mov    %rbp,0x360(%rsp)
mov    %rcx,%r10
imul   0xb0(%rsp),%r10
mov    %rcx,%r12
imul   0x150(%rsp),%r12
mov    0x238(%rsp),%rdx
add    %r12,%rdx
mov    0x158(%rsp),%rbp
lea    0x0(%rbp,%rdx,8),%rdx
mov    %rdx,0xe8(%rsp)
mov    0x230(%rsp),%rdx
add    %r12,%rdx
lea    0x0(%rbp,%rdx,8),%rdx
mov    %rdx,0xe0(%rsp)
mov    0x120(%rsp),%r11
mov    %rcx,0x288(%rsp)
mov    %rcx,%rdx
imul   0xa8(%rsp),%rdx
mov    %rax,%r15
mov    0x228(%rsp),%rax
add    %rdx,%rax
mov    %rax,0x350(%rsp)
mov    0x220(%rsp),%rax
lea    (%rax,%rdx,1),%rax
mov    %rax,0x348(%rsp)
mov    0x218(%rsp),%rax
lea    (%rax,%r12,8),%r12
mov    0x210(%rsp),%rax
lea    (%rax,%r14,8),%rax
mov    %rax,0x340(%rsp)
mov    0x208(%rsp),%rax
lea    (%rax,%rdx,8),%rax
mov    %rax,0x338(%rsp)
mov    0x40(%rsp),%rdx
mov    0x280(%rsp),%rbp
lea    0x0(%rbp,%rbx,1),%rax
mov    %rax,0x330(%rsp)
mov    0x278(%rsp),%rcx
lea    (%rcx,%rbx,1),%rax
mov    %rax,0x328(%rsp)
mov    0x248(%rsp),%rax
lea    (%rax,%rbx,1),%rax
mov    %rax,0x320(%rsp)
mov    0x240(%rsp),%rax
lea    (%rax,%rbx,1),%rax
mov    %rax,0x318(%rsp)
mov    0x178(%rsp),%rax
lea    (%rax,%r10,1),%rax
mov    %rax,0x310(%rsp)
mov    0x170(%rsp),%rax
lea    (%rax,%r10,1),%rax
mov    %rax,0x308(%rsp)
mov    0x270(%rsp),%rax
lea    (%rax,%r10,1),%rax
mov    %rax,0x300(%rsp)
mov    0x268(%rsp),%rax
lea    (%rax,%r10,1),%rax
mov    %rax,0x2f8(%rsp)
mov    0x168(%rsp),%rax
lea    (%rax,%r10,1),%rax
mov    %rax,0x2f0(%rsp)
mov    0x160(%rsp),%rax
lea    (%rax,%r10,1),%rax
mov    %rax,0x2e8(%rsp)
lea    0x0(%rbp,%r10,1),%rax
mov    %rax,0x2e0(%rsp)
lea    (%rcx,%r10,1),%rax
mov    %rax,0x2d8(%rsp)
mov    0x258(%rsp),%rbp
lea    0x0(%rbp,%rbx,8),%rax
mov    %rax,0x2d0(%rsp)
mov    0x260(%rsp),%rax
mov    %rbx,0x390(%rsp)
lea    (%rax,%rbx,8),%rcx
mov    %rcx,0x2c8(%rsp)
mov    0x250(%rsp),%rcx
lea    (%rcx,%r10,8),%rcx
mov    %rcx,0x2c0(%rsp)
lea    (%rax,%r10,8),%rax
mov    %rax,0x2b8(%rsp)
mov    %r10,0x358(%rsp)
lea    0x0(,%r10,8),%rax
add    %rbp,%rax
mov    %rax,0x2b0(%rsp)
xor    %eax,%eax
mov    %rax,0xc0(%rsp)
movl   $0x0,0x50(%rsp)
movl   $0x0,0x4c(%rsp)
mov    %r15,0x290(%rsp)
mov    %r15,%rcx
mov    0x180(%rsp),%rbp
mov    %rbp,%r15
xor    %ebx,%ebx
jmp    1d5c <make_nh123_real+0xc5c>
cs nopw 0x0(%rax,%rax,1)
mov    0x3b0(%rsp),%rbx
add    $0x1,%rbx
mov    -0x10(%rsp),%r10
add    %r10,%rbp
mov    0xc8(%rsp),%r13
mov    0x3b8(%rsp),%r15
add    %r13,%r15
mov    0x190(%rsp),%rcx
add    %r13,%rcx
add    %r11d,0x4c(%rsp)
mov    0x28(%rsp),%r9
add    %r9d,0x50(%rsp)
mov    0xc0(%rsp),%rax
add    %edi,%eax
mov    %rax,0xc0(%rsp)
cmp    %r14,%rbx
mov    0xb8(%rsp),%rsi
mov    0xd0(%rsp),%r8
je     19e0 <make_nh123_real+0x8e0>
mov    %rcx,0x190(%rsp)
mov    %rbx,%r14
imul   0xb0(%rsp),%r14
mov    %rbx,%r10
mov    0x388(%rsp),%rax
add    %r14,%rax
lea    (%rsi,%rax,8),%rax
mov    %rax,0x98(%rsp)
mov    %rbx,%r9
imul   %r13,%r9
mov    0x380(%rsp),%rcx
lea    (%rcx,%r9,1),%rax
mov    %rax,0x8(%rsp)
mov    0x378(%rsp),%rax
add    %r14,%rax
lea    (%rsi,%rax,8),%rax
mov    %rax,0x90(%rsp)
mov    0x330(%rsp),%rax
add    %r14,%rax
lea    (%rsi,%rax,8),%rax
mov    %rax,(%rsp)
add    0x370(%rsp),%r9
mov    %r9,0x10(%rsp)
mov    0x328(%rsp),%rax
add    %r14,%rax
lea    (%rsi,%rax,8),%rax
mov    %rax,-0x8(%rsp)
mov    0x368(%rsp),%rax
add    %r14,%rax
lea    (%rsi,%rax,8),%rax
mov    %rax,0x88(%rsp)
mov    0x360(%rsp),%rax
add    %r14,%rax
lea    (%rsi,%rax,8),%rax
mov    %rax,0x80(%rsp)
mov    %rbx,%rax
imul   -0x10(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x18(%rsp)
mov    %rbx,%rax
imul   0x60(%rsp),%rax
mov    0x320(%rsp),%rcx
add    %rax,%rcx
lea    (%rsi,%rcx,8),%rcx
mov    %rcx,0x68(%rsp)
mov    0x318(%rsp),%rcx
add    %rax,%rcx
lea    (%rsi,%rcx,8),%rcx
mov    %rcx,0xd8(%rsp)
imul   0x58(%rsp),%rbx
mov    0x310(%rsp),%rcx
add    %rbx,%rcx
lea    (%rsi,%rcx,8),%rcx
mov    %rcx,0x78(%rsp)
mov    0x308(%rsp),%rcx
lea    (%rcx,%rbx,1),%rcx
lea    (%rsi,%rcx,8),%rcx
mov    %rcx,0x70(%rsp)
mov    0x300(%rsp),%rcx
add    %rax,%rcx
lea    (%rsi,%rcx,8),%rcx
mov    %rcx,0x3d8(%rsp)
mov    0x2f8(%rsp),%rcx
add    %rax,%rcx
lea    (%rsi,%rcx,8),%rcx
mov    %rcx,0x3d0(%rsp)
imul   %r10d,%edi
mov    %rdi,0x3e8(%rsp)
mov    %r11d,%ecx
imul   %r10d,%ecx
mov    %ecx,0x13c(%rsp)
mov    0x2f0(%rsp),%rcx
add    %rax,%rcx
lea    (%rsi,%rcx,8),%rcx
mov    %rcx,0x118(%rsp)
mov    0x28(%rsp),%rcx
mov    %r10,0x3b0(%rsp)
imul   %r10d,%ecx
mov    %rcx,0x3e0(%rsp)
mov    0x2e8(%rsp),%rcx
add    %rax,%rcx
lea    (%rsi,%rcx,8),%rcx
mov    %rcx,0x110(%rsp)
mov    0x2e0(%rsp),%rcx
lea    (%rcx,%rbx,1),%rcx
lea    (%rsi,%rcx,8),%rcx
mov    %rcx,0x108(%rsp)
mov    0x2d8(%rsp),%rcx
lea    (%rcx,%rbx,1),%rcx
lea    (%rsi,%rcx,8),%rcx
mov    %rcx,0x100(%rsp)
mov    0x350(%rsp),%rcx
lea    (%rcx,%r14,1),%rcx
lea    (%rsi,%rcx,8),%rcx
mov    %rcx,0xf8(%rsp)
mov    0x348(%rsp),%rcx
lea    (%rcx,%r14,1),%rcx
lea    (%rsi,%rcx,8),%rcx
mov    %rcx,0xf0(%rsp)
mov    0x2c0(%rsp),%rcx
mov    %rbp,%rdi
lea    (%rcx,%rax,8),%r11
mov    0x188(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x390(%rsp),%rax
mov    %rcx,0x398(%rsp)
lea    (%rcx,%rax,8),%rax
mov    0x298(%rsp),%rcx
lea    (%rax,%rcx,8),%r9
mov    0x2b8(%rsp),%rax
mov    %r15,%rsi
mov    %rbx,0x3a0(%rsp)
lea    (%rax,%rbx,8),%r15
mov    0x340(%rsp),%rax
lea    (%rax,%r14,8),%rbx
mov    0x2d0(%rsp),%rax
lea    (%rax,%r14,8),%rbp
mov    0x2c8(%rsp),%rax
mov    %r14,0x3a8(%rsp)
lea    (%rax,%r14,8),%r10
mov    0x190(%rsp),%rax
mov    %rax,-0x70(%rsp)
mov    %rsi,0x3b8(%rsp)
mov    %rsi,-0x80(%rsp)
mov    %rdi,0x128(%rsp)
mov    %rdi,-0x48(%rsp)
mov    0x2a8(%rsp),%rax
mov    %rax,-0x68(%rsp)
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpl   $0x2,0x20(%rsp)
mov    %rsi,-0x40(%rsp)
jae    2130 <make_nh123_real+0x1030>
xor    %r14d,%r14d
mov    -0x68(%rsp),%rax
lea    (%rax,%r14,8),%rdx
mov    -0x80(%rsp),%rax
add    %r14d,%eax
mov    -0x70(%rsp),%rcx
add    %r14d,%ecx
mov    -0x48(%rsp),%rsi
lea    (%rsi,%r14,1),%r13d
mov    -0x38(%rsp),%r8
sub    %r14,%r8
xor    %esi,%esi
nop
lea    (%rsi,%r13,1),%edi
movslq %edi,%rdi
movsd  (%r11,%rdi,8),%xmm0
addsd  (%r15,%rdi,8),%xmm0
addsd  (%r9,%rdi,8),%xmm0
addsd  0x0(%rbp,%rdi,8),%xmm0
lea    (%rcx,%rsi,1),%edi
movslq %edi,%rdi
addsd  (%rbx,%rdi,8),%xmm0
addsd  0x0(%rbp,%rdi,8),%xmm0
lea    (%rax,%rsi,1),%edi
movslq %edi,%rdi
addsd  (%r10,%rdi,8),%xmm0
addsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,(%rdx,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%r8
jne    2080 <make_nh123_real+0xf80>
mov    -0x40(%rsp),%rsi
add    $0x1,%rsi
mov    -0x68(%rsp),%rax
add    0x1a8(%rsp),%rax
mov    %rax,-0x68(%rsp)
mov    0xc8(%rsp),%r13
add    %r13,-0x48(%rsp)
mov    -0x80(%rsp),%rax
add    -0x10(%rsp),%rax
mov    %rax,-0x80(%rsp)
mov    0xd0(%rsp),%r8
add    %r8,-0x70(%rsp)
mov    -0x38(%rsp),%r14
cmp    %r14,%rsi
mov    0x40(%rsp),%rdx
jne    2040 <make_nh123_real+0xf40>
jmp    2420 <make_nh123_real+0x1320>
nopl   0x0(%rax,%rax,1)
mov    %r13d,%eax
imul   %esi,%eax
add    0x18(%rsp),%eax
lea    (%rax,%rdx,1),%ecx
cmp    %eax,%ecx
jl     2050 <make_nh123_real+0xf50>
mov    %rdx,%rax
shr    $0x20,%rax
jne    2050 <make_nh123_real+0xf50>
mov    %esi,%ecx
imul   %r8d,%ecx
add    0x10(%rsp),%ecx
add    %ecx,%edx
cmp    %ecx,%edx
jl     2050 <make_nh123_real+0xf50>
test   %rax,%rax
jne    2050 <make_nh123_real+0xf50>
mov    %esi,%ecx
imul   -0x10(%rsp),%ecx
add    0x8(%rsp),%ecx
mov    0x40(%rsp),%rdx
add    %ecx,%edx
cmp    %ecx,%edx
jl     2050 <make_nh123_real+0xf50>
mov    $0x0,%r14d
test   %rax,%rax
jne    2053 <make_nh123_real+0xf53>
mov    -0x40(%rsp),%rdi
mov    %rdi,%rax
imul   0x1a0(%rsp),%rax
mov    0x3c0(%rsp),%rcx
add    %rax,%rcx
add    0x3c8(%rsp),%rax
mov    %edi,%r8d
imul   -0x10(%rsp),%r8d
add    0x8(%rsp),%r8d
mov    0xd0(%rsp),%rdx
mov    %edx,%esi
imul   %edi,%esi
add    0x10(%rsp),%esi
mov    0xc8(%rsp),%rdx
imul   %edi,%edx
add    0x18(%rsp),%edx
mov    0x198(%rsp),%rdi
lea    (%rdi,%rcx,8),%rcx
lea    (%rdi,%rax,8),%rax
movslq %r8d,%r8
mov    0x98(%rsp),%rdi
lea    (%rdi,%r8,8),%rdi
mov    %rdi,-0x50(%rsp)
mov    0x90(%rsp),%rdi
lea    (%rdi,%r8,8),%r13
movslq %esi,%rsi
mov    (%rsp),%r8
lea    (%r8,%rsi,8),%rdi
mov    %rdi,-0x78(%rsp)
mov    -0x8(%rsp),%r14
lea    (%r14,%rsi,8),%rdi
mov    %rdi,-0x30(%rsp)
mov    0x88(%rsp),%rdi
lea    (%rdi,%rsi,8),%rdi
mov    %rdi,-0x60(%rsp)
mov    0x80(%rsp),%rdi
lea    (%rdi,%rsi,8),%rsi
mov    %rsi,-0x28(%rsp)
movslq %edx,%rdx
lea    (%r8,%rdx,8),%rsi
mov    %rsi,-0x58(%rsp)
cmp    %r13,%rcx
setb   -0x20(%rsp)
cmp    %rax,-0x50(%rsp)
lea    (%r14,%rdx,8),%rsi
setb   -0x50(%rsp)
cmp    -0x30(%rsp),%rcx
setb   %r13b
cmp    %rax,-0x78(%rsp)
mov    0x68(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdi
mov    %rdi,-0x78(%rsp)
setb   -0x30(%rsp)
cmp    -0x28(%rsp),%rcx
setb   %r8b
cmp    %rax,-0x60(%rsp)
mov    0xd8(%rsp),%rdi
lea    (%rdi,%rdx,8),%r14
setb   -0x60(%rsp)
cmp    %rsi,%rcx
setb   -0x28(%rsp)
cmp    %rax,-0x58(%rsp)
mov    0x78(%rsp),%rsi
lea    (%rsi,%rdx,8),%rsi
setb   -0x58(%rsp)
cmp    %r14,%rcx
setb   0x38(%rsp)
cmp    %rax,-0x78(%rsp)
mov    0x70(%rsp),%rdi
lea    (%rdi,%rdx,8),%r14
setb   -0x78(%rsp)
cmp    %r14,%rcx
setb   %dil
cmp    %rax,%rsi
mov    0x3d0(%rsp),%rsi
lea    (%rsi,%rdx,8),%rsi
setb   %r14b
cmp    %rsi,%rcx
mov    0x3d8(%rsp),%rcx
lea    (%rcx,%rdx,8),%rdx
setb   %cl
cmp    %rax,%rdx
setb   %al
mov    -0x50(%rsp),%dl
test   %dl,-0x20(%rsp)
jne    2050 <make_nh123_real+0xf50>
and    -0x30(%rsp),%r13b
jne    2050 <make_nh123_real+0xf50>
and    -0x60(%rsp),%r8b
jne    2050 <make_nh123_real+0xf50>
mov    -0x58(%rsp),%dl
and    %dl,-0x28(%rsp)
jne    2050 <make_nh123_real+0xf50>
mov    -0x78(%rsp),%dl
and    %dl,0x38(%rsp)
jne    2050 <make_nh123_real+0xf50>
and    %r14b,%dil
jne    2050 <make_nh123_real+0xf50>
mov    $0x0,%r14d
and    %al,%cl
jne    2053 <make_nh123_real+0xf53>
xor    %eax,%eax
mov    0x30(%rsp),%rdx
mov    -0x70(%rsp),%r8
mov    -0x80(%rsp),%r14
mov    -0x48(%rsp),%rsi
mov    -0x68(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
lea    (%rsi,%rax,1),%ecx
movslq %ecx,%rcx
movupd (%r11,%rcx,8),%xmm0
movupd (%r15,%rcx,8),%xmm1
addpd  %xmm0,%xmm1
movupd (%r9,%rcx,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x0(%rbp,%rcx,8),%xmm1
addpd  %xmm0,%xmm1
lea    (%r8,%rax,1),%ecx
movslq %ecx,%rcx
movupd (%rbx,%rcx,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x0(%rbp,%rcx,8),%xmm1
addpd  %xmm0,%xmm1
lea    (%r14,%rax,1),%ecx
movslq %ecx,%rcx
movupd (%r10,%rcx,8),%xmm0
addpd  %xmm1,%xmm0
movupd (%rdi,%rax,8),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,(%rdi,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdx
jne    23a0 <make_nh123_real+0x12a0>
mov    %rdx,%r14
cmp    0x20(%rsp),%rdx
jne    2053 <make_nh123_real+0xf53>
jmp    20cf <make_nh123_real+0xfcf>
nop
mov    0x338(%rsp),%rax
mov    0x3a8(%rsp),%rcx
lea    (%rax,%rcx,8),%r8
mov    0x2b0(%rsp),%rax
mov    0x3a0(%rsp),%rcx
lea    (%rax,%rcx,8),%r13
mov    0x2a0(%rsp),%rax
mov    0x398(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    0x358(%rsp),%rcx
lea    (%rax,%rcx,8),%rsi
xor    %r9d,%r9d
mov    0xc0(%rsp),%rax
mov    %eax,%ecx
mov    0x50(%rsp),%eax
mov    %eax,-0x48(%rsp)
mov    0x4c(%rsp),%eax
mov    %eax,0x68(%rsp)
xor    %eax,%eax
mov    0x130(%rsp),%rdi
jmp    24d4 <make_nh123_real+0x13d4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addl   $0x1,-0x8(%rsp)
mov    (%rsp),%r9d
add    %r11d,%r9d
mov    0x28(%rsp),%rax
add    %eax,0x68(%rsp)
add    %r11d,%ecx
mov    %ecx,-0x48(%rsp)
mov    0xd8(%rsp),%ecx
add    0x28(%rsp),%ecx
mov    -0x8(%rsp),%eax
cmp    %r14d,%eax
je     1cf0 <make_nh123_real+0xbf0>
mov    %r9d,(%rsp)
mov    %eax,%r11d
mov    -0x14(%rsp),%eax
mov    %eax,%ebp
imul   %r11d,%ebp
mov    0x54(%rsp),%eax
mov    %eax,%r9d
mov    %r11d,-0x8(%rsp)
imul   %r11d,%r9d
mov    0x3e8(%rsp),%rax
add    %r9d,%eax
mov    %eax,0x38(%rsp)
add    0x13c(%rsp),%r9d
mov    %r9,-0x28(%rsp)
mov    0x3e0(%rsp),%rax
mov    %rbp,0x18(%rsp)
add    %ebp,%eax
mov    %rax,0x10(%rsp)
mov    %ecx,0xd8(%rsp)
mov    %ecx,%eax
mov    %rax,-0x80(%rsp)
mov    -0x48(%rsp),%eax
mov    %rax,-0x68(%rsp)
mov    0x68(%rsp),%eax
mov    %rax,-0x40(%rsp)
mov    (%rsp),%eax
mov    %rax,-0x70(%rsp)
xor    %r9d,%r9d
cmpl   $0x2,0x20(%rsp)
jae    2650 <make_nh123_real+0x1550>
xor    %ecx,%ecx
mov    -0x80(%rsp),%rax
lea    (%rax,%rcx,1),%edi
mov    -0x70(%rsp),%rax
lea    (%rax,%rcx,1),%edx
mov    -0x40(%rsp),%rax
add    %ecx,%eax
mov    -0x68(%rsp),%rbp
lea    (%rcx,%rbp,1),%r11d
mov    %r14,%rbp
sub    %rcx,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %r11d,%r11
movsd  (%r8,%r11,8),%xmm0
addsd  0x0(%r13,%r11,8),%xmm0
addsd  (%rsi,%r11,8),%xmm0
cltq
addsd  (%rbx,%rax,8),%xmm0
addsd  (%r15,%rax,8),%xmm0
movslq %edi,%rdi
addsd  (%r10,%rdi,8),%xmm0
movslq %edx,%rdx
addsd  (%r12,%rdx,8),%xmm0
movsd  %xmm0,(%r12,%rdx,8)
add    $0x1,%edi
add    $0x1,%edx
add    $0x1,%eax
add    $0x1,%r11d
add    $0xffffffffffffffff,%rbp
jne    2590 <make_nh123_real+0x1490>
add    $0x1,%r9d
mov    0x130(%rsp),%rdi
mov    -0x70(%rsp),%rax
add    %edi,%eax
mov    %rax,-0x70(%rsp)
mov    -0x40(%rsp),%rax
add    %edi,%eax
mov    %rax,-0x40(%rsp)
mov    -0x68(%rsp),%rax
add    %edi,%eax
mov    %rax,-0x68(%rsp)
mov    0x120(%rsp),%r11
mov    -0x80(%rsp),%rax
add    %r11d,%eax
mov    %rax,-0x80(%rsp)
cmp    %r14d,%r9d
mov    0x40(%rsp),%rdx
mov    0x128(%rsp),%rbp
mov    -0x48(%rsp),%ecx
jne    2550 <make_nh123_real+0x1450>
jmp    24a0 <make_nh123_real+0x13a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
imul   %r9d,%edi
mov    0x18(%rsp),%rax
add    %edi,%eax
lea    (%rax,%rdx,1),%ecx
cmp    %eax,%ecx
jl     255b <make_nh123_real+0x145b>
mov    %rdx,%rbp
shr    $0x20,%rbp
jne    255b <make_nh123_real+0x145b>
mov    0x10(%rsp),%rcx
lea    (%rcx,%rdi,1),%r11d
lea    (%r11,%rdx,1),%ecx
cmp    %r11d,%ecx
jl     255b <make_nh123_real+0x145b>
test   %rbp,%rbp
jne    255b <make_nh123_real+0x145b>
add    -0x28(%rsp),%edi
lea    (%rdi,%rdx,1),%ecx
cmp    %edi,%ecx
jl     255b <make_nh123_real+0x145b>
test   %rbp,%rbp
jne    255b <make_nh123_real+0x145b>
mov    -0x14(%rsp),%ecx
mov    %rdx,%r14
mov    %ecx,%edx
imul   %r9d,%edx
add    0x38(%rsp),%edx
lea    (%rdx,%r14,1),%ecx
cmp    %edx,%ecx
jl     290c <make_nh123_real+0x180c>
mov    $0x0,%ecx
test   %rbp,%rbp
mov    -0x38(%rsp),%r14
jne    255d <make_nh123_real+0x145d>
cltq
mov    0xe8(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0xe0(%rsp),%rbp
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
movslq %edx,%rdx
mov    0x98(%rsp),%rbp
lea    0x0(%rbp,%rdx,8),%rbp
mov    %rbp,-0x20(%rsp)
mov    0x90(%rsp),%rbp
lea    0x0(%rbp,%rdx,8),%rdx
movslq %edi,%rdi
mov    0x78(%rsp),%rbp
lea    0x0(%rbp,%rdi,8),%rbp
mov    %rbp,-0x58(%rsp)
mov    0x70(%rsp),%rbp
lea    0x0(%rbp,%rdi,8),%rbp
mov    %rbp,-0x60(%rsp)
mov    0x88(%rsp),%r14
lea    (%r14,%rdi,8),%rbp
mov    %rbp,-0x50(%rsp)
mov    0x80(%rsp),%rbp
lea    0x0(,%rdi,8),%rdi
add    %rbp,%rdi
movslq %r11d,%r11
cmp    %rdx,%rcx
setb   0x8(%rsp)
cmp    %rax,-0x20(%rsp)
mov    0x118(%rsp),%rdx
lea    (%rdx,%r11,8),%rdx
mov    %rdx,-0x78(%rsp)
setb   -0x20(%rsp)
cmp    -0x60(%rsp),%rcx
setb   %dl
cmp    %rax,-0x58(%rsp)
mov    0x110(%rsp),%rbp
lea    0x0(%rbp,%r11,8),%rbp
setb   -0x58(%rsp)
cmp    %rdi,%rcx
setb   %r14b
cmp    %rax,-0x50(%rsp)
mov    0x108(%rsp),%rdi
lea    (%rdi,%r11,8),%rdi
setb   -0x50(%rsp)
cmp    %rbp,%rcx
setb   -0x60(%rsp)
cmp    %rax,-0x78(%rsp)
mov    0x100(%rsp),%rbp
lea    0x0(%rbp,%r11,8),%rbp
setb   -0x78(%rsp)
cmp    %rbp,%rcx
setb   %bpl
cmp    %rax,%rdi
mov    0xf0(%rsp),%rdi
lea    (%rdi,%r11,8),%rdi
setb   -0x30(%rsp)
cmp    %rdi,%rcx
mov    0xf8(%rsp),%rcx
lea    (%rcx,%r11,8),%rcx
setb   %dil
cmp    %rax,%rcx
setb   %al
mov    -0x20(%rsp),%cl
test   %cl,0x8(%rsp)
jne    290c <make_nh123_real+0x180c>
mov    %r14d,%ecx
and    -0x58(%rsp),%dl
mov    -0x38(%rsp),%r14
jne    255b <make_nh123_real+0x145b>
and    -0x50(%rsp),%cl
jne    255b <make_nh123_real+0x145b>
mov    -0x78(%rsp),%cl
and    %cl,-0x60(%rsp)
jne    255b <make_nh123_real+0x145b>
and    -0x30(%rsp),%bpl
jne    255b <make_nh123_real+0x145b>
mov    $0x0,%ecx
and    %al,%dil
jne    255d <make_nh123_real+0x145d>
mov    -0x80(%rsp),%rax
mov    -0x68(%rsp),%rdx
mov    -0x40(%rsp),%rdi
mov    -0x70(%rsp),%rbp
mov    0x30(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %edx,%rdx
movupd (%r8,%rdx,8),%xmm0
movupd 0x0(%r13,%rdx,8),%xmm1
addpd  %xmm0,%xmm1
movupd (%rsi,%rdx,8),%xmm0
addpd  %xmm1,%xmm0
movslq %edi,%rdi
movupd (%rbx,%rdi,8),%xmm1
addpd  %xmm0,%xmm1
movupd (%r15,%rdi,8),%xmm0
addpd  %xmm1,%xmm0
cltq
movupd (%r10,%rax,8),%xmm1
addpd  %xmm0,%xmm1
movslq %ebp,%rbp
movupd (%r12,%rbp,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm0,(%r12,%rbp,8)
add    $0x2,%ebp
add    $0x2,%edi
add    $0x2,%edx
add    $0x2,%eax
add    $0xfffffffffffffffe,%rcx
jne    2890 <make_nh123_real+0x1790>
mov    0x30(%rsp),%rax
mov    %rax,%rcx
cmp    0x20(%rsp),%rax
jne    255d <make_nh123_real+0x145d>
jmp    25de <make_nh123_real+0x14de>
xor    %ecx,%ecx
mov    -0x38(%rsp),%r14
jmp    255d <make_nh123_real+0x145d>
add    $0x3f0,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @make_nh123_real(i32 %0, double* %1, double* %2, double* %3, double* %4) {
%6 = alloca i32
%7 = alloca double*
%8 = alloca double*
%9 = alloca double*
%10 = alloca double*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca double*
%27 = alloca double*
%28 = alloca i32
%29 = alloca double*
%30 = alloca double*
%31 = alloca double*
%32 = alloca double*
%33 = alloca double*
%34 = alloca double*
%35 = alloca i32
%36 = alloca i32
%37 = alloca double
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca double*
%42 = alloca double*
%43 = alloca double*
%44 = alloca i32
%45 = alloca i32
%46 = alloca i32
%47 = alloca i32
%48 = alloca double
%49 = alloca i32
%50 = alloca i32
store i32 %0, i32* %6
store double* %1, double** %7
store double* %2, double** %8
store double* %3, double** %9
store double* %4, double** %10
%51 = load i32, i32* %6
%52 = mul nsw i32 2, %51
store i32 %52, i32* %11
%53 = load i32, i32* %11
%54 = load i32, i32* %11
%55 = mul nsw i32 %53, %54
store i32 %55, i32* %12
%56 = load i32, i32* %12
%57 = load i32, i32* %11
%58 = mul nsw i32 %56, %57
store i32 %58, i32* %13
%59 = load i32, i32* %13
%60 = load i32, i32* %11
%61 = mul nsw i32 %59, %60
store i32 %61, i32* %14
%62 = load i32, i32* %14
%63 = load i32, i32* %11
%64 = mul nsw i32 %62, %63
store i32 %64, i32* %15
%65 = load i32, i32* %15
%66 = load i32, i32* %11
%67 = mul nsw i32 %65, %66
store i32 %67, i32* %16
%68 = load i32, i32* %16
%69 = load i32, i32* %11
%70 = mul nsw i32 %68, %69
store i32 %70, i32* %17
store i32 0, i32* %18
br label %71
71: ; preds = %155, %5
%72 = load i32, i32* %18
%73 = load i32, i32* %11
%74 = icmp slt i32 %72, %73
br i1 %74, label %75, label %158
75: ; preds = %71
store i32 0, i32* %19
br label %76
76: ; preds = %151, %75
%77 = load i32, i32* %19
%78 = load i32, i32* %11
%79 = icmp slt i32 %77, %78
br i1 %79, label %80, label %154
80: ; preds = %76
store i32 0, i32* %20
br label %81
81: ; preds = %147, %80
%82 = load i32, i32* %20
%83 = load i32, i32* %11
%84 = icmp slt i32 %82, %83
br i1 %84, label %85, label %150
85: ; preds = %81
store i32 0, i32* %21
br label %86
86: ; preds = %143, %85
%87 = load i32, i32* %21
%88 = load i32, i32* %11
%89 = icmp slt i32 %87, %88
br i1 %89, label %90, label %146
90: ; preds = %86
store i32 0, i32* %22
br label %91
91: ; preds = %139, %90
%92 = load i32, i32* %22
%93 = load i32, i32* %11
%94 = icmp slt i32 %92, %93
br i1 %94, label %95, label %142
95: ; preds = %91
%96 = load double*, double** %7
%97 = load i32, i32* %21
%98 = load i32, i32* %17
%99 = mul nsw i32 %97, %98
%100 = load i32, i32* %19
%101 = load i32, i32* %16
%102 = mul nsw i32 %100, %101
%103 = add nsw i32 %99, %102
%104 = load i32, i32* %18
%105 = load i32, i32* %15
%106 = mul nsw i32 %104, %105
%107 = add nsw i32 %103, %106
%108 = load i32, i32* %20
%109 = load i32, i32* %14
%110 = mul nsw i32 %108, %109
%111 = add nsw i32 %107, %110
%112 = load i32, i32* %19
%113 = load i32, i32* %13
%114 = mul nsw i32 %112, %113
%115 = add nsw i32 %111, %114
%116 = load i32, i32* %18
%117 = load i32, i32* %12
%118 = mul nsw i32 %116, %117
%119 = add nsw i32 %115, %118
%120 = load i32, i32* %20
%121 = load i32, i32* %11
%122 = mul nsw i32 %120, %121
%123 = add nsw i32 %119, %122
%124 = load i32, i32* %22
%125 = add nsw i32 %123, %124
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds double, double* %96, i64 %126
%128 = load double, double* %127
%129 = load double*, double** %8
%130 = load i32, i32* %21
%131 = load i32, i32* %11
%132 = mul nsw i32 %130, %131
%133 = load i32, i32* %22
%134 = add nsw i32 %132, %133
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds double, double* %129, i64 %135
%137 = load double, double* %136
%138 = fsub double %137, %128
store double %138, double* %136
br label %139
139: ; preds = %95
%140 = load i32, i32* %22
%141 = add nsw i32 %140, 1
store i32 %141, i32* %22
br label %91
142: ; preds = %91
br label %143
143: ; preds = %142
%144 = load i32, i32* %21
%145 = add nsw i32 %144, 1
store i32 %145, i32* %21
br label %86
146: ; preds = %86
br label %147
147: ; preds = %146
%148 = load i32, i32* %20
%149 = add nsw i32 %148, 1
store i32 %149, i32* %20
br label %81
150: ; preds = %81
br label %151
151: ; preds = %150
%152 = load i32, i32* %19
%153 = add nsw i32 %152, 1
store i32 %153, i32* %19
br label %76
154: ; preds = %76
br label %155
155: ; preds = %154
%156 = load i32, i32* %18
%157 = add nsw i32 %156, 1
store i32 %157, i32* %18
br label %71
158: ; preds = %71
store i32 0, i32* %23
br label %159
159: ; preds = %643, %158
%160 = load i32, i32* %23
%161 = load i32, i32* %11
%162 = icmp slt i32 %160, %161
br i1 %162, label %163, label %646
163: ; preds = %159
store i32 0, i32* %24
br label %164
164: ; preds = %639, %163
%165 = load i32, i32* %24
%166 = load i32, i32* %11
%167 = icmp slt i32 %165, %166
br i1 %167, label %168, label %642
168: ; preds = %164
store i32 0, i32* %25
br label %169
169: ; preds = %635, %168
%170 = load i32, i32* %25
%171 = load i32, i32* %11
%172 = icmp slt i32 %170, %171
br i1 %172, label %173, label %638
173: ; preds = %169
%174 = load double*, double** %9
%175 = load i32, i32* %23
%176 = load i32, i32* %13
%177 = mul nsw i32 %175, %176
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds double, double* %174, i64 %178
%180 = load i32, i32* %24
%181 = load i32, i32* %12
%182 = mul nsw i32 %180, %181
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds double, double* %179, i64 %183
store double* %184, double** %26
%185 = load double*, double** %10
%186 = load i32, i32* %23
%187 = load i32, i32* %15
%188 = mul nsw i32 %186, %187
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds double, double* %185, i64 %189
%191 = load i32, i32* %24
%192 = load i32, i32* %14
%193 = mul nsw i32 %191, %192
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds double, double* %190, i64 %194
%196 = load i32, i32* %25
%197 = load i32, i32* %13
%198 = mul nsw i32 %196, %197
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds double, double* %195, i64 %199
store double* %200, double** %27
store i32 0, i32* %28
br label %201
201: ; preds = %631, %173
%202 = load i32, i32* %28
%203 = load i32, i32* %11
%204 = icmp slt i32 %202, %203
br i1 %204, label %205, label %634
205: ; preds = %201
%206 = load double*, double** %7
%207 = load i32, i32* %24
%208 = load i32, i32* %17
%209 = mul nsw i32 %207, %208
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds double, double* %206, i64 %210
%212 = load i32, i32* %28
%213 = load i32, i32* %16
%214 = mul nsw i32 %212, %213
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds double, double* %211, i64 %215
%217 = load i32, i32* %23
%218 = load i32, i32* %15
%219 = mul nsw i32 %217, %218
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds double, double* %216, i64 %220
%222 = load i32, i32* %25
%223 = load i32, i32* %14
%224 = mul nsw i32 %222, %223
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds double, double* %221, i64 %225
store double* %226, double** %29
%227 = load double*, double** %7
%228 = load i32, i32* %23
%229 = load i32, i32* %17
%230 = mul nsw i32 %228, %229
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds double, double* %227, i64 %231
%233 = load i32, i32* %24
%234 = load i32, i32* %16
%235 = mul nsw i32 %233, %234
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds double, double* %232, i64 %236
%238 = load i32, i32* %28
%239 = load i32, i32* %15
%240 = mul nsw i32 %238, %239
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds double, double* %237, i64 %241
%243 = load i32, i32* %25
%244 = load i32, i32* %14
%245 = mul nsw i32 %243, %244
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds double, double* %242, i64 %246
store double* %247, double** %30
%248 = load double*, double** %7
%249 = load i32, i32* %23
%250 = load i32, i32* %17
%251 = mul nsw i32 %249, %250
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds double, double* %248, i64 %252
%254 = load i32, i32* %28
%255 = load i32, i32* %16
%256 = mul nsw i32 %254, %255
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds double, double* %253, i64 %257
%259 = load i32, i32* %25
%260 = load i32, i32* %15
%261 = mul nsw i32 %259, %260
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds double, double* %258, i64 %262
%264 = load i32, i32* %24
%265 = load i32, i32* %14
%266 = mul nsw i32 %264, %265
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds double, double* %263, i64 %267
store double* %268, double** %31
%269 = load double*, double** %7
%270 = load i32, i32* %23
%271 = load i32, i32* %17
%272 = mul nsw i32 %270, %271
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds double, double* %269, i64 %273
%275 = load i32, i32* %25
%276 = load i32, i32* %16
%277 = mul nsw i32 %275, %276
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds double, double* %274, i64 %278
%280 = load i32, i32* %24
%281 = load i32, i32* %15
%282 = mul nsw i32 %280, %281
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds double, double* %279, i64 %283
%285 = load i32, i32* %28
%286 = load i32, i32* %14
%287 = mul nsw i32 %285, %286
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds double, double* %284, i64 %288
store double* %289, double** %32
%290 = load double*, double** %7
%291 = load i32, i32* %24
%292 = load i32, i32* %17
%293 = mul nsw i32 %291, %292
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds double, double* %290, i64 %294
%296 = load i32, i32* %23
%297 = load i32, i32* %16
%298 = mul nsw i32 %296, %297
%299 = sext i32 %298 to i64
%300 = getelementptr inbounds double, double* %295, i64 %299
%301 = load i32, i32* %25
%302 = load i32, i32* %15
%303 = mul nsw i32 %301, %302
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds double, double* %300, i64 %304
%306 = load i32, i32* %28
%307 = load i32, i32* %14
%308 = mul nsw i32 %306, %307
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds double, double* %305, i64 %309
store double* %310, double** %33
%311 = load double*, double** %7
%312 = load i32, i32* %23
%313 = load i32, i32* %17
%314 = mul nsw i32 %312, %313
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds double, double* %311, i64 %315
%317 = load i32, i32* %24
%318 = load i32, i32* %16
%319 = mul nsw i32 %317, %318
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds double, double* %316, i64 %320
%322 = load i32, i32* %25
%323 = load i32, i32* %15
%324 = mul nsw i32 %322, %323
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds double, double* %321, i64 %325
%327 = load i32, i32* %28
%328 = load i32, i32* %14
%329 = mul nsw i32 %327, %328
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds double, double* %326, i64 %330
store double* %331, double** %34
store i32 0, i32* %35
br label %332
332: ; preds = %443, %205
%333 = load i32, i32* %35
%334 = load i32, i32* %11
%335 = icmp slt i32 %333, %334
br i1 %335, label %336, label %446
336: ; preds = %332
store i32 0, i32* %36
br label %337
337: ; preds = %439, %336
%338 = load i32, i32* %36
%339 = load i32, i32* %11
%340 = icmp slt i32 %338, %339
br i1 %340, label %341, label %442
341: ; preds = %337
%342 = load i32, i32* %28
%343 = load i32, i32* %13
%344 = mul nsw i32 %342, %343
%345 = load i32, i32* %25
%346 = load i32, i32* %12
%347 = mul nsw i32 %345, %346
%348 = add nsw i32 %344, %347
%349 = load i32, i32* %35
%350 = load i32, i32* %11
%351 = mul nsw i32 %349, %350
%352 = add nsw i32 %348, %351
%353 = load i32, i32* %36
%354 = add nsw i32 %352, %353
store i32 %354, i32* %38
%355 = load double*, double** %29
%356 = load i32, i32* %38
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds double, double* %355, i64 %357
%359 = load double, double* %358
store double %359, double* %37
%360 = load double*, double** %30
%361 = load i32, i32* %38
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds double, double* %360, i64 %362
%364 = load double, double* %363
%365 = load double, double* %37
%366 = fadd double %365, %364
store double %366, double* %37
%367 = load double*, double** %31
%368 = load i32, i32* %38
%369 = sext i32 %368 to i64
%370 = getelementptr inbounds double, double* %367, i64 %369
%371 = load double, double* %370
%372 = load double, double* %37
%373 = fadd double %372, %371
store double %373, double* %37
%374 = load double*, double** %33
%375 = load i32, i32* %38
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds double, double* %374, i64 %376
%378 = load double, double* %377
%379 = load double, double* %37
%380 = fadd double %379, %378
store double %380, double* %37
%381 = load i32, i32* %25
%382 = load i32, i32* %13
%383 = mul nsw i32 %381, %382
%384 = load i32, i32* %35
%385 = load i32, i32* %12
%386 = mul nsw i32 %384, %385
%387 = add nsw i32 %383, %386
%388 = load i32, i32* %28
%389 = load i32, i32* %11
%390 = mul nsw i32 %388, %389
%391 = add nsw i32 %387, %390
%392 = load i32, i32* %36
%393 = add nsw i32 %391, %392
store i32 %393, i32* %39
%394 = load double*, double** %32
%395 = load i32, i32* %39
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds double, double* %394, i64 %396
%398 = load double, double* %397
%399 = load double, double* %37
%400 = fadd double %399, %398
store double %400, double* %37
%401 = load double*, double** %33
%402 = load i32, i32* %39
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds double, double* %401, i64 %403
%405 = load double, double* %404
%406 = load double, double* %37
%407 = fadd double %406, %405
store double %407, double* %37
%408 = load i32, i32* %35
%409 = load i32, i32* %13
%410 = mul nsw i32 %408, %409
%411 = load i32, i32* %25
%412 = load i32, i32* %12
%413 = mul nsw i32 %411, %412
%414 = add nsw i32 %410, %413
%415 = load i32, i32* %28
%416 = load i32, i32* %11
%417 = mul nsw i32 %415, %416
%418 = add nsw i32 %414, %417
%419 = load i32, i32* %36
%420 = add nsw i32 %418, %419
store i32 %420, i32* %40
%421 = load double*, double** %34
%422 = load i32, i32* %40
%423 = sext i32 %422 to i64
%424 = getelementptr inbounds double, double* %421, i64 %423
%425 = load double, double* %424
%426 = load double, double* %37
%427 = fadd double %426, %425
store double %427, double* %37
%428 = load double, double* %37
%429 = load double*, double** %26
%430 = load i32, i32* %35
%431 = load i32, i32* %11
%432 = mul nsw i32 %430, %431
%433 = load i32, i32* %36
%434 = add nsw i32 %432, %433
%435 = sext i32 %434 to i64
%436 = getelementptr inbounds double, double* %429, i64 %435
%437 = load double, double* %436
%438 = fadd double %437, %428
store double %438, double* %436
br label %439
439: ; preds = %341
%440 = load i32, i32* %36
%441 = add nsw i32 %440, 1
store i32 %441, i32* %36
br label %337
442: ; preds = %337
br label %443
443: ; preds = %442
%444 = load i32, i32* %35
%445 = add nsw i32 %444, 1
store i32 %445, i32* %35
br label %332
446: ; preds = %332
%447 = load double*, double** %7
%448 = load i32, i32* %25
%449 = load i32, i32* %17
%450 = mul nsw i32 %448, %449
%451 = sext i32 %450 to i64
%452 = getelementptr inbounds double, double* %447, i64 %451
%453 = load i32, i32* %23
%454 = load i32, i32* %16
%455 = mul nsw i32 %453, %454
%456 = sext i32 %455 to i64
%457 = getelementptr inbounds double, double* %452, i64 %456
%458 = load i32, i32* %24
%459 = load i32, i32* %15
%460 = mul nsw i32 %458, %459
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds double, double* %457, i64 %461
%463 = load i32, i32* %28
%464 = load i32, i32* %14
%465 = mul nsw i32 %463, %464
%466 = sext i32 %465 to i64
%467 = getelementptr inbounds double, double* %462, i64 %466
store double* %467, double** %41
%468 = load double*, double** %7
%469 = load i32, i32* %24
%470 = load i32, i32* %17
%471 = mul nsw i32 %469, %470
%472 = sext i32 %471 to i64
%473 = getelementptr inbounds double, double* %468, i64 %472
%474 = load i32, i32* %23
%475 = load i32, i32* %16
%476 = mul nsw i32 %474, %475
%477 = sext i32 %476 to i64
%478 = getelementptr inbounds double, double* %473, i64 %477
%479 = load i32, i32* %28
%480 = load i32, i32* %15
%481 = mul nsw i32 %479, %480
%482 = sext i32 %481 to i64
%483 = getelementptr inbounds double, double* %478, i64 %482
%484 = load i32, i32* %25
%485 = load i32, i32* %14
%486 = mul nsw i32 %484, %485
%487 = sext i32 %486 to i64
%488 = getelementptr inbounds double, double* %483, i64 %487
store double* %488, double** %42
%489 = load double*, double** %7
%490 = load i32, i32* %23
%491 = load i32, i32* %17
%492 = mul nsw i32 %490, %491
%493 = sext i32 %492 to i64
%494 = getelementptr inbounds double, double* %489, i64 %493
%495 = load i32, i32* %28
%496 = load i32, i32* %16
%497 = mul nsw i32 %495, %496
%498 = sext i32 %497 to i64
%499 = getelementptr inbounds double, double* %494, i64 %498
%500 = load i32, i32* %24
%501 = load i32, i32* %15
%502 = mul nsw i32 %500, %501
%503 = sext i32 %502 to i64
%504 = getelementptr inbounds double, double* %499, i64 %503
%505 = load i32, i32* %25
%506 = load i32, i32* %14
%507 = mul nsw i32 %505, %506
%508 = sext i32 %507 to i64
%509 = getelementptr inbounds double, double* %504, i64 %508
store double* %509, double** %43
store i32 0, i32* %44
br label %510
510: ; preds = %627, %446
%511 = load i32, i32* %44
%512 = load i32, i32* %11
%513 = icmp slt i32 %511, %512
br i1 %513, label %514, label %630
514: ; preds = %510
store i32 0, i32* %45
br label %515
515: ; preds = %623, %514
%516 = load i32, i32* %45
%517 = load i32, i32* %11
%518 = icmp slt i32 %516, %517
br i1 %518, label %519, label %626
519: ; preds = %515
store i32 0, i32* %46
br label %520
520: ; preds = %619, %519
%521 = load i32, i32* %46
%522 = load i32, i32* %11
%523 = icmp slt i32 %521, %522
br i1 %523, label %524, label %622
524: ; preds = %520
%525 = load i32, i32* %28
%526 = load i32, i32* %13
%527 = mul nsw i32 %525, %526
%528 = load i32, i32* %44
%529 = load i32, i32* %12
%530 = mul nsw i32 %528, %529
%531 = add nsw i32 %527, %530
%532 = load i32, i32* %45
%533 = load i32, i32* %11
%534 = mul nsw i32 %532, %533
%535 = add nsw i32 %531, %534
%536 = load i32, i32* %46
%537 = add nsw i32 %535, %536
store i32 %537, i32* %47
%538 = load double*, double** %41
%539 = load i32, i32* %47
%540 = sext i32 %539 to i64
%541 = getelementptr inbounds double, double* %538, i64 %540
%542 = load double, double* %541
store double %542, double* %48
%543 = load double*, double** %42
%544 = load i32, i32* %47
%545 = sext i32 %544 to i64
%546 = getelementptr inbounds double, double* %543, i64 %545
%547 = load double, double* %546
%548 = load double, double* %48
%549 = fadd double %548, %547
store double %549, double* %48
%550 = load double*, double** %43
%551 = load i32, i32* %47
%552 = sext i32 %551 to i64
%553 = getelementptr inbounds double, double* %550, i64 %552
%554 = load double, double* %553
%555 = load double, double* %48
%556 = fadd double %555, %554
store double %556, double* %48
%557 = load i32, i32* %44
%558 = load i32, i32* %13
%559 = mul nsw i32 %557, %558
%560 = load i32, i32* %28
%561 = load i32, i32* %12
%562 = mul nsw i32 %560, %561
%563 = add nsw i32 %559, %562
%564 = load i32, i32* %45
%565 = load i32, i32* %11
%566 = mul nsw i32 %564, %565
%567 = add nsw i32 %563, %566
%568 = load i32, i32* %46
%569 = add nsw i32 %567, %568
store i32 %569, i32* %49
%570 = load double*, double** %32
%571 = load i32, i32* %49
%572 = sext i32 %571 to i64
%573 = getelementptr inbounds double, double* %570, i64 %572
%574 = load double, double* %573
%575 = load double, double* %48
%576 = fadd double %575, %574
store double %576, double* %48
%577 = load double*, double** %30
%578 = load i32, i32* %49
%579 = sext i32 %578 to i64
%580 = getelementptr inbounds double, double* %577, i64 %579
%581 = load double, double* %580
%582 = load double, double* %48
%583 = fadd double %582, %581
store double %583, double* %48
%584 = load i32, i32* %44
%585 = load i32, i32* %13
%586 = mul nsw i32 %584, %585
%587 = load i32, i32* %45
%588 = load i32, i32* %12
%589 = mul nsw i32 %587, %588
%590 = add nsw i32 %586, %589
%591 = load i32, i32* %28
%592 = load i32, i32* %11
%593 = mul nsw i32 %591, %592
%594 = add nsw i32 %590, %593
%595 = load i32, i32* %46
%596 = add nsw i32 %594, %595
store i32 %596, i32* %50
%597 = load double*, double** %34
%598 = load i32, i32* %50
%599 = sext i32 %598 to i64
%600 = getelementptr inbounds double, double* %597, i64 %599
%601 = load double, double* %600
%602 = load double, double* %48
%603 = fadd double %602, %601
store double %603, double* %48
%604 = load double, double* %48
%605 = load double*, double** %27
%606 = load i32, i32* %44
%607 = load i32, i32* %12
%608 = mul nsw i32 %606, %607
%609 = load i32, i32* %45
%610 = load i32, i32* %11
%611 = mul nsw i32 %609, %610
%612 = add nsw i32 %608, %611
%613 = load i32, i32* %46
%614 = add nsw i32 %612, %613
%615 = sext i32 %614 to i64
%616 = getelementptr inbounds double, double* %605, i64 %615
%617 = load double, double* %616
%618 = fadd double %617, %604
store double %618, double* %616
br label %619
619: ; preds = %524
%620 = load i32, i32* %46
%621 = add nsw i32 %620, 1
store i32 %621, i32* %46
br label %520
622: ; preds = %520
br label %623
623: ; preds = %622
%624 = load i32, i32* %45
%625 = add nsw i32 %624, 1
store i32 %625, i32* %45
br label %515
626: ; preds = %515
br label %627
627: ; preds = %626
%628 = load i32, i32* %44
%629 = add nsw i32 %628, 1
store i32 %629, i32* %44
br label %510
630: ; preds = %510
br label %631
631: ; preds = %630
%632 = load i32, i32* %28
%633 = add nsw i32 %632, 1
store i32 %633, i32* %28
br label %201
634: ; preds = %201
br label %635
635: ; preds = %634
%636 = load i32, i32* %25
%637 = add nsw i32 %636, 1
store i32 %637, i32* %25
br label %169
638: ; preds = %169
br label %639
639: ; preds = %638
%640 = load i32, i32* %24
%641 = add nsw i32 %640, 1
store i32 %641, i32* %24
br label %164
642: ; preds = %164
br label %643
643: ; preds = %642
%644 = load i32, i32* %23
%645 = add nsw i32 %644, 1
store i32 %645, i32* %23
br label %159
646: ; preds = %159
ret void
}

LLVM IR (-O2):
define void @make_nh123_real(i32 %0, double* nocapture %1, double* nocapture %2, double* nocapture %3, double* nocapture %4) {
%6 = shl i32 %0, 1
%7 = mul i32 %6, %6
%8 = mul i32 %7, %6
%9 = mul nsw i32 %8, %6
%10 = mul nsw i32 %9, %6
%11 = mul nsw i32 %10, %6
%12 = mul nsw i32 %11, %6
%13 = icmp sgt i32 %0, 0
br i1 %13, label %14, label %313
14: ; preds = %5
%15 = add i32 %9, %6
%16 = add i32 %11, %8
%17 = add i32 %10, %7
%18 = call i32 @llvm.smax.i32(i32 %6, i32 1)
%19 = sext i32 %6 to i64
%20 = zext i32 %18 to i64
%21 = add nsw i64 %20, -1
%22 = zext i32 %17 to i64
%23 = zext i32 %16 to i64
%24 = zext i32 %15 to i64
%25 = mul i32 %0, %0
%26 = mul i32 %25, %0
%27 = mul i32 %25, %25
%28 = mul i32 %26, %27
%29 = shl i32 %28, 7
%30 = zext i32 %29 to i64
%31 = zext i32 %17 to i64
%32 = zext i32 %16 to i64
%33 = zext i32 %15 to i64
%34 = mul i32 %0, %0
%35 = mul i32 %34, %0
%36 = mul i32 %34, %34
%37 = mul i32 %35, %36
%38 = shl i32 %37, 7
%39 = zext i32 %38 to i64
%40 = getelementptr double, double* %1, i64 %20
%41 = and i64 %20, 2147483644
%42 = add nsw i64 %41, -4
%43 = lshr exact i64 %42, 2
%44 = add nuw nsw i64 %43, 1
%45 = icmp ult i32 %18, 4
%46 = trunc i64 %21 to i32
%47 = icmp ugt i64 %21, 4294967295
%48 = and i64 %20, 2147483644
%49 = and i64 %44, 1
%50 = icmp eq i64 %42, 0
%51 = and i64 %44, 9223372036854775806
%52 = icmp eq i64 %49, 0
%53 = icmp eq i64 %48, %20
%54 = and i64 %20, 1
%55 = icmp eq i64 %54, 0
%56 = sub nsw i64 0, %20
br label %57
57: ; preds = %126, %14
%58 = phi i64 [ %129, %126 ], [ 0, %14 ]
%59 = phi i32 [ %127, %126 ], [ 0, %14 ]
%60 = mul i64 %58, %31
%61 = mul i64 %58, %22
%62 = mul i32 %59, %17
br label %117
63: ; preds = %126
br i1 %13, label %64, label %313
64: ; preds = %63
%65 = call i32 @llvm.smax.i32(i32 %6, i32 1)
%66 = sext i32 %6 to i64
%67 = sext i32 %8 to i64
%68 = sext i32 %11 to i64
%69 = sext i32 %10 to i64
%70 = sext i32 %9 to i64
%71 = sext i32 %12 to i64
%72 = zext i32 %65 to i64
%73 = add nsw i64 %20, -1
%74 = mul i32 %0, %0
%75 = shl i32 %74, 2
%76 = shl i32 %0, 1
%77 = mul i32 %0, %0
%78 = mul i32 %77, %0
%79 = shl i32 %78, 3
%80 = mul i32 %0, %0
%81 = shl i32 %80, 2
%82 = mul i32 %0, %0
%83 = shl i32 %82, 2
%84 = shl i32 %0, 1
%85 = mul i32 %0, %0
%86 = mul i32 %85, %0
%87 = shl i32 %86, 3
%88 = mul i32 %0, %0
%89 = shl i32 %88, 2
%90 = add nsw i64 %20, -1
%91 = zext i32 %7 to i64
%92 = zext i32 %8 to i64
%93 = zext i32 %6 to i64
%94 = zext i32 %7 to i64
%95 = zext i32 %6 to i64
%96 = zext i32 %8 to i64
%97 = icmp ult i32 %18, 2
%98 = trunc i64 %90 to i32
%99 = icmp ugt i64 %90, 4294967295
%100 = trunc i64 %90 to i32
%101 = icmp ugt i64 %90, 4294967295
%102 = trunc i64 %90 to i32
%103 = icmp ugt i64 %90, 4294967295
%104 = and i64 %20, 2147483646
%105 = icmp eq i64 %104, %20
%106 = icmp ult i32 %18, 2
%107 = trunc i64 %73 to i32
%108 = icmp ugt i64 %73, 4294967295
%109 = trunc i64 %73 to i32
%110 = icmp ugt i64 %73, 4294967295
%111 = trunc i64 %73 to i32
%112 = icmp ugt i64 %73, 4294967295
%113 = trunc i64 %73 to i32
%114 = icmp ugt i64 %73, 4294967295
%115 = and i64 %20, 2147483646
%116 = icmp eq i64 %115, %20
br label %289
117: ; preds = %139, %57
%118 = phi i64 [ %142, %139 ], [ 0, %57 ]
%119 = phi i32 [ %140, %139 ], [ 0, %57 ]
%120 = mul i64 %118, %32
%121 = add i64 %60, %120
%122 = mul i64 %118, %23
%123 = add i64 %61, %122
%124 = mul i32 %119, %16
%125 = add i32 %124, %62
br label %130
126: ; preds = %139
%127 = add nuw nsw i32 %59, 1
%128 = icmp eq i32 %127, %18
%129 = add i64 %58, 1
br i1 %128, label %63, label %57
130: ; preds = %259, %117
%131 = phi i64 [ %262, %259 ], [ 0, %117 ]
%132 = phi i32 [ %260, %259 ], [ 0, %117 ]
%133 = mul i64 %131, %33
%134 = add i64 %121, %133
%135 = mul i64 %131, %24
%136 = add i64 %123, %135
%137 = mul i32 %132, %15
%138 = add i32 %125, %137
br label %143
139: ; preds = %259
%140 = add nuw nsw i32 %119, 1
%141 = icmp eq i32 %140, %18
%142 = add i64 %118, 1
br i1 %141, label %126, label %117
143: ; preds = %263, %130
%144 = phi i64 [ 0, %130 ], [ %264, %263 ]
%145 = mul i64 %144, %19
%146 = getelementptr double, double* %2, i64 %145
%147 = add i64 %145, %20
%148 = getelementptr double, double* %2, i64 %147
%149 = mul i64 %144, %39
%150 = add i64 %134, %149
%151 = shl i64 %150, 32
%152 = ashr exact i64 %151, 32
%153 = getelementptr double, double* %1, i64 %152
%154 = getelementptr double, double* %40, i64 %152
%155 = mul i64 %144, %30
%156 = add i64 %136, %155
%157 = trunc i64 %156 to i32
%158 = trunc i64 %144 to i32
%159 = mul i32 %12, %158
%160 = add i32 %138, %159
%161 = mul nsw i64 %144, %19
br i1 %45, label %242, label %162
162: ; preds = %143
%163 = add i32 %157, %46
%164 = icmp slt i32 %163, %157
%165 = or i1 %164, %47
br i1 %165, label %242, label %166
166: ; preds = %162
%167 = icmp ult double* %146, %154
%168 = icmp ult double* %153, %148
%169 = and i1 %167, %168
br i1 %169, label %242, label %170
170: ; preds = %166
br i1 %50, label %218, label %171
171: ; preds = %170, %171
%172 = phi i64 [ %215, %171 ], [ 0, %170 ]
%173 = phi i64 [ %216, %171 ], [ 0, %170 ]
%174 = trunc i64 %172 to i32
%175 = add i32 %160, %174
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds double, double* %1, i64 %176
%178 = bitcast double* %177 to <2 x double>*
%179 = load <2 x double>, <2 x double>* %178
%180 = getelementptr inbounds double, double* %177, i64 2
%181 = bitcast double* %180 to <2 x double>*
%182 = load <2 x double>, <2 x double>* %181
%183 = add nsw i64 %172, %161
%184 = getelementptr inbounds double, double* %2, i64 %183
%185 = bitcast double* %184 to <2 x double>*
%186 = load <2 x double>, <2 x double>* %185
%187 = getelementptr inbounds double, double* %184, i64 2
%188 = bitcast double* %187 to <2 x double>*
%189 = load <2 x double>, <2 x double>* %188
%190 = fsub <2 x double> %186, %179
%191 = fsub <2 x double> %189, %182
%192 = bitcast double* %184 to <2 x double>*
store <2 x double> %190, <2 x double>* %192
%193 = bitcast double* %187 to <2 x double>*
store <2 x double> %191, <2 x double>* %193
%194 = or i64 %172, 4
%195 = trunc i64 %194 to i32
%196 = add i32 %160, %195
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds double, double* %1, i64 %197
%199 = bitcast double* %198 to <2 x double>*
%200 = load <2 x double>, <2 x double>* %199
%201 = getelementptr inbounds double, double* %198, i64 2
%202 = bitcast double* %201 to <2 x double>*
%203 = load <2 x double>, <2 x double>* %202
%204 = add nsw i64 %194, %161
%205 = getelementptr inbounds double, double* %2, i64 %204
%206 = bitcast double* %205 to <2 x double>*
%207 = load <2 x double>, <2 x double>* %206
%208 = getelementptr inbounds double, double* %205, i64 2
%209 = bitcast double* %208 to <2 x double>*
%210 = load <2 x double>, <2 x double>* %209
%211 = fsub <2 x double> %207, %200
%212 = fsub <2 x double> %210, %203
%213 = bitcast double* %205 to <2 x double>*
store <2 x double> %211, <2 x double>* %213
%214 = bitcast double* %208 to <2 x double>*
store <2 x double> %212, <2 x double>* %214
%215 = add nuw i64 %172, 8
%216 = add i64 %173, 2
%217 = icmp eq i64 %216, %51
br i1 %217, label %218, label %171
218: ; preds = %171, %170
%219 = phi i64 [ 0, %170 ], [ %215, %171 ]
br i1 %52, label %241, label %220
220: ; preds = %218
%221 = trunc i64 %219 to i32
%222 = add i32 %160, %221
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds double, double* %1, i64 %223
%225 = bitcast double* %224 to <2 x double>*
%226 = load <2 x double>, <2 x double>* %225
%227 = getelementptr inbounds double, double* %224, i64 2
%228 = bitcast double* %227 to <2 x double>*
%229 = load <2 x double>, <2 x double>* %228
%230 = add nsw i64 %219, %161
%231 = getelementptr inbounds double, double* %2, i64 %230
%232 = bitcast double* %231 to <2 x double>*
%233 = load <2 x double>, <2 x double>* %232
%234 = getelementptr inbounds double, double* %231, i64 2
%235 = bitcast double* %234 to <2 x double>*
%236 = load <2 x double>, <2 x double>* %235
%237 = fsub <2 x double> %233, %226
%238 = fsub <2 x double> %236, %229
%239 = bitcast double* %231 to <2 x double>*
store <2 x double> %237, <2 x double>* %239
%240 = bitcast double* %234 to <2 x double>*
store <2 x double> %238, <2 x double>* %240
br label %241
241: ; preds = %218, %220
br i1 %53, label %263, label %242
242: ; preds = %166, %162, %143, %241
%243 = phi i64 [ 0, %166 ], [ 0, %162 ], [ 0, %143 ], [ %48, %241 ]
%244 = xor i64 %243, -1
br i1 %55, label %256, label %245
245: ; preds = %242
%246 = trunc i64 %243 to i32
%247 = add i32 %160, %246
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds double, double* %1, i64 %248
%250 = load double, double* %249
%251 = add nsw i64 %243, %161
%252 = getelementptr inbounds double, double* %2, i64 %251
%253 = load double, double* %252
%254 = fsub double %253, %250
store double %254, double* %252
%255 = or i64 %243, 1
br label %256
256: ; preds = %245, %242
%257 = phi i64 [ %243, %242 ], [ %255, %245 ]
%258 = icmp eq i64 %244, %56
br i1 %258, label %263, label %266
259: ; preds = %263
%260 = add nuw nsw i32 %132, 1
%261 = icmp eq i32 %260, %18
%262 = add i64 %131, 1
br i1 %261, label %139, label %130
263: ; preds = %256, %266, %241
%264 = add nuw nsw i64 %144, 1
%265 = icmp eq i64 %264, %20
br i1 %265, label %259, label %143
266: ; preds = %256, %266
%267 = phi i64 [ %287, %266 ], [ %257, %256 ]
%268 = trunc i64 %267 to i32
%269 = add i32 %160, %268
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds double, double* %1, i64 %270
%272 = load double, double* %271
%273 = add nsw i64 %267, %161
%274 = getelementptr inbounds double, double* %2, i64 %273
%275 = load double, double* %274
%276 = fsub double %275, %272
store double %276, double* %274
%277 = add nuw nsw i64 %267, 1
%278 = trunc i64 %277 to i32
%279 = add i32 %160, %278
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds double, double* %1, i64 %280
%282 = load double, double* %281
%283 = add nsw i64 %277, %161
%284 = getelementptr inbounds double, double* %2, i64 %283
%285 = load double, double* %284
%286 = fsub double %285, %282
store double %286, double* %284
%287 = add nuw nsw i64 %267, 2
%288 = icmp eq i64 %287, %20
br i1 %288, label %263, label %266
289: ; preds = %364, %64
%290 = phi i64 [ 0, %64 ], [ %365, %364 ]
%291 = mul i64 %290, %67
%292 = add i64 %291, %20
%293 = mul i64 %290, %71
%294 = add i64 %293, %20
%295 = mul i64 %290, %68
%296 = add i64 %295, %20
%297 = mul i64 %290, %69
%298 = add i64 %297, %20
%299 = mul i64 %290, %69
%300 = add i64 %299, %20
%301 = mul i64 %290, %71
%302 = add i64 %301, %20
%303 = mul i64 %290, %68
%304 = add i64 %303, %20
%305 = mul nsw i64 %290, %67
%306 = getelementptr inbounds double, double* %3, i64 %305
%307 = mul nsw i64 %290, %69
%308 = getelementptr inbounds double, double* %4, i64 %307
%309 = mul nsw i64 %290, %71
%310 = getelementptr inbounds double, double* %1, i64 %309
%311 = mul nsw i64 %290, %68
%312 = getelementptr inbounds double, double* %1, i64 %311
br label %314
313: ; preds = %364, %5, %63
ret void
314: ; preds = %367, %289
%315 = phi i64 [ 0, %289 ], [ %368, %367 ]
%316 = trunc i64 %315 to i32
%317 = mul i32 %7, %316
%318 = zext i32 %317 to i64
%319 = add i64 %291, %318
%320 = add i64 %292, %318
%321 = mul i64 %315, %68
%322 = add i64 %293, %321
%323 = add i64 %294, %321
%324 = mul i64 %315, %71
%325 = add i64 %295, %324
%326 = add i64 %296, %324
%327 = mul i64 %315, %69
%328 = add i64 %293, %327
%329 = add i64 %294, %327
%330 = mul i64 %315, %70
%331 = add i64 %293, %330
%332 = add i64 %294, %330
%333 = add i64 %297, %324
%334 = add i64 %298, %324
%335 = mul i64 %315, %70
%336 = add i64 %299, %335
%337 = add i64 %300, %335
%338 = mul i64 %315, %68
%339 = add i64 %301, %338
%340 = add i64 %302, %338
%341 = mul i64 %315, %69
%342 = add i64 %301, %341
%343 = add i64 %302, %341
%344 = mul i64 %315, %71
%345 = add i64 %303, %344
%346 = add i64 %304, %344
%347 = add i64 %303, %341
%348 = add i64 %304, %341
%349 = trunc i64 %315 to i32
%350 = mul i32 %7, %349
%351 = zext i32 %350 to i64
%352 = getelementptr inbounds double, double* %306, i64 %351
%353 = mul nsw i64 %315, %70
%354 = getelementptr inbounds double, double* %308, i64 %353
%355 = mul nsw i64 %315, %71
%356 = getelementptr inbounds double, double* %1, i64 %355
%357 = mul nsw i64 %315, %68
%358 = getelementptr inbounds double, double* %310, i64 %357
%359 = mul nsw i64 %315, %69
%360 = getelementptr inbounds double, double* %356, i64 %311
%361 = getelementptr inbounds double, double* %310, i64 %359
%362 = getelementptr inbounds double, double* %312, i64 %359
%363 = getelementptr inbounds double, double* %356, i64 %307
br label %370
364: ; preds = %367
%365 = add nuw nsw i64 %290, 1
%366 = icmp eq i64 %365, %72
br i1 %366, label %313, label %289
367: ; preds = %428
%368 = add nuw nsw i64 %315, 1
%369 = icmp eq i64 %368, %72
br i1 %369, label %364, label %314
370: ; preds = %428, %314
%371 = phi i64 [ 0, %314 ], [ %429, %428 ]
%372 = mul i64 %371, %69
%373 = add i64 %322, %372
%374 = mul i64 %371, %94
%375 = add i64 %323, %372
%376 = add i64 %325, %372
%377 = mul i64 %371, %96
%378 = add i64 %326, %372
%379 = mul i64 %371, %68
%380 = add i64 %328, %379
%381 = add i64 %329, %379
%382 = add i64 %331, %372
%383 = add i64 %332, %372
%384 = mul i64 %371, %70
%385 = add i64 %322, %384
%386 = add i64 %323, %384
%387 = add i64 %333, %384
%388 = add i64 %334, %384
%389 = mul i64 %371, %91
%390 = mul i64 %371, %92
%391 = mul i64 %371, %67
%392 = add i64 %336, %391
%393 = getelementptr double, double* %4, i64 %392
%394 = add i64 %337, %391
%395 = getelementptr double, double* %4, i64 %394
%396 = mul i64 %371, %69
%397 = add i64 %339, %396
%398 = add i64 %340, %396
%399 = mul i64 %371, %70
%400 = add i64 %339, %399
%401 = add i64 %340, %399
%402 = mul i64 %371, %68
%403 = add i64 %342, %402
%404 = add i64 %343, %402
%405 = add i64 %342, %399
%406 = add i64 %343, %399
%407 = add i64 %345, %399
%408 = add i64 %346, %399
%409 = mul i64 %371, %71
%410 = add i64 %347, %409
%411 = add i64 %348, %409
%412 = mul nsw i64 %371, %67
%413 = getelementptr inbounds double, double* %354, i64 %412
%414 = mul nsw i64 %371, %70
%415 = mul nsw i64 %371, %69
%416 = mul nsw i64 %371, %68
%417 = getelementptr inbounds double, double* %361, i64 %416
%418 = getelementptr inbounds double, double* %360, i64 %415
%419 = getelementptr inbounds double, double* %358, i64 %415
%420 = mul nsw i64 %371, %71
%421 = getelementptr inbounds double, double* %362, i64 %420
%422 = getelementptr inbounds double, double* %363, i64 %414
%423 = getelementptr inbounds double, double* %358, i64 %414
%424 = trunc i64 %371 to i32
%425 = mul i32 %7, %424
%426 = trunc i64 %412 to i32
%427 = getelementptr inbounds double, double* %360, i64 %414
br label %431
428: ; preds = %732
%429 = add nuw nsw i64 %371, 1
%430 = icmp eq i64 %429, %72
br i1 %430, label %367, label %370
431: ; preds = %732, %370
%432 = phi i64 [ 0, %370 ], [ %733, %732 ]
%433 = mul i64 %432, %70
%434 = add i64 %373, %433
%435 = getelementptr double, double* %1, i64 %434
%436 = mul i64 %432, %95
%437 = add i64 %374, %436
%438 = add i64 %375, %433
%439 = getelementptr double, double* %1, i64 %438
%440 = add i64 %376, %433
%441 = getelementptr double, double* %1, i64 %440
%442 = add i64 %377, %436
%443 = add i64 %378, %433
%444 = getelementptr double, double* %1, i64 %443
%445 = add i64 %380, %433
%446 = getelementptr double, double* %1, i64 %445
%447 = add i64 %381, %433
%448 = getelementptr double, double* %1, i64 %447
%449 = mul i64 %432, %96
%450 = add i64 %374, %449
%451 = mul i64 %432, %68
%452 = add i64 %382, %451
%453 = getelementptr double, double* %1, i64 %452
%454 = add i64 %383, %451
%455 = getelementptr double, double* %1, i64 %454
%456 = mul i64 %432, %69
%457 = add i64 %385, %456
%458 = getelementptr double, double* %1, i64 %457
%459 = add i64 %386, %456
%460 = getelementptr double, double* %1, i64 %459
%461 = add i64 %387, %451
%462 = getelementptr double, double* %1, i64 %461
%463 = add i64 %388, %451
%464 = getelementptr double, double* %1, i64 %463
%465 = mul i64 %432, %92
%466 = add i64 %389, %465
%467 = mul i64 %432, %93
%468 = add i64 %390, %467
%469 = add i64 %389, %467
%470 = mul i64 %432, %70
%471 = add i64 %397, %470
%472 = getelementptr double, double* %1, i64 %471
%473 = trunc i64 %432 to i32
%474 = mul i32 %6, %473
%475 = add i64 %398, %470
%476 = getelementptr double, double* %1, i64 %475
%477 = mul i64 %432, %69
%478 = add i64 %400, %477
%479 = getelementptr double, double* %1, i64 %478
%480 = trunc i64 %432 to i32
%481 = mul i32 %7, %480
%482 = add i64 %401, %477
%483 = getelementptr double, double* %1, i64 %482
%484 = add i64 %403, %470
%485 = getelementptr double, double* %1, i64 %484
%486 = add i64 %404, %470
%487 = getelementptr double, double* %1, i64 %486
%488 = mul i64 %432, %68
%489 = add i64 %405, %488
%490 = getelementptr double, double* %1, i64 %489
%491 = trunc i64 %432 to i32
%492 = mul i32 %8, %491
%493 = add i64 %406, %488
%494 = getelementptr double, double* %1, i64 %493
%495 = add i64 %407, %477
%496 = getelementptr double, double* %1, i64 %495
%497 = add i64 %408, %477
%498 = getelementptr double, double* %1, i64 %497
%499 = add i64 %410, %470
%500 = getelementptr double, double* %1, i64 %499
%501 = add i64 %411, %470
%502 = getelementptr double, double* %1, i64 %501
%503 = trunc i64 %432 to i32
%504 = mul i32 %8, %503
%505 = trunc i64 %432 to i32
%506 = mul i32 %7, %505
%507 = trunc i64 %432 to i32
%508 = mul i32 %6, %507
%509 = mul nsw i64 %432, %68
%510 = getelementptr inbounds double, double* %422, i64 %509
%511 = mul nsw i64 %432, %69
%512 = getelementptr inbounds double, double* %423, i64 %511
%513 = getelementptr inbounds double, double* %310, i64 %509
%514 = getelementptr inbounds double, double* %513, i64 %415
%515 = getelementptr inbounds double, double* %514, i64 %353
%516 = mul nsw i64 %432, %70
%517 = getelementptr inbounds double, double* %417, i64 %516
%518 = getelementptr inbounds double, double* %418, i64 %516
%519 = getelementptr inbounds double, double* %419, i64 %516
%520 = trunc i64 %432 to i32
%521 = mul i32 %8, %520
%522 = trunc i64 %432 to i32
%523 = mul i32 %6, %522
br label %524
524: ; preds = %675, %431
%525 = phi i64 [ 0, %431 ], [ %676, %675 ]
%526 = mul i64 %525, %19
%527 = add i64 %319, %526
%528 = getelementptr double, double* %3, i64 %527
%529 = add i64 %320, %526
%530 = getelementptr double, double* %3, i64 %529
%531 = mul i64 %525, %96
%532 = add i64 %437, %531
%533 = shl i64 %532, 32
%534 = ashr exact i64 %533, 32
%535 = getelementptr double, double* %435, i64 %534
%536 = getelementptr double, double* %439, i64 %534
%537 = mul i64 %525, %94
%538 = add i64 %442, %537
%539 = shl i64 %538, 32
%540 = ashr exact i64 %539, 32
%541 = getelementptr double, double* %441, i64 %540
%542 = getelementptr double, double* %444, i64 %540
%543 = getelementptr double, double* %446, i64 %540
%544 = getelementptr double, double* %448, i64 %540
%545 = mul i64 %525, %95
%546 = add i64 %450, %545
%547 = shl i64 %546, 32
%548 = ashr exact i64 %547, 32
%549 = getelementptr double, double* %441, i64 %548
%550 = getelementptr double, double* %444, i64 %548
%551 = getelementptr double, double* %453, i64 %548
%552 = getelementptr double, double* %455, i64 %548
%553 = getelementptr double, double* %458, i64 %548
%554 = getelementptr double, double* %460, i64 %548
%555 = getelementptr double, double* %462, i64 %548
%556 = getelementptr double, double* %464, i64 %548
%557 = mul i64 %525, %93
%558 = add i64 %466, %557
%559 = trunc i64 %558 to i32
%560 = mul i64 %525, %91
%561 = add i64 %468, %560
%562 = trunc i64 %561 to i32
%563 = mul i64 %525, %92
%564 = add i64 %469, %563
%565 = trunc i64 %564 to i32
%566 = mul nsw i64 %525, %66
%567 = trunc i64 %566 to i32
%568 = trunc i64 %525 to i32
%569 = mul i32 %7, %568
%570 = trunc i64 %525 to i32
%571 = mul i32 %8, %570
br i1 %97, label %662, label %572
572: ; preds = %524
%573 = add i32 %559, %98
%574 = icmp slt i32 %573, %559
%575 = or i1 %574, %99
%576 = add i32 %562, %100
%577 = icmp slt i32 %576, %562
%578 = or i1 %577, %101
%579 = add i32 %565, %102
%580 = icmp slt i32 %579, %565
%581 = or i1 %580, %103
%582 = or i1 %575, %578
%583 = or i1 %582, %581
br i1 %583, label %662, label %584
584: ; preds = %572
%585 = icmp ult double* %528, %536
%586 = icmp ult double* %535, %530
%587 = and i1 %585, %586
%588 = icmp ult double* %528, %542
%589 = icmp ult double* %541, %530
%590 = and i1 %588, %589
%591 = or i1 %587, %590
%592 = icmp ult double* %528, %544
%593 = icmp ult double* %543, %530
%594 = and i1 %592, %593
%595 = or i1 %591, %594
%596 = icmp ult double* %528, %550
%597 = icmp ult double* %549, %530
%598 = and i1 %596, %597
%599 = or i1 %595, %598
%600 = icmp ult double* %528, %552
%601 = icmp ult double* %551, %530
%602 = and i1 %600, %601
%603 = or i1 %599, %602
%604 = icmp ult double* %528, %554
%605 = icmp ult double* %553, %530
%606 = and i1 %604, %605
%607 = or i1 %603, %606
%608 = icmp ult double* %528, %556
%609 = icmp ult double* %555, %530
%610 = and i1 %608, %609
%611 = or i1 %607, %610
br i1 %611, label %662, label %612
612: ; preds = %584, %612
%613 = phi i64 [ %659, %612 ], [ 0, %584 ]
%614 = trunc i64 %613 to i32
%615 = add i32 %614, %567
%616 = add i32 %615, %425
%617 = add i32 %616, %521
%618 = sext i32 %617 to i64
%619 = getelementptr inbounds double, double* %510, i64 %618
%620 = bitcast double* %619 to <2 x double>*
%621 = load <2 x double>, <2 x double>* %620
%622 = getelementptr inbounds double, double* %512, i64 %618
%623 = bitcast double* %622 to <2 x double>*
%624 = load <2 x double>, <2 x double>* %623
%625 = fadd <2 x double> %621, %624
%626 = getelementptr inbounds double, double* %515, i64 %618
%627 = bitcast double* %626 to <2 x double>*
%628 = load <2 x double>, <2 x double>* %627
%629 = fadd <2 x double> %625, %628
%630 = getelementptr inbounds double, double* %518, i64 %618
%631 = bitcast double* %630 to <2 x double>*
%632 = load <2 x double>, <2 x double>* %631
%633 = fadd <2 x double> %629, %632
%634 = add i32 %523, %614
%635 = add i32 %634, %426
%636 = add i32 %635, %569
%637 = sext i32 %636 to i64
%638 = getelementptr inbounds double, double* %517, i64 %637
%639 = bitcast double* %638 to <2 x double>*
%640 = load <2 x double>, <2 x double>* %639
%641 = fadd <2 x double> %633, %640
%642 = getelementptr inbounds double, double* %518, i64 %637
%643 = bitcast double* %642 to <2 x double>*
%644 = load <2 x double>, <2 x double>* %643
%645 = fadd <2 x double> %641, %644
%646 = add i32 %634, %425
%647 = add i32 %646, %571
%648 = sext i32 %647 to i64
%649 = getelementptr inbounds double, double* %519, i64 %648
%650 = bitcast double* %649 to <2 x double>*
%651 = load <2 x double>, <2 x double>* %650
%652 = fadd <2 x double> %645, %651
%653 = add nsw i64 %613, %566
%654 = getelementptr inbounds double, double* %352, i64 %653
%655 = bitcast double* %654 to <2 x double>*
%656 = load <2 x double>, <2 x double>* %655
%657 = fadd <2 x double> %656, %652
%658 = bitcast double* %654 to <2 x double>*
store <2 x double> %657, <2 x double>* %658
%659 = add nuw i64 %613, 2
%660 = icmp eq i64 %659, %104
br i1 %660, label %661, label %612
661: ; preds = %612
br i1 %105, label %675, label %662
662: ; preds = %584, %572, %524, %661
%663 = phi i64 [ 0, %584 ], [ 0, %572 ], [ 0, %524 ], [ %104, %661 ]
br label %678
664: ; preds = %675
%665 = getelementptr inbounds double, double* %421, i64 %516
%666 = getelementptr inbounds double, double* %427, i64 %511
%667 = getelementptr inbounds double, double* %513, i64 %359
%668 = getelementptr inbounds double, double* %667, i64 %414
%669 = trunc i64 %432 to i32
%670 = mul i32 %8, %669
%671 = trunc i64 %432 to i32
%672 = mul i32 %7, %671
%673 = trunc i64 %432 to i32
%674 = mul i32 %6, %673
br label %718
675: ; preds = %678, %661
%676 = add nuw nsw i64 %525, 1
%677 = icmp eq i64 %676, %72
br i1 %677, label %664, label %524
678: ; preds = %662, %678
%679 = phi i64 [ %716, %678 ], [ %663, %662 ]
%680 = trunc i64 %679 to i32
%681 = add i32 %680, %567
%682 = add i32 %681, %425
%683 = add i32 %682, %521
%684 = sext i32 %683 to i64
%685 = getelementptr inbounds double, double* %510, i64 %684
%686 = load double, double* %685
%687 = getelementptr inbounds double, double* %512, i64 %684
%688 = load double, double* %687
%689 = fadd double %686, %688
%690 = getelementptr inbounds double, double* %515, i64 %684
%691 = load double, double* %690
%692 = fadd double %689, %691
%693 = getelementptr inbounds double, double* %518, i64 %684
%694 = load double, double* %693
%695 = fadd double %692, %694
%696 = add i32 %523, %680
%697 = add i32 %696, %426
%698 = add i32 %697, %569
%699 = sext i32 %698 to i64
%700 = getelementptr inbounds double, double* %517, i64 %699
%701 = load double, double* %700
%702 = fadd double %695, %701
%703 = getelementptr inbounds double, double* %518, i64 %699
%704 = load double, double* %703
%705 = fadd double %702, %704
%706 = add i32 %696, %425
%707 = add i32 %706, %571
%708 = sext i32 %707 to i64
%709 = getelementptr inbounds double, double* %519, i64 %708
%710 = load double, double* %709
%711 = fadd double %705, %710
%712 = add nsw i64 %679, %566
%713 = getelementptr inbounds double, double* %352, i64 %712
%714 = load double, double* %713
%715 = fadd double %714, %711
store double %715, double* %713
%716 = add nuw nsw i64 %679, 1
%717 = icmp eq i64 %716, %72
br i1 %717, label %675, label %678
718: ; preds = %858, %664
%719 = phi i32 [ 0, %664 ], [ %859, %858 ]
%720 = mul i32 %83, %719
%721 = mul i32 %87, %719
%722 = add i32 %474, %721
%723 = add i32 %481, %721
%724 = add i32 %492, %720
%725 = mul i32 %75, %719
%726 = add i32 %504, %725
%727 = mul i32 %79, %719
%728 = add i32 %506, %727
%729 = add i32 %508, %727
%730 = mul nsw i32 %719, %7
%731 = mul nsw i32 %719, %8
br label %735
732: ; preds = %858
%733 = add nuw nsw i64 %432, 1
%734 = icmp eq i64 %733, %72
br i1 %734, label %428, label %431
735: ; preds = %861, %718
%736 = phi i32 [ 0, %718 ], [ %862, %861 ]
%737 = mul i32 %84, %736
%738 = add i32 %720, %737
%739 = sext i32 %738 to i64
%740 = getelementptr double, double* %393, i64 %739
%741 = getelementptr double, double* %395, i64 %739
%742 = mul i32 %89, %736
%743 = add i32 %722, %742
%744 = sext i32 %743 to i64
%745 = getelementptr double, double* %472, i64 %744
%746 = getelementptr double, double* %476, i64 %744
%747 = add i32 %723, %737
%748 = sext i32 %747 to i64
%749 = getelementptr double, double* %479, i64 %748
%750 = getelementptr double, double* %483, i64 %748
%751 = getelementptr double, double* %485, i64 %748
%752 = getelementptr double, double* %487, i64 %748
%753 = add i32 %724, %737
%754 = sext i32 %753 to i64
%755 = getelementptr double, double* %490, i64 %754
%756 = getelementptr double, double* %494, i64 %754
%757 = getelementptr double, double* %496, i64 %754
%758 = getelementptr double, double* %498, i64 %754
%759 = getelementptr double, double* %500, i64 %754
%760 = getelementptr double, double* %502, i64 %754
%761 = mul i32 %76, %736
%762 = add i32 %725, %761
%763 = add i32 %726, %761
%764 = add i32 %728, %761
%765 = mul i32 %81, %736
%766 = add i32 %729, %765
%767 = mul nsw i32 %736, %6
%768 = mul nsw i32 %736, %7
br i1 %106, label %856, label %769
769: ; preds = %735
%770 = add i32 %762, %107
%771 = icmp slt i32 %770, %762
%772 = or i1 %771, %108
%773 = add i32 %763, %109
%774 = icmp slt i32 %773, %763
%775 = or i1 %774, %110
%776 = add i32 %764, %111
%777 = icmp slt i32 %776, %764
%778 = or i1 %777, %112
%779 = add i32 %766, %113
%780 = icmp slt i32 %779, %766
%781 = or i1 %780, %114
%782 = or i1 %772, %775
%783 = or i1 %782, %778
%784 = or i1 %783, %781
br i1 %784, label %856, label %785
785: ; preds = %769
%786 = icmp ult double* %740, %746
%787 = icmp ult double* %745, %741
%788 = and i1 %786, %787
%789 = icmp ult double* %740, %750
%790 = icmp ult double* %749, %741
%791 = and i1 %789, %790
%792 = or i1 %788, %791
%793 = icmp ult double* %740, %752
%794 = icmp ult double* %751, %741
%795 = and i1 %793, %794
%796 = or i1 %792, %795
%797 = icmp ult double* %740, %756
%798 = icmp ult double* %755, %741
%799 = and i1 %797, %798
%800 = or i1 %796, %799
%801 = icmp ult double* %740, %758
%802 = icmp ult double* %757, %741
%803 = and i1 %801, %802
%804 = or i1 %800, %803
%805 = icmp ult double* %740, %760
%806 = icmp ult double* %759, %741
%807 = and i1 %805, %806
%808 = or i1 %804, %807
br i1 %808, label %856, label %809
809: ; preds = %785, %809
%810 = phi i64 [ %853, %809 ], [ 0, %785 ]
%811 = trunc i64 %810 to i32
%812 = add i32 %767, %811
%813 = add i32 %812, %670
%814 = add i32 %813, %730
%815 = sext i32 %814 to i64
%816 = getelementptr inbounds double, double* %665, i64 %815
%817 = bitcast double* %816 to <2 x double>*
%818 = load <2 x double>, <2 x double>* %817
%819 = getelementptr inbounds double, double* %666, i64 %815
%820 = bitcast double* %819 to <2 x double>*
%821 = load <2 x double>, <2 x double>* %820
%822 = fadd <2 x double> %818, %821
%823 = getelementptr inbounds double, double* %668, i64 %815
%824 = bitcast double* %823 to <2 x double>*
%825 = load <2 x double>, <2 x double>* %824
%826 = fadd <2 x double> %822, %825
%827 = add i32 %812, %672
%828 = add i32 %827, %731
%829 = sext i32 %828 to i64
%830 = getelementptr inbounds double, double* %517, i64 %829
%831 = bitcast double* %830 to <2 x double>*
%832 = load <2 x double>, <2 x double>* %831
%833 = fadd <2 x double> %826, %832
%834 = getelementptr inbounds double, double* %512, i64 %829
%835 = bitcast double* %834 to <2 x double>*
%836 = load <2 x double>, <2 x double>* %835
%837 = fadd <2 x double> %833, %836
%838 = add i32 %731, %811
%839 = add i32 %838, %674
%840 = add i32 %839, %768
%841 = sext i32 %840 to i64
%842 = getelementptr inbounds double, double* %519, i64 %841
%843 = bitcast double* %842 to <2 x double>*
%844 = load <2 x double>, <2 x double>* %843
%845 = fadd <2 x double> %837, %844
%846 = add i32 %812, %730
%847 = sext i32 %846 to i64
%848 = getelementptr inbounds double, double* %413, i64 %847
%849 = bitcast double* %848 to <2 x double>*
%850 = load <2 x double>, <2 x double>* %849
%851 = fadd <2 x double> %850, %845
%852 = bitcast double* %848 to <2 x double>*
store <2 x double> %851, <2 x double>* %852
%853 = add nuw i64 %810, 2
%854 = icmp eq i64 %853, %115
br i1 %854, label %855, label %809
855: ; preds = %809
br i1 %116, label %861, label %856
856: ; preds = %785, %769, %735, %855
%857 = phi i64 [ 0, %785 ], [ 0, %769 ], [ 0, %735 ], [ %115, %855 ]
br label %864
858: ; preds = %861
%859 = add nuw nsw i32 %719, 1
%860 = icmp eq i32 %859, %65
br i1 %860, label %732, label %718
861: ; preds = %864, %855
%862 = add nuw nsw i32 %736, 1
%863 = icmp eq i32 %862, %65
br i1 %863, label %858, label %735
864: ; preds = %856, %864
%865 = phi i64 [ %900, %864 ], [ %857, %856 ]
%866 = trunc i64 %865 to i32
%867 = add i32 %767, %866
%868 = add i32 %867, %670
%869 = add i32 %868, %730
%870 = sext i32 %869 to i64
%871 = getelementptr inbounds double, double* %665, i64 %870
%872 = load double, double* %871
%873 = getelementptr inbounds double, double* %666, i64 %870
%874 = load double, double* %873
%875 = fadd double %872, %874
%876 = getelementptr inbounds double, double* %668, i64 %870
%877 = load double, double* %876
%878 = fadd double %875, %877
%879 = add i32 %867, %672
%880 = add i32 %879, %731
%881 = sext i32 %880 to i64
%882 = getelementptr inbounds double, double* %517, i64 %881
%883 = load double, double* %882
%884 = fadd double %878, %883
%885 = getelementptr inbounds double, double* %512, i64 %881
%886 = load double, double* %885
%887 = fadd double %884, %886
%888 = add i32 %731, %866
%889 = add i32 %888, %674
%890 = add i32 %889, %768
%891 = sext i32 %890 to i64
%892 = getelementptr inbounds double, double* %519, i64 %891
%893 = load double, double* %892
%894 = fadd double %887, %893
%895 = add i32 %867, %730
%896 = sext i32 %895 to i64
%897 = getelementptr inbounds double, double* %413, i64 %896
%898 = load double, double* %897
%899 = fadd double %898, %894
store double %899, double* %897
%900 = add nuw nsw i64 %865, 1
%901 = icmp eq i64 %900, %72
br i1 %901, label %861, label %864
}