void blktrid(double *a, double *b, double *c, double *x, double *r, int ni,
             int nk) {
  int n, m, istart, i, j, k, kk, mp, mr, jb, kr;
  double t, s;
  n = ni - 1;
  m = nk - 1;
  int nj = nk;
  istart = 1;
  for (i = istart; i <= n; i++) {
    for (j = 0; j <= m - 1; j++) {
      t = 1.0 / b[i * nj * nk + j * nk + j];
      for (k = j + 1; k <= m; k++) {
        b[i * nj * nk + j * nk + k] = t * b[i * nj * nk + j * nk + k];
      }
      if (i != n) {
        for (k = 0; k <= m; k++) {
          c[i * nj * nk + j * nk + k] = t * c[i * nj * nk + j * nk + k];
        }
      }
      r[i * nj + j] = t * r[i * nj + j];
      for (k = j + 1; k <= m; k++) {
        for (kk = j + 1; kk <= m; kk++) {
          b[i * nj * nk + k * nk + kk] =
              b[i * nj * nk + k * nk + kk] -
              b[i * nj * nk + k * nk + j] * b[i * nj * nk + j * nk + kk];
        }
        if (i != n) {
          for (kk = 0; kk <= m; kk++) {
            c[i * nj * nk + k * nk + kk] =
                c[i * nj * nk + k * nk + kk] -
                b[i * nj * nk + k * nk + j] * c[i * nj * nk + j * nk + kk];
          }
        }
        r[i * nj + k] =
            r[i * nj + k] - b[i * nj * nk + k * nk + j] * r[i * nj + j];
      }
    }
    t = 1.0 / b[i * nj * nk + m * nk + m];
    for (kk = 0; kk <= m; kk++) {
      c[i * nj * nk + m * nk + kk] = t * c[i * nj * nk + m * nk + kk];
    }
    r[i * nj + m] = t * r[i * nj + m];
    for (j = 0; j <= (m - 1); j++) {
      mp = m - j;
      for (k = 0; k <= mp - 1; k++) {
        mr = mp - k - 1;
        if (i != n) {
          for (kk = 0; kk <= m; kk++) {
            c[i * nj * nk + mr * nk + kk] =
                c[i * nj * nk + mr * nk + kk] -
                b[i * nj * nk + mr * nk + mp] * c[i * nj * nk + mp * nk + kk];
          }
        }
        r[i * nj + mr] =
            r[i * nj + mr] - b[i * nj * nk + mr * nk + mp] * r[i * nj + mp];
      }
    }
    if (i != n) {
      for (j = 0; j <= m; j++) {
        for (k = 0; k <= m; k++) {
          for (kk = 0; kk <= m; kk++) {
            b[(i + 1) * nj * nk + k * nk + kk] =
                b[(i + 1) * nj * nk + k * nk + kk] -
                a[(i + 1) * nj * nk + k * nk + j] *
                    c[i * nj * nk + j * nk + kk];
          }
          r[(i + 1) * nj + k] =
              r[(i + 1) * nj + k] -
              a[(i + 1) * nj * nk + k * nk + j] * r[i * nj + j];
        }
      }
    }
  }
  for (k = 0; k <= m; k++) {
    x[n * nj + k] = r[n * nj + k];
  }
  for (j = 0; j <= n - istart - 1; j++) {
    jb = n - j - 1;
    for (k = 0; k <= m; k++) {
      kr = m - k;
      s = 0.0;
      for (kk = 0; kk <= m; kk++) {
        s = c[jb * nj * nk + kr * nk + kk] * x[(jb + 1) * nj + kk] + s;
      }
      x[jb * nj + kr] = r[jb * nj + kr] - s;
    }
  }
}


x86 assembly (clang, -O0):
<blktrid>:
push   %rbp
mov    %rsp,%rbp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x6c(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     197a <blktrid+0x87a>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1519 <blktrid+0x419>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xe72(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     1206 <blktrid+0x106>
movsd  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11a1 <blktrid+0xa1>
mov    -0x3c(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     1283 <blktrid+0x183>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     127e <blktrid+0x17e>
movsd  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1219 <blktrid+0x119>
jmp    1283 <blktrid+0x183>
movsd  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     1506 <blktrid+0x406>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     1397 <blktrid+0x297>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    12d2 <blktrid+0x1d2>
mov    -0x3c(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     1474 <blktrid+0x374>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     146f <blktrid+0x36f>
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    13aa <blktrid+0x2aa>
jmp    1474 <blktrid+0x374>
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12bd <blktrid+0x1bd>
jmp    150b <blktrid+0x40b>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1157 <blktrid+0x57>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xac1(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     15b5 <blktrid+0x4b5>
movsd  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1550 <blktrid+0x450>
movsd  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     17ad <blktrid+0x6ad>
mov    -0x34(%rbp),%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     179a <blktrid+0x69a>
mov    -0x4c(%rbp),%eax
sub    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     1708 <blktrid+0x608>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     1703 <blktrid+0x603>
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x50(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x50(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x50(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    163e <blktrid+0x53e>
jmp    1708 <blktrid+0x608>
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x50(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    160e <blktrid+0x50e>
jmp    179f <blktrid+0x69f>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    15ed <blktrid+0x4ed>
mov    -0x3c(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     1967 <blktrid+0x867>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     1962 <blktrid+0x862>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     194f <blktrid+0x84f>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     18b4 <blktrid+0x7b4>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    17e6 <blktrid+0x6e6>
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x6c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x6c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    17d3 <blktrid+0x6d3>
jmp    1954 <blktrid+0x854>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    17c0 <blktrid+0x6c0>
jmp    1967 <blktrid+0x867>
jmp    196c <blktrid+0x86c>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1144 <blktrid+0x44>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     19c7 <blktrid+0x8c7>
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1981 <blktrid+0x881>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x30(%rbp),%ecx
sub    -0x38(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1ad3 <blktrid+0x9d3>
mov    -0x30(%rbp),%eax
sub    -0x40(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     1ac0 <blktrid+0x9c0>
mov    -0x34(%rbp),%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     1a81 <blktrid+0x981>
mov    -0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x58(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
imul   -0x6c(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1a19 <blktrid+0x919>
mov    -0x28(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    19f5 <blktrid+0x8f5>
jmp    1ac5 <blktrid+0x9c5>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    19ce <blktrid+0x8ce>
pop    %rbp
ret

x86 assembly (clang, -O2):
<blktrid>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2d0,%rsp
mov    %rcx,0x1c0(%rsp)
mov    %rdx,-0x78(%rsp)
mov    %rdi,-0x58(%rsp)
mov    0x308(%rsp),%ebx
lea    -0x1(%r9),%eax
lea    -0x1(%rbx),%edx
movslq %ebx,%rcx
mov    %rcx,-0x70(%rsp)
mov    %edx,0xac(%rsp)
movslq %edx,%rcx
mov    %rcx,0x18(%rsp)
mov    %eax,0x30(%rsp)
mov    %eax,%eax
mov    %rax,0x10(%rsp)
mov    %ebx,%edi
mov    %r9,0x8(%rsp)
cmp    $0x2,%r9d
mov    %r8,-0x60(%rsp)
mov    %rdi,-0x80(%rsp)
jl     278a <blktrid+0x168a>
mov    0x18(%rsp),%rdx
mov    %edx,%eax
imul   %ebx,%eax
movslq %eax,%r14
mov    -0x70(%rsp),%r11
mov    %r11d,%r15d
imul   %r15d,%r15d
mov    %r11,%r13
imul   %r11,%r13
lea    -0x2(%r11),%eax
mov    %eax,0x34(%rsp)
imul   %ebx,%eax
mov    %rax,0x150(%rsp)
mov    %r11d,%eax
neg    %eax
mov    %rax,0x98(%rsp)
lea    (%r11,%rdx,1),%r10
imul   %r11,%r10
lea    0x1(%r11),%r12
imul   %r11,%r12
mov    -0x80(%rsp),%rax
and    $0xfffffffc,%eax
mov    %rax,-0x8(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x148(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
movabs $0x7ffffffffffffffc,%rdi
ff ff 7f
or     $0x2,%rdi
mov    %rax,%rcx
mov    %rax,0x140(%rsp)
and    %rax,%rdi
mov    %rdi,0x130(%rsp)
mov    -0x80(%rsp),%rax
neg    %rax
mov    %rax,0xa0(%rsp)
mov    -0x80(%rsp),%rax
lea    0x0(,%rax,8),%rax
and    $0xffffffffffffffe0,%rax
mov    %rax,0x1b0(%rsp)
mov    %r14,0x238(%rsp)
lea    (%r14,%r13,1),%rax
mov    -0x78(%rsp),%r14
lea    0x30(%r14,%rax,8),%r9
lea    (%r14,%rax,8),%rcx
lea    0x0(,%r11,8),%rax
mov    %rax,0x90(%rsp)
neg    %rax
mov    %rax,0x258(%rsp)
movsd  0x1d97(%rip),%xmm0
movapd 0x1d9f(%rip),%xmm1
mov    %edx,%eax
mov    %rax,0x188(%rsp)
mov    0x8(%rsp),%eax
mov    %rax,0x228(%rsp)
mov    %r15,0x118(%rsp)
add    %r15d,%r15d
mov    -0x80(%rsp),%rax
lea    (%rsi,%rax,8),%rax
mov    %rax,0x2c8(%rsp)
mov    -0x58(%rsp),%rax
lea    0x8(%rax),%rax
mov    %rax,0x2c0(%rsp)
mov    -0x80(%rsp),%rax
lea    0x0(%r13,%rax,1),%rax
mov    %rax,0x220(%rsp)
mov    -0x80(%rsp),%rax
lea    (%r14,%rax,8),%rax
mov    %rax,0x2b0(%rsp)
lea    0x0(%r13,%rdx,1),%rax
mov    %rax,0x1f8(%rsp)
mov    -0x80(%rsp),%rdi
lea    0x8(%rsi),%rax
mov    %rax,0x1b8(%rsp)
lea    (%r10,%rdi,1),%rax
mov    %rax,0x1f0(%rsp)
lea    (%r12,%rdi,1),%rax
mov    %rax,0x1e8(%rsp)
lea    0x8(,%r11,8),%rax
mov    %rax,0x160(%rsp)
lea    0x1(%r12),%rax
mov    %rax,0x1e0(%rsp)
lea    0x2(%r12),%rax
mov    %rax,0x1d8(%rsp)
lea    0x1(%r13),%rax
mov    %rax,0x1d0(%rsp)
lea    0x2(%r13),%rax
mov    %rax,0x1c8(%rsp)
lea    0x38(%rsi,%r13,8),%rax
mov    %rax,0x110(%rsp)
lea    0x0(,%r13,8),%rax
mov    %rax,0x218(%rsp)
lea    (%rsi,%r13,8),%rax
mov    %rax,0x108(%rsp)
lea    0x30(%r14,%r13,8),%rax
mov    %rax,0x100(%rsp)
lea    (%r14,%r13,8),%rax
mov    %rax,0x60(%rsp)
lea    0x18(%rsi,%r12,8),%rax
mov    %rax,0xf8(%rsp)
lea    0x18(%rsi,%r13,8),%rax
mov    %rax,0xf0(%rsp)
lea    (%rsi,%r12,8),%rax
mov    %rax,0xe8(%rsp)
lea    0x10(%r14,%r12,8),%rax
mov    %rax,0xe0(%rsp)
mov    %r12,0x208(%rsp)
lea    (%r14,%r12,8),%rax
mov    %rax,0xd8(%rsp)
lea    0x10(%r14),%rax
mov    %rax,0x278(%rsp)
lea    0x10(%r14,%r10,8),%rax
mov    %rax,0xd0(%rsp)
mov    %r10,0x210(%rsp)
lea    0x8(%r14,%r10,8),%rax
mov    %rax,0xc8(%rsp)
lea    0x10(%rsi),%rax
mov    %rax,0x2a8(%rsp)
lea    0x10(%r14,%r13,8),%rax
mov    %rax,0xc0(%rsp)
lea    (%r14,%r13,8),%rax
add    $0x8,%rax
mov    %rax,0xb8(%rsp)
mov    $0x1,%ebp
xor    %edx,%edx
mov    %r15,0x200(%rsp)
mov    %r15d,%eax
mov    %r15d,-0xc(%rsp)
mov    %r13,0x190(%rsp)
mov    %r13,0x230(%rsp)
jmp    1521 <blktrid+0x421>
nopl   0x0(%rax,%rax,1)
mov    0x128(%rsp),%rdx
add    $0x1,%rdx
mov    0x218(%rsp),%rax
add    %rax,0x110(%rsp)
add    %rax,0x108(%rsp)
add    %rax,0x100(%rsp)
add    %rax,0x60(%rsp)
add    %rax,0xf8(%rsp)
add    %rax,0xf0(%rsp)
add    %rax,0xe8(%rsp)
add    %rax,0xe0(%rsp)
add    %rax,0xd8(%rsp)
mov    0x120(%rsp),%r9
add    %rax,%r9
mov    0x138(%rsp),%rcx
add    %rax,%rcx
mov    0x230(%rsp),%r13
add    %r13,0x190(%rsp)
add    %rax,0xd0(%rsp)
add    %rax,0xc8(%rsp)
mov    -0xc(%rsp),%ebp
add    0x118(%rsp),%ebp
mov    %ebp,-0xc(%rsp)
add    %rax,0xc0(%rsp)
add    %rax,0xb8(%rsp)
mov    -0x50(%rsp),%rbp
cmp    0x228(%rsp),%rbp
je     278a <blktrid+0x168a>
mov    %rcx,0x138(%rsp)
mov    %r9,0x120(%rsp)
mov    %rbp,%rcx
mov    %r13,%rbp
mov    %rdx,0x128(%rsp)
imul   %rdx,%rbp
mov    %r13,%rax
add    %rbp,%rax
mov    %rax,0x68(%rsp)
mov    0x220(%rsp),%rax
mov    %rbp,0x38(%rsp)
add    %rbp,%rax
mov    %rax,0x158(%rsp)
mov    %rcx,0x58(%rsp)
mov    %rcx,%rdx
mov    -0x70(%rsp),%rax
imul   %rax,%rdx
mov    %rdx,%rcx
mov    %rdx,-0x30(%rsp)
imul   %rax,%rdx
mov    %rdx,-0x18(%rsp)
cmp    $0x2,%eax
jge    15e0 <blktrid+0x4e0>
mov    0x238(%rsp),%rax
mov    -0x18(%rsp),%rcx
add    %rcx,%rax
mov    0x18(%rsp),%rcx
add    %rax,%rcx
movapd %xmm0,%xmm2
divsd  (%rsi,%rcx,8),%xmm2
test   %ebx,%ebx
mov    0x138(%rsp),%r10
mov    -0x60(%rsp),%r8
jle    2019 <blktrid+0xf19>
cmp    $0x4,%ebx
jae    1f40 <blktrid+0xe40>
xor    %eax,%eax
jmp    2000 <blktrid+0xf00>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x1e0(%rsp),%rax
mov    0x38(%rsp),%rbp
add    %rbp,%rax
mov    %rax,0x48(%rsp)
mov    0x1d8(%rsp),%rax
add    %rbp,%rax
mov    %rax,0x250(%rsp)
mov    0x208(%rsp),%rax
add    %rbp,%rax
mov    %rax,0x198(%rsp)
mov    0x1e8(%rsp),%rax
add    %rbp,%rax
mov    %rax,0x248(%rsp)
test   %ebx,%ebx
setle  %al
mov    0x1c8(%rsp),%rcx
lea    (%rcx,%rbp,1),%r9
mov    0x1d0(%rsp),%rdx
add    %rbp,%rdx
mov    0x58(%rsp),%rbp
cmp    0x10(%rsp),%rbp
sete   %cl
or     %al,%cl
mov    %cl,0x50(%rsp)
lea    (%rsi,%rdx,8),%rax
mov    %rax,0x2b8(%rsp)
lea    (%rsi,%r9,8),%rax
mov    %rax,0x240(%rsp)
mov    $0x1,%r11d
mov    0xd8(%rsp),%rax
mov    %rax,0x180(%rsp)
mov    0xe0(%rsp),%rax
mov    %rax,0x178(%rsp)
mov    0xe8(%rsp),%rax
mov    %rax,0x170(%rsp)
mov    0xf0(%rsp),%r8
mov    0xf8(%rsp),%rax
mov    %rax,0x168(%rsp)
mov    0x60(%rsp),%r12
mov    0x100(%rsp),%rbp
mov    0x108(%rsp),%r13
mov    0x34(%rsp),%r9d
mov    0x110(%rsp),%r10
xor    %eax,%eax
jmp    1772 <blktrid+0x672>
nopl   0x0(%rax)
mov    0xb4(%rsp),%r11d
add    $0x1,%r11d
mov    0x160(%rsp),%rcx
mov    0x268(%rsp),%r10
add    %rcx,%r10
mov    0xb0(%rsp),%r9d
add    $0xffffffff,%r9d
mov    0x90(%rsp),%rax
add    %rax,%r13
mov    0x270(%rsp),%rbp
add    %rax,%rbp
add    %rax,%r12
add    %rcx,0x168(%rsp)
add    %rcx,%r8
add    %rax,0x170(%rsp)
add    %rax,0x178(%rsp)
add    %rax,0x180(%rsp)
mov    0x260(%rsp),%rax
cmp    0x188(%rsp),%rax
mov    -0x80(%rsp),%rdi
je     158d <blktrid+0x48d>
mov    %rax,%r14
mov    %r9d,%eax
add    $0x1,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x1a0(%rsp)
mov    0x34(%rsp),%eax
sub    %r14d,%eax
mov    %rax,-0x50(%rsp)
add    $0x1,%rax
mov    %rax,0x1a8(%rsp)
mov    %rax,%rdx
movabs $0x1fffffffc,%rax
and    %rax,%rdx
mov    %rdx,0x20(%rsp)
mov    %r14,%rcx
mov    -0x70(%rsp),%r15
imul   %r15,%rcx
mov    %r11d,0xb4(%rsp)
movslq %r11d,%rax
mov    %rax,-0x68(%rsp)
mov    %r14d,%eax
imul   %ebx,%eax
mov    -0x18(%rsp),%rdx
mov    %rcx,%r11
add    %rdx,%rcx
mov    %rcx,-0x28(%rsp)
cltq
add    %rdx,%rax
add    %r14,%rax
movapd %xmm0,%xmm2
divsd  (%rsi,%rax,8),%xmm2
mov    %r14,%rax
mov    %r14,-0x20(%rsp)
add    $0x1,%r14
cmp    %r15,%r14
jge    191a <blktrid+0x81a>
mov    -0x68(%rsp),%rax
cmpl   $0x3,-0x50(%rsp)
jb     1900 <blktrid+0x800>
mov    0x20(%rsp),%rax
lea    -0x4(%rax),%rcx
mov    %rcx,%rax
shr    $0x2,%rax
add    $0x1,%rax
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
test   %rcx,%rcx
je     1f17 <blktrid+0xe17>
mov    0x1a0(%rsp),%rcx
lea    -0x4(%rcx),%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %ecx,%ecx
nopl   0x0(%rax)
movupd -0x30(%r10,%rcx,8),%xmm4
movupd -0x20(%r10,%rcx,8),%xmm5
movupd -0x10(%r10,%rcx,8),%xmm6
movupd (%r10,%rcx,8),%xmm7
mulpd  %xmm3,%xmm4
mulpd  %xmm3,%xmm5
movupd %xmm4,-0x30(%r10,%rcx,8)
movupd %xmm5,-0x20(%r10,%rcx,8)
mulpd  %xmm3,%xmm6
mulpd  %xmm3,%xmm7
movupd %xmm6,-0x10(%r10,%rcx,8)
movupd %xmm7,(%r10,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1860 <blktrid+0x760>
test   $0x1,%al
je     18dc <blktrid+0x7dc>
add    -0x68(%rsp),%rcx
add    -0x28(%rsp),%rcx
movupd (%rsi,%rcx,8),%xmm4
movupd 0x10(%rsi,%rcx,8),%xmm5
mulpd  %xmm3,%xmm4
mulpd  %xmm3,%xmm5
movupd %xmm4,(%rsi,%rcx,8)
movupd %xmm5,0x10(%rsi,%rcx,8)
mov    0x20(%rsp),%rax
cmp    %rax,0x1a8(%rsp)
je     191a <blktrid+0x81a>
mov    0x20(%rsp),%rax
mov    -0x68(%rsp),%rcx
add    %rcx,%rax
nopl   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
movsd  %xmm3,0x0(%r13,%rax,8)
add    $0x1,%rax
cmp    %eax,%edi
jne    1900 <blktrid+0x800>
mov    %r9d,0xb0(%rsp)
cmpb   $0x0,0x50(%rsp)
jne    1a19 <blktrid+0x919>
cmp    $0x4,%ebx
jae    1940 <blktrid+0x840>
xor    %eax,%eax
jmp    1a00 <blktrid+0x900>
nopl   0x0(%rax)
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
cmpq   $0x0,0x148(%rsp)
je     1f26 <blktrid+0xe26>
mov    0x130(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rbp,%rax,8),%xmm4
movupd -0x20(%rbp,%rax,8),%xmm5
movupd -0x10(%rbp,%rax,8),%xmm6
movupd 0x0(%rbp,%rax,8),%xmm7
mulpd  %xmm3,%xmm4
mulpd  %xmm3,%xmm5
movupd %xmm4,-0x30(%rbp,%rax,8)
movupd %xmm5,-0x20(%rbp,%rax,8)
mulpd  %xmm3,%xmm6
mulpd  %xmm3,%xmm7
movupd %xmm6,-0x10(%rbp,%rax,8)
movupd %xmm7,0x0(%rbp,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1970 <blktrid+0x870>
testb  $0x1,0x140(%rsp)
01
je     19ec <blktrid+0x8ec>
add    -0x28(%rsp),%rax
mov    -0x78(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm4
movupd 0x10(%rcx,%rax,8),%xmm5
mulpd  %xmm3,%xmm4
mulpd  %xmm3,%xmm5
movupd %xmm4,(%rcx,%rax,8)
movupd %xmm5,0x10(%rcx,%rax,8)
mov    -0x8(%rsp),%rcx
mov    %rcx,%rax
cmp    %rdi,%rcx
je     1a19 <blktrid+0x919>
nopl   0x0(%rax)
movsd  (%r12,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
movsd  %xmm3,(%r12,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdi
jne    1a00 <blktrid+0x900>
mov    %r10,0x268(%rsp)
mov    %rbp,0x270(%rsp)
mov    -0x30(%rsp),%rax
mov    -0x20(%rsp),%rcx
add    %rax,%rcx
mov    -0x60(%rsp),%rax
mulsd  (%rax,%rcx,8),%xmm2
mov    %rcx,0x88(%rsp)
movsd  %xmm2,(%rax,%rcx,8)
mov    %r14,0x260(%rsp)
cmp    -0x70(%rsp),%r14
jge    16f0 <blktrid+0x5f0>
mov    0x160(%rsp),%rcx
mov    -0x20(%rsp),%rbp
imul   %rbp,%rcx
mov    0x240(%rsp),%rax
mov    %rcx,-0x48(%rsp)
add    %rcx,%rax
mov    0x68(%rsp),%rcx
lea    (%rcx,%r11,1),%rcx
mov    0x158(%rsp),%rdx
lea    (%rdx,%r11,1),%rdx
mov    0x250(%rsp),%rdi
mov    -0x50(%rsp),%rbx
add    %rbx,%rdi
mov    %rdi,0x70(%rsp)
lea    (%rax,%rbx,8),%rax
mov    %rax,0x40(%rsp)
mov    0x198(%rsp),%rax
add    %r11,%rax
mov    %rax,0x298(%rsp)
add    0x248(%rsp),%r11
mov    %r11,0x2a0(%rsp)
mov    -0x78(%rsp),%rax
lea    (%rax,%rcx,8),%rcx
mov    %rcx,0x290(%rsp)
lea    (%rax,%rdx,8),%rax
mov    %rax,0x288(%rsp)
mov    -0x18(%rsp),%rax
add    %rbp,%rax
mov    %rax,0x80(%rsp)
mov    0x20(%rsp),%rax
mov    -0x68(%rsp),%r9
add    %r9,%rax
mov    %rax,0x280(%rsp)
mov    0x180(%rsp),%r15
mov    0x178(%rsp),%rcx
mov    0x170(%rsp),%rax
mov    0x168(%rsp),%r14
xor    %r11d,%r11d
jmp    1bb0 <blktrid+0xab0>
xchg   %ax,%ax
mov    -0x30(%rsp),%rdx
add    %r9,%rdx
mov    -0x60(%rsp),%rbp
movsd  0x0(%rbp,%rdx,8),%xmm2
mov    0x28(%rsp),%rdi
add    0x80(%rsp),%edi
movslq %edi,%rdi
movsd  (%rsi,%rdi,8),%xmm3
mov    0x88(%rsp),%rdi
mulsd  0x0(%rbp,%rdi,8),%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,0x0(%rbp,%rdx,8)
add    $0x1,%r9
mov    -0x38(%rsp),%r11
add    $0x1,%r11
mov    0x90(%rsp),%rdx
add    %rdx,%r14
add    %rdx,%rax
add    %rdx,%rcx
add    %rdx,%r15
mov    0x308(%rsp),%ebx
cmp    %ebx,%r9d
je     16f0 <blktrid+0x5f0>
mov    %r11,-0x38(%rsp)
mov    -0x70(%rsp),%rdi
imul   %rdi,%r11
mov    0x48(%rsp),%rdx
add    %r11,%rdx
lea    (%rsi,%rdx,8),%rdx
add    -0x48(%rsp),%rdx
mov    %rdx,-0x40(%rsp)
mov    %r9,%rbp
imul   %rdi,%rbp
mov    -0x18(%rsp),%rdx
mov    %rbp,0x28(%rsp)
add    %rdx,%rbp
mov    -0x20(%rsp),%rdx
mov    %rbp,%rdi
mov    %rbp,(%rsp)
lea    (%rdx,%rbp,1),%rbx
mov    -0x68(%rsp),%r10
cmpl   $0x3,-0x50(%rsp)
mov    -0x80(%rsp),%rdi
jb     1cb0 <blktrid+0xbb0>
mov    -0x40(%rsp),%rdx
cmp    0x40(%rsp),%rdx
jae    1c38 <blktrid+0xb38>
mov    0x70(%rsp),%rdx
add    %r11,%rdx
lea    (%rsi,%rdx,8),%rdx
mov    -0x68(%rsp),%r10
cmp    %rdx,0x2b8(%rsp)
jb     1cb0 <blktrid+0xbb0>
movsd  (%rsi,%rbx,8),%xmm2
unpcklpd %xmm2,%xmm2
xorpd  %xmm1,%xmm2
xor    %edx,%edx
mov    0x1a0(%rsp),%rbp
nop
movupd -0x10(%r14,%rdx,8),%xmm3
movupd (%r14,%rdx,8),%xmm4
movupd -0x10(%r8,%rdx,8),%xmm5
movupd (%r8,%rdx,8),%xmm6
mulpd  %xmm2,%xmm5
addpd  %xmm3,%xmm5
mulpd  %xmm2,%xmm6
addpd  %xmm4,%xmm6
movupd %xmm5,-0x10(%r14,%rdx,8)
movupd %xmm6,(%r14,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rbp
jne    1c50 <blktrid+0xb50>
mov    0x280(%rsp),%r10
mov    0x20(%rsp),%rdx
cmp    %rdx,0x1a8(%rsp)
je     1d4e <blktrid+0xc4e>
nopl   0x0(%rax,%rax,1)
mov    0x308(%rsp),%edx
sub    %r10d,%edx
test   $0x1,%dl
jne    1cd0 <blktrid+0xbd0>
mov    %r10,%rdx
jmp    1d03 <blktrid+0xc03>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rsp),%rdx
add    %r10,%rdx
movsd  (%rsi,%rbx,8),%xmm2
mov    -0x28(%rsp),%rdi
add    %r10,%rdi
mulsd  (%rsi,%rdi,8),%xmm2
mov    -0x80(%rsp),%rdi
movsd  (%rsi,%rdx,8),%xmm3
subsd  %xmm2,%xmm3
movsd  %xmm3,(%rsi,%rdx,8)
mov    %r10,%rdx
add    $0x1,%rdx
not    %r10d
cmp    0x98(%rsp),%r10d
je     1d4e <blktrid+0xc4e>
movsd  (%rsi,%rbx,8),%xmm2
mulsd  0x0(%r13,%rdx,8),%xmm2
movsd  (%rax,%rdx,8),%xmm3
subsd  %xmm2,%xmm3
movsd  0x8(%rax,%rdx,8),%xmm2
movsd  %xmm3,(%rax,%rdx,8)
movsd  (%rsi,%rbx,8),%xmm3
mulsd  0x8(%r13,%rdx,8),%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,0x8(%rax,%rdx,8)
add    $0x2,%rdx
cmp    %edx,%edi
jne    1d10 <blktrid+0xc10>
cmpb   $0x0,0x50(%rsp)
jne    1b40 <blktrid+0xa40>
mov    0x308(%rsp),%edx
cmp    $0x4,%edx
jae    1d70 <blktrid+0xc70>
xor    %r10d,%r10d
jmp    1e70 <blktrid+0xd70>
nopl   (%rax)
mov    0x298(%rsp),%rdx
add    %r11,%rdx
mov    0x2a0(%rsp),%rdi
add    %r11,%rdi
mov    %rdi,0x78(%rsp)
add    0x198(%rsp),%r11
lea    (%rsi,%r11,8),%rbp
add    -0x48(%rsp),%rbp
mov    -0x78(%rsp),%rdi
lea    (%rdi,%rdx,8),%r10
cmp    %r10,-0x40(%rsp)
seta   -0x40(%rsp)
mov    0x78(%rsp),%rdx
lea    (%rdi,%rdx,8),%rdi
cmp    %rdi,%rbp
setb   %r11b
cmp    0x288(%rsp),%r10
setb   %dl
cmp    %rdi,0x290(%rsp)
setb   %dil
test   %r11b,-0x40(%rsp)
jne    1e5f <blktrid+0xd5f>
mov    $0x0,%r10d
and    %dil,%dl
mov    -0x80(%rsp),%rdi
mov    0x1b0(%rsp),%rbp
jne    1e70 <blktrid+0xd70>
movsd  (%rsi,%rbx,8),%xmm2
unpcklpd %xmm2,%xmm2
xorpd  %xmm1,%xmm2
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rcx,%rdx,1),%xmm3
movupd (%rcx,%rdx,1),%xmm4
movupd (%r12,%rdx,1),%xmm5
movupd 0x10(%r12,%rdx,1),%xmm6
mulpd  %xmm2,%xmm5
addpd  %xmm3,%xmm5
mulpd  %xmm2,%xmm6
addpd  %xmm4,%xmm6
movupd %xmm5,-0x10(%rcx,%rdx,1)
movupd %xmm6,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rbp
jne    1e10 <blktrid+0xd10>
mov    -0x8(%rsp),%rdx
mov    %rdx,%r10
cmp    %rdi,%rdx
je     1b40 <blktrid+0xa40>
jmp    1e70 <blktrid+0xd70>
xor    %r10d,%r10d
mov    -0x80(%rsp),%rdi
nopw   0x0(%rax,%rax,1)
mov    %r10,%rdx
test   $0x1,%dil
je     1eb1 <blktrid+0xdb1>
mov    (%rsp),%rbp
add    %r10,%rbp
movsd  (%rsi,%rbx,8),%xmm2
mov    -0x28(%rsp),%rdx
add    %r10,%rdx
mov    -0x78(%rsp),%rdi
mulsd  (%rdi,%rdx,8),%xmm2
movsd  (%rdi,%rbp,8),%xmm3
subsd  %xmm2,%xmm3
movsd  %xmm3,(%rdi,%rbp,8)
mov    -0x80(%rsp),%rdi
mov    %r10,%rdx
or     $0x1,%rdx
not    %r10
cmp    0xa0(%rsp),%r10
je     1b40 <blktrid+0xa40>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rsi,%rbx,8),%xmm2
mulsd  (%r12,%rdx,8),%xmm2
movsd  (%r15,%rdx,8),%xmm3
subsd  %xmm2,%xmm3
movsd  0x8(%r15,%rdx,8),%xmm2
movsd  %xmm3,(%r15,%rdx,8)
movsd  (%rsi,%rbx,8),%xmm3
mulsd  0x8(%r12,%rdx,8),%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,0x8(%r15,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rdi
jne    1ed0 <blktrid+0xdd0>
jmp    1b40 <blktrid+0xa40>
xor    %ecx,%ecx
test   $0x1,%al
jne    18b4 <blktrid+0x7b4>
jmp    18dc <blktrid+0x7dc>
xor    %eax,%eax
testb  $0x1,0x140(%rsp)
01
jne    19c4 <blktrid+0x8c4>
jmp    19ec <blktrid+0x8ec>
nopl   0x0(%rax,%rax,1)
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
cmpq   $0x0,0x148(%rsp)
je     2770 <blktrid+0x1670>
mov    0x130(%rsp),%rdx
xor    %ecx,%ecx
mov    -0x8(%rsp),%r9
mov    0x120(%rsp),%rbp
xchg   %ax,%ax
movupd -0x30(%rbp,%rcx,8),%xmm4
movupd -0x20(%rbp,%rcx,8),%xmm5
movupd -0x10(%rbp,%rcx,8),%xmm6
movupd 0x0(%rbp,%rcx,8),%xmm7
mulpd  %xmm3,%xmm4
mulpd  %xmm3,%xmm5
movupd %xmm4,-0x30(%rbp,%rcx,8)
movupd %xmm5,-0x20(%rbp,%rcx,8)
mulpd  %xmm3,%xmm6
mulpd  %xmm3,%xmm7
movupd %xmm6,-0x10(%rbp,%rcx,8)
movupd %xmm7,0x0(%rbp,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1f70 <blktrid+0xe70>
testb  $0x1,0x140(%rsp)
01
je     1fea <blktrid+0xeea>
add    %rax,%rcx
mov    -0x78(%rsp),%rax
movupd (%rax,%rcx,8),%xmm4
movupd 0x10(%rax,%rcx,8),%xmm5
mulpd  %xmm3,%xmm4
mulpd  %xmm3,%xmm5
movupd %xmm4,(%rax,%rcx,8)
movupd %xmm5,0x10(%rax,%rcx,8)
mov    %r9,%rax
cmp    %rdi,%r9
je     2019 <blktrid+0xf19>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r10,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
movsd  %xmm3,(%r10,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdi
jne    2000 <blktrid+0xf00>
mov    0x18(%rsp),%rax
mov    -0x30(%rsp),%rcx
add    %rcx,%rax
mulsd  (%r8,%rax,8),%xmm2
movsd  %xmm2,(%r8,%rax,8)
cmp    $0x2,%ebx
jge    2390 <blktrid+0x1290>
mov    0x58(%rsp),%rax
lea    0x1(%rax),%rcx
mov    %rcx,-0x50(%rsp)
cmp    0x10(%rsp),%rax
je     1460 <blktrid+0x360>
test   %ebx,%ebx
jle    1460 <blktrid+0x360>
mov    0x128(%rsp),%rax
imul   0x118(%rsp),%rax
add    0x200(%rsp),%rax
mov    %rax,-0x68(%rsp)
mov    -0x50(%rsp),%r12
imul   -0x70(%rsp),%r12
mov    0xb8(%rsp),%rbp
mov    0xc0(%rsp),%rax
xor    %r13d,%r13d
mov    %r12,-0x48(%rsp)
jmp    20bb <blktrid+0xfbb>
nop
add    $0x1,%r13
mov    0x90(%rsp),%rcx
add    %rcx,%rax
add    %rcx,%rbp
cmp    %rdi,%r13
je     1460 <blktrid+0x360>
test   %ebx,%ebx
jle    20a0 <blktrid+0xfa0>
mov    %r13,%rdi
imul   -0x70(%rsp),%rdi
mov    0x68(%rsp),%rcx
lea    (%rcx,%rdi,1),%r8
mov    0x158(%rsp),%rdx
lea    (%rdx,%rdi,1),%r9
mov    -0x78(%rsp),%rcx
lea    (%rcx,%r8,8),%rdx
mov    %rdx,-0x40(%rsp)
lea    (%rcx,%r9,8),%rcx
mov    %rcx,(%rsp)
add    -0x18(%rsp),%rdi
mov    %rdi,-0x20(%rsp)
mov    -0x30(%rsp),%rcx
add    %r13,%rcx
mov    %rcx,0x28(%rsp)
mov    -0xc(%rsp),%r15d
xor    %r9d,%r9d
jmp    2173 <blktrid+0x1073>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%r9,%r12,1),%rdx
mov    -0x60(%rsp),%r8
movsd  (%r8,%rdx,8),%xmm2
mov    %rdi,%rcx
mov    %edx,%edi
mov    0x308(%rsp),%ebx
imul   %ebx,%edi
movslq %edi,%rdi
add    %r13,%rdi
movsd  (%rcx,%rdi,8),%xmm3
mov    -0x80(%rsp),%rdi
mov    0x28(%rsp),%rcx
mulsd  (%r8,%rcx,8),%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,(%r8,%rdx,8)
add    $0x1,%r9
add    %ebx,%r15d
cmp    %rdi,%r9
je     20a0 <blktrid+0xfa0>
lea    (%r9,%r12,1),%edi
imul   %ebx,%edi
movslq %edi,%r11
lea    (%r11,%r13,1),%r8
movslq %r15d,%rcx
mov    %rcx,-0x38(%rsp)
cmp    $0x4,%ebx
jae    2260 <blktrid+0x1160>
xor    %r10d,%r10d
mov    -0x80(%rsp),%rdx
mov    -0x58(%rsp),%rdi
mov    %r10,%r14
test   $0x1,%dl
je     21e4 <blktrid+0x10e4>
add    %r10,%r11
movsd  (%rdi,%r8,8),%xmm2
mov    -0x20(%rsp),%rcx
lea    (%rcx,%r10,1),%rdx
mov    -0x78(%rsp),%rdi
mulsd  (%rdi,%rdx,8),%xmm2
mov    -0x58(%rsp),%rdi
mov    -0x80(%rsp),%rdx
movsd  (%rsi,%r11,8),%xmm3
subsd  %xmm2,%xmm3
movsd  %xmm3,(%rsi,%r11,8)
mov    %r10,%r14
or     $0x1,%r14
not    %r10
cmp    0xa0(%rsp),%r10
je     2120 <blktrid+0x1020>
mov    0x1b8(%rsp),%rcx
mov    -0x38(%rsp),%rbx
lea    (%rcx,%rbx,8),%rbx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rdi,%r8,8),%xmm2
mulsd  -0x8(%rbp,%r14,8),%xmm2
movsd  -0x8(%rbx,%r14,8),%xmm3
subsd  %xmm2,%xmm3
movsd  (%rbx,%r14,8),%xmm2
movsd  %xmm3,-0x8(%rbx,%r14,8)
movsd  (%rdi,%r8,8),%xmm3
mulsd  0x0(%rbp,%r14,8),%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,(%rbx,%r14,8)
add    $0x2,%r14
cmp    %r14,%rdx
jne    2210 <blktrid+0x1110>
jmp    2120 <blktrid+0x1020>
nopw   0x0(%rax,%rax,1)
mov    %r13,%rcx
mov    %r9d,%edi
imul   -0x80(%rsp),%edi
add    -0x68(%rsp),%edi
movslq %edi,%rdi
lea    (%rdi,%r13,1),%rbx
lea    (%rsi,%rdi,8),%rdx
mov    0x2c8(%rsp),%rcx
lea    (%rcx,%rdi,8),%r12
mov    0x2c0(%rsp),%rcx
lea    (%rcx,%rbx,8),%r10
mov    -0x58(%rsp),%rdi
lea    (%rdi,%rbx,8),%rbx
cmp    %r10,%rdx
setb   %r10b
cmp    %r12,%rbx
setb   %r14b
cmp    (%rsp),%rdx
setb   %bl
cmp    %r12,-0x40(%rsp)
setb   %dil
test   %r14b,%r10b
jne    236a <blktrid+0x126a>
mov    $0x0,%r10d
and    %dil,%bl
mov    -0x80(%rsp),%rdx
mov    -0x58(%rsp),%rdi
mov    -0x48(%rsp),%r12
jne    219f <blktrid+0x109f>
mov    0x2a8(%rsp),%rcx
mov    -0x38(%rsp),%rdx
lea    (%rcx,%rdx,8),%rbx
movsd  (%rdi,%r8,8),%xmm2
unpcklpd %xmm2,%xmm2
xorpd  %xmm1,%xmm2
xor    %edi,%edi
mov    0x1b0(%rsp),%rdx
nopl   0x0(%rax)
movupd -0x10(%rbx,%rdi,1),%xmm3
movupd (%rbx,%rdi,1),%xmm4
movupd -0x10(%rax,%rdi,1),%xmm5
movupd (%rax,%rdi,1),%xmm6
mulpd  %xmm2,%xmm5
addpd  %xmm3,%xmm5
mulpd  %xmm2,%xmm6
addpd  %xmm4,%xmm6
movupd %xmm5,-0x10(%rbx,%rdi,1)
movupd %xmm6,(%rbx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    2310 <blktrid+0x1210>
mov    -0x8(%rsp),%rdi
mov    %rdi,%r10
mov    -0x80(%rsp),%rdx
cmp    %rdx,%rdi
mov    -0x58(%rsp),%rdi
je     2120 <blktrid+0x1020>
jmp    219f <blktrid+0x109f>
xor    %r10d,%r10d
mov    -0x80(%rsp),%rdx
mov    -0x58(%rsp),%rdi
mov    -0x48(%rsp),%r12
jmp    219f <blktrid+0x109f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x1f8(%rsp),%rax
mov    0x38(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0x78(%rsp)
mov    0x210(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x70(%rsp)
add    0x1f0(%rsp),%rcx
mov    %rcx,0x38(%rsp)
test   %ebx,%ebx
setle  %al
mov    0x58(%rsp),%rcx
cmp    0x10(%rsp),%rcx
sete   %cl
or     %al,%cl
mov    %cl,-0x68(%rsp)
mov    0xc8(%rsp),%rbp
mov    0xd0(%rsp),%rax
mov    0x150(%rsp),%rcx
mov    %ecx,-0x28(%rsp)
xor    %edx,%edx
mov    0xac(%rsp),%ecx
mov    %ecx,0x40(%rsp)
jmp    243e <blktrid+0x133e>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x48(%rsp),%rdx
add    $0x1,%rdx
addl   $0xffffffff,0x40(%rsp)
sub    %ebx,-0x28(%rsp)
mov    0x258(%rsp),%rcx
add    %rcx,%rax
add    %rcx,%rbp
cmp    0x188(%rsp),%rdx
je     203b <blktrid+0xf3b>
mov    0x18(%rsp),%rcx
mov    %rdx,0x48(%rsp)
sub    %rdx,%rcx
mov    %rcx,-0x38(%rsp)
jle    2410 <blktrid+0x1310>
mov    0x48(%rsp),%rdx
mov    %rdx,%rcx
imul   0x98(%rsp),%rcx
add    0x150(%rsp),%rcx
mov    %rcx,-0x20(%rsp)
mov    0x78(%rsp),%rcx
sub    %rdx,%rcx
mov    %rcx,-0x50(%rsp)
mov    -0x70(%rsp),%r9
imul   %r9,%rdx
mov    0x70(%rsp),%rdi
sub    %rdx,%rdi
mov    -0x78(%rsp),%rcx
lea    (%rcx,%rdi,8),%rdi
mov    %rdi,0x50(%rsp)
mov    0x38(%rsp),%rdi
sub    %rdx,%rdi
lea    (%rcx,%rdi,8),%rcx
mov    %rcx,0x88(%rsp)
mov    -0x80(%rsp),%rdi
mov    -0x38(%rsp),%rdx
mov    %rdx,%rcx
imul   %r9,%rcx
mov    -0x18(%rsp),%r9
add    %r9,%rcx
mov    %rcx,0x80(%rsp)
lea    (%rdx,%r9,1),%ecx
mov    %ecx,0x28(%rsp)
mov    -0x30(%rsp),%rcx
add    %rdx,%rcx
mov    %rcx,-0x40(%rsp)
mov    0x40(%rsp),%ecx
mov    %rcx,(%rsp)
mov    -0x28(%rsp),%r10d
xor    %r12d,%r12d
jmp    2541 <blktrid+0x1441>
nopl   0x0(%rax,%rax,1)
movslq %r9d,%rcx
add    -0x30(%rsp),%rcx
movsd  (%r8,%rcx,8),%xmm2
add    0x28(%rsp),%r15d
movslq %r15d,%rdx
movsd  (%rsi,%rdx,8),%xmm3
mov    -0x40(%rsp),%rdx
mulsd  (%r8,%rdx,8),%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,(%r8,%rcx,8)
add    $0x1,%r12
sub    %ebx,%r10d
cmp    (%rsp),%r12
je     2410 <blktrid+0x1310>
mov    %r12d,%r9d
not    %r9d
add    -0x38(%rsp),%r9d
mov    %r9d,%r15d
imul   %ebx,%r15d
cmpb   $0x0,-0x68(%rsp)
jne    2500 <blktrid+0x1400>
movslq %r10d,%rcx
mov    %rcx,-0x48(%rsp)
movslq %r15d,%r13
add    -0x18(%rsp),%r13
mov    -0x38(%rsp),%rcx
lea    (%rcx,%r13,1),%r14
cmp    $0x4,%ebx
jae    2640 <blktrid+0x1540>
xor    %r11d,%r11d
mov    %r13,%rcx
mov    %r11,%r13
test   $0x1,%dil
je     25c7 <blktrid+0x14c7>
mov    %rbx,%r13
mov    %rcx,%rbx
add    %r11,%rbx
movsd  (%rsi,%r14,8),%xmm2
mov    0x80(%rsp),%rcx
add    %r11,%rcx
mov    -0x78(%rsp),%rdx
mulsd  (%rdx,%rcx,8),%xmm2
movsd  (%rdx,%rbx,8),%xmm3
subsd  %xmm2,%xmm3
movsd  %xmm3,(%rdx,%rbx,8)
mov    %r13,%rbx
mov    %r11,%r13
or     $0x1,%r13
not    %r11
cmp    0xa0(%rsp),%r11
je     2500 <blktrid+0x1400>
mov    0x60(%rsp),%rcx
mov    -0x48(%rsp),%rdx
lea    (%rcx,%rdx,8),%rdx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rsi,%r14,8),%xmm2
mulsd  -0x8(%rbp,%r13,8),%xmm2
movsd  (%rdx,%r13,8),%xmm3
subsd  %xmm2,%xmm3
movsd  0x8(%rdx,%r13,8),%xmm2
movsd  %xmm3,(%rdx,%r13,8)
movsd  (%rsi,%r14,8),%xmm3
mulsd  0x0(%rbp,%r13,8),%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,0x8(%rdx,%r13,8)
add    $0x2,%r13
cmp    %r13,%rdi
jne    25f0 <blktrid+0x14f0>
jmp    2500 <blktrid+0x1400>
nopw   0x0(%rax,%rax,1)
mov    %r12d,%edx
imul   0x98(%rsp),%edx
add    -0x20(%rsp),%edx
movslq %edx,%rdx
mov    0x68(%rsp),%rcx
lea    (%rcx,%rdx,1),%rdi
mov    -0x78(%rsp),%rcx
lea    (%rcx,%rdi,8),%rbx
mov    0x2b0(%rsp),%rcx
lea    (%rcx,%rdi,8),%rdi
add    -0x50(%rsp),%rdx
lea    (%rsi,%rdx,8),%r8
mov    0x1b8(%rsp),%rcx
lea    (%rcx,%rdx,8),%rdx
cmp    %rdx,%rbx
setb   %r11b
cmp    %rdi,%r8
setb   %cl
cmp    0x88(%rsp),%rbx
setb   %dl
cmp    %rdi,0x50(%rsp)
setb   %bl
test   %cl,%r11b
jne    2757 <blktrid+0x1657>
mov    $0x0,%r11d
and    %bl,%dl
mov    -0x60(%rsp),%r8
mov    0x308(%rsp),%ebx
mov    -0x80(%rsp),%rdi
jne    257f <blktrid+0x147f>
mov    0x190(%rsp),%rcx
mov    -0x48(%rsp),%rdx
add    %rdx,%rcx
mov    0x278(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
movsd  (%rsi,%r14,8),%xmm2
unpcklpd %xmm2,%xmm2
xorpd  %xmm1,%xmm2
xor    %ebx,%ebx
mov    -0x8(%rsp),%rcx
xchg   %ax,%ax
movupd -0x10(%rdx,%rbx,8),%xmm3
movupd (%rdx,%rbx,8),%xmm4
movupd -0x10(%rax,%rbx,8),%xmm5
movupd (%rax,%rbx,8),%xmm6
mulpd  %xmm2,%xmm5
addpd  %xmm3,%xmm5
mulpd  %xmm2,%xmm6
addpd  %xmm4,%xmm6
movupd %xmm5,-0x10(%rdx,%rbx,8)
movupd %xmm6,(%rdx,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%rcx
jne    2700 <blktrid+0x1600>
mov    %rcx,%r11
cmp    %rdi,%rcx
mov    -0x60(%rsp),%r8
mov    0x308(%rsp),%ebx
je     2500 <blktrid+0x1400>
jmp    257f <blktrid+0x147f>
xor    %r11d,%r11d
mov    -0x60(%rsp),%r8
mov    0x308(%rsp),%ebx
mov    -0x80(%rsp),%rdi
jmp    257f <blktrid+0x147f>
xor    %ecx,%ecx
mov    -0x8(%rsp),%r9
testb  $0x1,0x140(%rsp)
01
jne    1fc4 <blktrid+0xec4>
jmp    1fea <blktrid+0xeea>
test   %ebx,%ebx
mov    0x1c0(%rsp),%r13
jle    2989 <blktrid+0x1889>
mov    0x30(%rsp),%eax
imul   %ebx,%eax
movslq %eax,%r9
cmp    $0x4,%ebx
jb     27dd <blktrid+0x16dd>
lea    0x0(,%r9,8),%rcx
add    %r13,%rcx
lea    (%r9,%rdi,1),%rax
lea    (%r8,%rax,8),%rdx
cmp    %rdx,%rcx
jae    287c <blktrid+0x177c>
lea    0x0(,%rax,8),%rax
add    %r13,%rax
lea    (%r8,%r9,8),%rcx
cmp    %rax,%rcx
jae    287c <blktrid+0x177c>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
add    %rdi,%rax
mov    %rdi,%rdx
and    $0x3,%rdx
je     2814 <blktrid+0x1714>
lea    0x0(,%r9,8),%rsi
add    %r13,%rsi
lea    (%r8,%r9,8),%rdi
movsd  (%rdi,%rcx,8),%xmm0
movsd  %xmm0,(%rsi,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
jne    2800 <blktrid+0x1700>
cmp    $0x3,%rax
mov    -0x80(%rsp),%rdi
jb     2989 <blktrid+0x1889>
lea    0x18(,%r9,8),%rax
add    %r13,%rax
lea    (%r8,%r9,8),%rdx
add    $0x18,%rdx
cs nopw 0x0(%rax,%rax,1)
movsd  -0x18(%rdx,%rcx,8),%xmm0
movsd  %xmm0,-0x18(%rax,%rcx,8)
movsd  -0x10(%rdx,%rcx,8),%xmm0
movsd  %xmm0,-0x10(%rax,%rcx,8)
movsd  -0x8(%rdx,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%rax,%rcx,8)
movsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rdi
jne    2840 <blktrid+0x1740>
jmp    2989 <blktrid+0x1889>
mov    %edi,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rax
mov    %rax,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0xc,%rax
jae    28a2 <blktrid+0x17a2>
xor    %ebx,%ebx
jmp    291d <blktrid+0x181d>
and    $0xfffffffffffffffc,%rsi
lea    0x70(,%r9,8),%rbp
add    %r13,%rbp
lea    (%r8,%r9,8),%rax
add    $0x70,%rax
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups -0x70(%rax,%rbx,8),%xmm0
movups -0x60(%rax,%rbx,8),%xmm1
movups %xmm0,-0x70(%rbp,%rbx,8)
movups %xmm1,-0x60(%rbp,%rbx,8)
movups -0x50(%rax,%rbx,8),%xmm0
movups -0x40(%rax,%rbx,8),%xmm1
movups %xmm0,-0x50(%rbp,%rbx,8)
movups %xmm1,-0x40(%rbp,%rbx,8)
movups -0x30(%rax,%rbx,8),%xmm0
movups -0x20(%rax,%rbx,8),%xmm1
movups %xmm0,-0x30(%rbp,%rbx,8)
movups %xmm1,-0x20(%rbp,%rbx,8)
movupd -0x10(%rax,%rbx,8),%xmm0
movupd (%rax,%rbx,8),%xmm1
movupd %xmm0,-0x10(%rbp,%rbx,8)
movupd %xmm1,0x0(%rbp,%rbx,8)
add    $0x10,%rbx
add    $0xfffffffffffffffc,%rsi
jne    28c0 <blktrid+0x17c0>
test   %rdx,%rdx
je     296f <blktrid+0x186f>
add    %r9,%rbx
lea    0x10(,%rbx,8),%rax
add    %r13,%rax
mov    -0x60(%rsp),%rsi
lea    (%rsi,%rbx,8),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x10(%rsi,%rdi,1),%xmm0
movupd (%rsi,%rdi,1),%xmm1
movupd %xmm0,-0x10(%rax,%rdi,1)
movupd %xmm1,(%rax,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    2950 <blktrid+0x1850>
mov    -0x80(%rsp),%rdi
cmp    %rdi,%rcx
mov    -0x60(%rsp),%r8
mov    0x308(%rsp),%ebx
jne    27df <blktrid+0x16df>
cmpl   $0x3,0x8(%rsp)
jge    29a2 <blktrid+0x18a2>
add    $0x2d0,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x8(%rsp),%rax
add    $0xfffffffe,%eax
mov    %rax,0x8(%rsp)
mov    %edi,%eax
and    $0xfffffffe,%eax
mov    -0x78(%rsp),%rcx
lea    0x8(%rcx),%r11
mov    0x30(%rsp),%r9d
imul   %ebx,%r9d
add    $0xffffffff,%r9d
imul   %ebx,%r9d
mov    %ebx,%ecx
imul   %ebx,%ecx
mov    %ecx,-0x58(%rsp)
mov    -0x70(%rsp),%rdx
mov    %rdx,%rcx
imul   0x10(%rsp),%rcx
lea    0x8(,%rcx,8),%rsi
add    %r13,%rsi
lea    0x0(,%rdx,8),%rcx
neg    %rcx
mov    %rcx,-0x30(%rsp)
xor    %r10d,%r10d
mov    -0x78(%rsp),%r12
jmp    2a29 <blktrid+0x1929>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r10
sub    -0x58(%rsp),%r9d
add    -0x30(%rsp),%rsi
cmp    0x8(%rsp),%r10
je     2990 <blktrid+0x1890>
test   %ebx,%ebx
jle    2a10 <blktrid+0x1910>
mov    0x10(%rsp),%r14
sub    %r10,%r14
lea    -0x1(%r14),%r15
mov    -0x70(%rsp),%rcx
imul   %rcx,%r15
imul   %rcx,%r14
mov    %r9d,%r8d
xor    %ecx,%ecx
jmp    2a7b <blktrid+0x197b>
nopl   (%rax)
add    %r15,%rbx
mov    -0x60(%rsp),%rdx
movsd  (%rdx,%rbx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rbx,8)
add    $0x1,%rcx
mov    0x308(%rsp),%ebx
sub    %ebx,%r8d
cmp    %rdi,%rcx
je     2a10 <blktrid+0x1910>
cmp    $0x1,%ebx
jne    2a90 <blktrid+0x1990>
xorpd  %xmm0,%xmm0
xor    %edx,%edx
jmp    2acb <blktrid+0x19cb>
nopl   0x0(%rax,%rax,1)
movslq %r8d,%rdx
lea    (%r11,%rdx,8),%rbx
xorpd  %xmm1,%xmm1
xor    %edx,%edx
nopl   (%rax)
movsd  -0x8(%rbx,%rdx,8),%xmm2
movsd  (%rbx,%rdx,8),%xmm0
mulsd  -0x8(%rsi,%rdx,8),%xmm2
mulsd  (%rsi,%rdx,8),%xmm0
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
add    $0x2,%rdx
movapd %xmm0,%xmm1
cmp    %rdx,%rax
jne    2aa0 <blktrid+0x19a0>
mov    0x18(%rsp),%rbx
sub    %rcx,%rbx
test   $0x1,%dil
je     2a50 <blktrid+0x1950>
lea    (%rbx,%r15,1),%edi
mov    0x308(%rsp),%ebp
imul   %ebp,%edi
movslq %edi,%rdi
add    %rdx,%rdi
movsd  (%r12,%rdi,8),%xmm1
mov    -0x80(%rsp),%rdi
add    %r14,%rdx
mulsd  0x0(%r13,%rdx,8),%xmm1
addsd  %xmm1,%xmm0
jmp    2a50 <blktrid+0x1950>

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

LLVM IR (-O2):
define void @blktrid(double* nocapture %0, double* nocapture %1, double* nocapture %2, double* nocapture %3, double* nocapture %4, i32 %5, i32 %6) {
%8 = add nsw i32 %5, -1
%9 = add i32 %6, -1
%10 = icmp sgt i32 %5, 1
br i1 %10, label %11, label %136
11: ; preds = %7
%12 = icmp slt i32 %6, 2
%13 = icmp slt i32 %6, 1
%14 = mul nsw i32 %9, %6
%15 = icmp sgt i32 %6, 0
%16 = sext i32 %6 to i64
%17 = sext i32 %9 to i64
%18 = zext i32 %8 to i64
%19 = sext i32 %14 to i64
%20 = zext i32 %5 to i64
%21 = zext i32 %9 to i64
%22 = zext i32 %6 to i64
%23 = zext i32 %6 to i64
%24 = zext i32 %6 to i64
%25 = zext i32 %9 to i64
%26 = zext i32 %6 to i64
%27 = zext i32 %6 to i64
%28 = mul i32 %6, %6
%29 = shl i32 %28, 1
%30 = zext i32 %29 to i64
%31 = zext i32 %28 to i64
%32 = getelementptr double, double* %1, i64 %22
%33 = getelementptr double, double* %0, i64 1
%34 = mul nsw i64 %16, %16
%35 = mul nsw i64 %16, %16
%36 = add nuw i64 %34, %22
%37 = mul nsw i64 %16, %16
%38 = add i32 %6, -2
%39 = mul i32 %38, %6
%40 = zext i32 %39 to i64
%41 = sub i32 0, %6
%42 = zext i32 %41 to i64
%43 = getelementptr double, double* %2, i64 %22
%44 = add i64 %35, %17
%45 = getelementptr double, double* %1, i64 1
%46 = add nsw i64 %16, %17
%47 = mul i64 %46, %16
%48 = add i64 %47, %22
%49 = add nsw i64 %16, 1
%50 = mul i64 %49, %16
%51 = mul nsw i64 %16, %16
%52 = add i64 %50, %22
%53 = shl nsw i64 %16, 3
%54 = add nsw i64 %53, 8
%55 = add nsw i64 %50, 1
%56 = add nuw i64 %51, %22
%57 = add nsw i64 %16, 1
%58 = mul i64 %57, %16
%59 = add nsw i64 %58, 1
%60 = mul nsw i64 %16, %16
%61 = shl nsw i64 %16, 3
%62 = add nsw i64 %61, 8
%63 = add nsw i64 %58, 2
%64 = add i32 %6, -2
%65 = add nuw nsw i64 %60, 1
%66 = add nuw nsw i64 %60, 2
%67 = and i64 %27, 4294967292
%68 = add nsw i64 %67, -4
%69 = lshr exact i64 %68, 2
%70 = add nuw nsw i64 %69, 1
%71 = icmp ult i32 %6, 4
%72 = and i64 %22, 4294967292
%73 = and i64 %70, 1
%74 = icmp eq i64 %68, 0
%75 = and i64 %70, 9223372036854775806
%76 = icmp eq i64 %73, 0
%77 = icmp eq i64 %72, %22
%78 = sub i32 0, %6
%79 = icmp ult i32 %6, 4
%80 = and i64 %22, 4294967292
%81 = icmp eq i64 %80, %22
%82 = and i64 %27, 1
%83 = icmp eq i64 %82, 0
%84 = sub nsw i64 0, %27
%85 = icmp ult i32 %6, 4
%86 = and i64 %22, 4294967292
%87 = and i64 %70, 1
%88 = icmp eq i64 %68, 0
%89 = and i64 %70, 9223372036854775806
%90 = icmp eq i64 %87, 0
%91 = icmp eq i64 %86, %22
%92 = icmp ult i32 %6, 4
%93 = and i64 %22, 4294967292
%94 = icmp eq i64 %93, %22
%95 = and i64 %27, 1
%96 = icmp eq i64 %95, 0
%97 = sub nsw i64 0, %27
%98 = icmp ult i32 %6, 4
%99 = and i64 %22, 4294967292
%100 = icmp eq i64 %99, %22
%101 = and i64 %27, 1
%102 = icmp eq i64 %101, 0
%103 = sub nsw i64 0, %27
br label %104
104: ; preds = %11, %1009
%105 = phi i64 [ 0, %11 ], [ %1011, %1009 ]
%106 = phi i64 [ 1, %11 ], [ %879, %1009 ]
%107 = mul i64 %60, %105
%108 = add i64 %59, %107
%109 = add i64 %63, %107
%110 = mul i64 %51, %105
%111 = add i64 %50, %110
%112 = add i64 %52, %110
%113 = add i64 %55, %110
%114 = add i64 %51, %110
%115 = add i64 %56, %110
%116 = mul i64 %37, %105
%117 = add i64 %35, %116
%118 = add i64 %44, %116
%119 = add i64 %47, %116
%120 = add i64 %48, %116
%121 = mul i64 %105, %31
%122 = add i64 %121, %30
%123 = mul i64 %35, %105
%124 = add i64 %34, %123
%125 = add i64 %36, %123
%126 = mul nsw i64 %106, %16
%127 = mul nsw i64 %126, %16
br i1 %12, label %662, label %128
128: ; preds = %104
%129 = add i64 %66, %107
%130 = add i64 %65, %107
%131 = icmp eq i64 %106, %18
%132 = or i1 %131, %13
%133 = getelementptr double, double* %1, i64 %130
%134 = getelementptr double, double* %1, i64 %129
%135 = bitcast double* %134 to i8*
br label %258
136: ; preds = %1009, %7
%137 = icmp sgt i32 %6, 0
br i1 %137, label %138, label %1012
138: ; preds = %136
%139 = mul nsw i32 %8, %6
%140 = sext i32 %139 to i64
%141 = zext i32 %6 to i64
%142 = icmp ult i32 %6, 4
br i1 %142, label %236, label %143
143: ; preds = %138
%144 = getelementptr double, double* %3, i64 %140
%145 = add nsw i64 %140, %141
%146 = getelementptr double, double* %3, i64 %145
%147 = getelementptr double, double* %4, i64 %140
%148 = getelementptr double, double* %4, i64 %145
%149 = icmp ult double* %144, %148
%150 = icmp ult double* %147, %146
%151 = and i1 %149, %150
br i1 %151, label %236, label %152
152: ; preds = %143
%153 = and i64 %141, 4294967292
%154 = add nsw i64 %153, -4
%155 = lshr exact i64 %154, 2
%156 = add nuw nsw i64 %155, 1
%157 = and i64 %156, 3
%158 = icmp ult i64 %154, 12
br i1 %158, label %214, label %159
159: ; preds = %152
%160 = and i64 %156, 9223372036854775804
br label %161
161: ; preds = %161, %159
%162 = phi i64 [ 0, %159 ], [ %211, %161 ]
%163 = phi i64 [ 0, %159 ], [ %212, %161 ]
%164 = add nsw i64 %162, %140
%165 = getelementptr inbounds double, double* %4, i64 %164
%166 = bitcast double* %165 to <2 x double>*
%167 = load <2 x double>, <2 x double>* %166
%168 = getelementptr inbounds double, double* %165, i64 2
%169 = bitcast double* %168 to <2 x double>*
%170 = load <2 x double>, <2 x double>* %169
%171 = getelementptr inbounds double, double* %3, i64 %164
%172 = bitcast double* %171 to <2 x double>*
store <2 x double> %167, <2 x double>* %172
%173 = getelementptr inbounds double, double* %171, i64 2
%174 = bitcast double* %173 to <2 x double>*
store <2 x double> %170, <2 x double>* %174
%175 = or i64 %162, 4
%176 = add nsw i64 %175, %140
%177 = getelementptr inbounds double, double* %4, 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 = getelementptr inbounds double, double* %3, i64 %176
%184 = bitcast double* %183 to <2 x double>*
store <2 x double> %179, <2 x double>* %184
%185 = getelementptr inbounds double, double* %183, i64 2
%186 = bitcast double* %185 to <2 x double>*
store <2 x double> %182, <2 x double>* %186
%187 = or i64 %162, 8
%188 = add nsw i64 %187, %140
%189 = getelementptr inbounds double, double* %4, i64 %188
%190 = bitcast double* %189 to <2 x double>*
%191 = load <2 x double>, <2 x double>* %190
%192 = getelementptr inbounds double, double* %189, i64 2
%193 = bitcast double* %192 to <2 x double>*
%194 = load <2 x double>, <2 x double>* %193
%195 = getelementptr inbounds double, double* %3, i64 %188
%196 = bitcast double* %195 to <2 x double>*
store <2 x double> %191, <2 x double>* %196
%197 = getelementptr inbounds double, double* %195, i64 2
%198 = bitcast double* %197 to <2 x double>*
store <2 x double> %194, <2 x double>* %198
%199 = or i64 %162, 12
%200 = add nsw i64 %199, %140
%201 = getelementptr inbounds double, double* %4, i64 %200
%202 = bitcast double* %201 to <2 x double>*
%203 = load <2 x double>, <2 x double>* %202
%204 = getelementptr inbounds double, double* %201, i64 2
%205 = bitcast double* %204 to <2 x double>*
%206 = load <2 x double>, <2 x double>* %205
%207 = getelementptr inbounds double, double* %3, i64 %200
%208 = bitcast double* %207 to <2 x double>*
store <2 x double> %203, <2 x double>* %208
%209 = getelementptr inbounds double, double* %207, i64 2
%210 = bitcast double* %209 to <2 x double>*
store <2 x double> %206, <2 x double>* %210
%211 = add nuw i64 %162, 16
%212 = add nuw i64 %163, 4
%213 = icmp eq i64 %212, %160
br i1 %213, label %214, label %161
214: ; preds = %161, %152
%215 = phi i64 [ 0, %152 ], [ %211, %161 ]
%216 = icmp eq i64 %157, 0
br i1 %216, label %234, label %217
217: ; preds = %214, %217
%218 = phi i64 [ %231, %217 ], [ %215, %214 ]
%219 = phi i64 [ %232, %217 ], [ 0, %214 ]
%220 = add nsw i64 %218, %140
%221 = getelementptr inbounds double, double* %4, i64 %220
%222 = bitcast double* %221 to <2 x double>*
%223 = load <2 x double>, <2 x double>* %222
%224 = getelementptr inbounds double, double* %221, i64 2
%225 = bitcast double* %224 to <2 x double>*
%226 = load <2 x double>, <2 x double>* %225
%227 = getelementptr inbounds double, double* %3, i64 %220
%228 = bitcast double* %227 to <2 x double>*
store <2 x double> %223, <2 x double>* %228
%229 = getelementptr inbounds double, double* %227, i64 2
%230 = bitcast double* %229 to <2 x double>*
store <2 x double> %226, <2 x double>* %230
%231 = add nuw i64 %218, 4
%232 = add i64 %219, 1
%233 = icmp eq i64 %232, %157
br i1 %233, label %234, label %217
234: ; preds = %217, %214
%235 = icmp eq i64 %153, %141
br i1 %235, label %1012, label %236
236: ; preds = %143, %138, %234
%237 = phi i64 [ 0, %143 ], [ 0, %138 ], [ %153, %234 ]
%238 = xor i64 %237, -1
%239 = add nsw i64 %238, %141
%240 = and i64 %141, 3
%241 = icmp eq i64 %240, 0
br i1 %241, label %252, label %242
242: ; preds = %236, %242
%243 = phi i64 [ %249, %242 ], [ %237, %236 ]
%244 = phi i64 [ %250, %242 ], [ 0, %236 ]
%245 = add nsw i64 %243, %140
%246 = getelementptr inbounds double, double* %4, i64 %245
%247 = load double, double* %246
%248 = getelementptr inbounds double, double* %3, i64 %245
store double %247, double* %248
%249 = add nuw nsw i64 %243, 1
%250 = add i64 %244, 1
%251 = icmp eq i64 %250, %240
br i1 %251, label %252, label %242
252: ; preds = %242, %236
%253 = phi i64 [ %237, %236 ], [ %249, %242 ]
%254 = icmp ult i64 %239, 3
br i1 %254, label %1012, label %1025
255: ; preds = %646, %440
%256 = add nuw i32 %260, 1
%257 = icmp eq i64 %304, %21
br i1 %257, label %662, label %258
258: ; preds = %128, %255
%259 = phi i64 [ 0, %128 ], [ %304, %255 ]
%260 = phi i32 [ 1, %128 ], [ %256, %255 ]
%261 = trunc i64 %259 to i32
%262 = sub i32 %64, %261
%263 = zext i32 %262 to i64
%264 = add nuw nsw i64 %263, 1
%265 = and i64 %264, 8589934588
%266 = add nsw i64 %265, -4
%267 = lshr exact i64 %266, 2
%268 = add nuw nsw i64 %267, 1
%269 = trunc i64 %259 to i32
%270 = sub i32 %64, %269
%271 = zext i32 %270 to i64
%272 = add nuw nsw i64 %271, 1
%273 = trunc i64 %259 to i32
%274 = sub i32 %64, %273
%275 = zext i32 %274 to i64
%276 = add nuw nsw i64 %275, 1
%277 = mul i64 %62, %259
%278 = trunc i64 %259 to i32
%279 = sub i32 %64, %278
%280 = zext i32 %279 to i64
%281 = add i64 %109, %280
%282 = getelementptr i8, i8* %135, i64 %277
%283 = shl nuw nsw i64 %280, 3
%284 = getelementptr i8, i8* %282, i64 %283
%285 = mul i64 %259, %16
%286 = add i64 %111, %285
%287 = add i64 %112, %285
%288 = mul i64 %54, %259
%289 = add i64 %114, %285
%290 = getelementptr double, double* %2, i64 %289
%291 = add i64 %115, %285
%292 = getelementptr double, double* %2, i64 %291
%293 = trunc i64 %259 to i32
%294 = sext i32 %260 to i64
%295 = mul nsw i64 %259, %16
%296 = mul nsw i32 %293, %6
%297 = add nsw i64 %295, %127
%298 = sext i32 %296 to i64
%299 = add nsw i64 %127, %298
%300 = add nsw i64 %299, %259
%301 = getelementptr inbounds double, double* %1, i64 %300
%302 = load double, double* %301
%303 = fdiv double 1.000000e+00, %302
%304 = add nuw nsw i64 %259, 1
%305 = icmp slt i64 %304, %16
br i1 %305, label %306, label %379
306: ; preds = %258
%307 = icmp ult i32 %270, 3
br i1 %307, label %368, label %308
308: ; preds = %306
%309 = and i64 %272, 8589934588
%310 = add nsw i64 %309, %294
%311 = insertelement <2 x double> poison, double %303, i64 0
%312 = shufflevector <2 x double> %311, <2 x double> poison, <2 x i32> zeroinitializer
%313 = insertelement <2 x double> poison, double %303, i64 0
%314 = shufflevector <2 x double> %313, <2 x double> poison, <2 x i32> zeroinitializer
%315 = and i64 %268, 1
%316 = icmp eq i64 %266, 0
br i1 %316, label %350, label %317
317: ; preds = %308
%318 = and i64 %268, 9223372036854775806
br label %319
319: ; preds = %319, %317
%320 = phi i64 [ 0, %317 ], [ %347, %319 ]
%321 = phi i64 [ 0, %317 ], [ %348, %319 ]
%322 = add i64 %320, %294
%323 = add nsw i64 %322, %297
%324 = getelementptr inbounds double, double* %1, i64 %323
%325 = bitcast double* %324 to <2 x double>*
%326 = load <2 x double>, <2 x double>* %325
%327 = getelementptr inbounds double, double* %324, i64 2
%328 = bitcast double* %327 to <2 x double>*
%329 = load <2 x double>, <2 x double>* %328
%330 = fmul <2 x double> %312, %326
%331 = fmul <2 x double> %314, %329
%332 = bitcast double* %324 to <2 x double>*
store <2 x double> %330, <2 x double>* %332
%333 = bitcast double* %327 to <2 x double>*
store <2 x double> %331, <2 x double>* %333
%334 = or i64 %320, 4
%335 = add i64 %334, %294
%336 = add nsw i64 %335, %297
%337 = getelementptr inbounds double, double* %1, i64 %336
%338 = bitcast double* %337 to <2 x double>*
%339 = load <2 x double>, <2 x double>* %338
%340 = getelementptr inbounds double, double* %337, i64 2
%341 = bitcast double* %340 to <2 x double>*
%342 = load <2 x double>, <2 x double>* %341
%343 = fmul <2 x double> %312, %339
%344 = fmul <2 x double> %314, %342
%345 = bitcast double* %337 to <2 x double>*
store <2 x double> %343, <2 x double>* %345
%346 = bitcast double* %340 to <2 x double>*
store <2 x double> %344, <2 x double>* %346
%347 = add nuw i64 %320, 8
%348 = add i64 %321, 2
%349 = icmp eq i64 %348, %318
br i1 %349, label %350, label %319
350: ; preds = %319, %308
%351 = phi i64 [ 0, %308 ], [ %347, %319 ]
%352 = icmp eq i64 %315, 0
br i1 %352, label %366, label %353
353: ; preds = %350
%354 = add i64 %351, %294
%355 = add nsw i64 %354, %297
%356 = getelementptr inbounds double, double* %1, i64 %355
%357 = bitcast double* %356 to <2 x double>*
%358 = load <2 x double>, <2 x double>* %357
%359 = getelementptr inbounds double, double* %356, i64 2
%360 = bitcast double* %359 to <2 x double>*
%361 = load <2 x double>, <2 x double>* %360
%362 = fmul <2 x double> %312, %358
%363 = fmul <2 x double> %314, %361
%364 = bitcast double* %356 to <2 x double>*
store <2 x double> %362, <2 x double>* %364
%365 = bitcast double* %359 to <2 x double>*
store <2 x double> %363, <2 x double>* %365
br label %366
366: ; preds = %350, %353
%367 = icmp eq i64 %272, %309
br i1 %367, label %379, label %368
368: ; preds = %306, %366
%369 = phi i64 [ %294, %306 ], [ %310, %366 ]
br label %370
370: ; preds = %368, %370
%371 = phi i64 [ %376, %370 ], [ %369, %368 ]
%372 = add nsw i64 %371, %297
%373 = getelementptr inbounds double, double* %1, i64 %372
%374 = load double, double* %373
%375 = fmul double %303, %374
store double %375, double* %373
%376 = add nsw i64 %371, 1
%377 = trunc i64 %376 to i32
%378 = icmp eq i32 %377, %6
br i1 %378, label %379, label %370
379: ; preds = %370, %366, %258
br i1 %132, label %440, label %380
380: ; preds = %379
br i1 %71, label %430, label %381
381: ; preds = %380
%382 = insertelement <2 x double> poison, double %303, i64 0
%383 = shufflevector <2 x double> %382, <2 x double> poison, <2 x i32> zeroinitializer
%384 = insertelement <2 x double> poison, double %303, i64 0
%385 = shufflevector <2 x double> %384, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %74, label %415, label %386
386: ; preds = %381, %386
%387 = phi i64 [ %412, %386 ], [ 0, %381 ]
%388 = phi i64 [ %413, %386 ], [ 0, %381 ]
%389 = add nsw i64 %387, %297
%390 = getelementptr inbounds double, double* %2, i64 %389
%391 = bitcast double* %390 to <2 x double>*
%392 = load <2 x double>, <2 x double>* %391
%393 = getelementptr inbounds double, double* %390, i64 2
%394 = bitcast double* %393 to <2 x double>*
%395 = load <2 x double>, <2 x double>* %394
%396 = fmul <2 x double> %383, %392
%397 = fmul <2 x double> %385, %395
%398 = bitcast double* %390 to <2 x double>*
store <2 x double> %396, <2 x double>* %398
%399 = bitcast double* %393 to <2 x double>*
store <2 x double> %397, <2 x double>* %399
%400 = or i64 %387, 4
%401 = add nsw i64 %400, %297
%402 = getelementptr inbounds double, double* %2, i64 %401
%403 = bitcast double* %402 to <2 x double>*
%404 = load <2 x double>, <2 x double>* %403
%405 = getelementptr inbounds double, double* %402, i64 2
%406 = bitcast double* %405 to <2 x double>*
%407 = load <2 x double>, <2 x double>* %406
%408 = fmul <2 x double> %383, %404
%409 = fmul <2 x double> %385, %407
%410 = bitcast double* %402 to <2 x double>*
store <2 x double> %408, <2 x double>* %410
%411 = bitcast double* %405 to <2 x double>*
store <2 x double> %409, <2 x double>* %411
%412 = add nuw i64 %387, 8
%413 = add i64 %388, 2
%414 = icmp eq i64 %413, %75
br i1 %414, label %415, label %386
415: ; preds = %386, %381
%416 = phi i64 [ 0, %381 ], [ %412, %386 ]
br i1 %76, label %429, label %417
417: ; preds = %415
%418 = add nsw i64 %416, %297
%419 = getelementptr inbounds double, double* %2, i64 %418
%420 = bitcast double* %419 to <2 x double>*
%421 = load <2 x double>, <2 x double>* %420
%422 = getelementptr inbounds double, double* %419, i64 2
%423 = bitcast double* %422 to <2 x double>*
%424 = load <2 x double>, <2 x double>* %423
%425 = fmul <2 x double> %383, %421
%426 = fmul <2 x double> %385, %424
%427 = bitcast double* %419 to <2 x double>*
store <2 x double> %425, <2 x double>* %427
%428 = bitcast double* %422 to <2 x double>*
store <2 x double> %426, <2 x double>* %428
br label %429
429: ; preds = %415, %417
br i1 %77, label %440, label %430
430: ; preds = %380, %429
%431 = phi i64 [ 0, %380 ], [ %72, %429 ]
br label %432
432: ; preds = %430, %432
%433 = phi i64 [ %438, %432 ], [ %431, %430 ]
%434 = add nsw i64 %433, %297
%435 = getelementptr inbounds double, double* %2, i64 %434
%436 = load double, double* %435
%437 = fmul double %303, %436
store double %437, double* %435
%438 = add nuw nsw i64 %433, 1
%439 = icmp eq i64 %438, %22
br i1 %439, label %440, label %432
440: ; preds = %432, %429, %379
%441 = add nsw i64 %259, %126
%442 = getelementptr inbounds double, double* %4, i64 %441
%443 = load double, double* %442
%444 = fmul double %303, %443
store double %444, double* %442
br i1 %305, label %445, label %255
445: ; preds = %440
%446 = add i64 %259, %127
%447 = icmp ult i32 %274, 3
%448 = and i64 %276, 8589934588
%449 = add nsw i64 %448, %294
%450 = icmp eq i64 %276, %448
br label %451
451: ; preds = %646, %445
%452 = phi i64 [ %661, %646 ], [ 0, %445 ]
%453 = phi i64 [ %658, %646 ], [ %294, %445 ]
%454 = mul i64 %452, %16
%455 = mul i64 %452, %16
%456 = add i64 %286, %455
%457 = getelementptr double, double* %2, i64 %456
%458 = bitcast double* %457 to i8*
%459 = add i64 %287, %455
%460 = getelementptr double, double* %2, i64 %459
%461 = bitcast double* %460 to i8*
%462 = add i64 %111, %455
%463 = getelementptr double, double* %1, i64 %462
%464 = bitcast double* %463 to i8*
%465 = getelementptr i8, i8* %464, i64 %288
%466 = add i64 %113, %455
%467 = getelementptr double, double* %1, i64 %466
%468 = bitcast double* %467 to i8*
%469 = getelementptr i8, i8* %468, i64 %288
%470 = mul nsw i64 %453, %16
%471 = add nsw i64 %470, %127
%472 = add nsw i64 %471, %259
%473 = getelementptr inbounds double, double* %1, i64 %472
br i1 %447, label %516, label %474
474: ; preds = %451
%475 = add i64 %281, %454
%476 = getelementptr double, double* %1, i64 %475
%477 = add i64 %108, %454
%478 = getelementptr double, double* %1, i64 %477
%479 = bitcast double* %478 to i8*
%480 = getelementptr i8, i8* %479, i64 %277
%481 = icmp ult i8* %480, %284
%482 = icmp ult double* %133, %476
%483 = and i1 %481, %482
br i1 %483, label %516, label %484
484: ; preds = %474
%485 = load double, double* %473
%486 = insertelement <2 x double> poison, double %485, i64 0
%487 = shufflevector <2 x double> %486, <2 x double> poison, <2 x i32> zeroinitializer
%488 = insertelement <2 x double> poison, double %485, i64 0
%489 = shufflevector <2 x double> %488, <2 x double> poison, <2 x i32> zeroinitializer
%490 = fneg <2 x double> %487
%491 = fneg <2 x double> %489
br label %492
492: ; preds = %492, %484
%493 = phi i64 [ 0, %484 ], [ %513, %492 ]
%494 = add i64 %493, %294
%495 = add nsw i64 %494, %471
%496 = getelementptr inbounds double, double* %1, i64 %495
%497 = bitcast double* %496 to <2 x double>*
%498 = load <2 x double>, <2 x double>* %497
%499 = getelementptr inbounds double, double* %496, i64 2
%500 = bitcast double* %499 to <2 x double>*
%501 = load <2 x double>, <2 x double>* %500
%502 = add nsw i64 %494, %297
%503 = getelementptr inbounds double, double* %1, i64 %502
%504 = bitcast double* %503 to <2 x double>*
%505 = load <2 x double>, <2 x double>* %504
%506 = getelementptr inbounds double, double* %503, i64 2
%507 = bitcast double* %506 to <2 x double>*
%508 = load <2 x double>, <2 x double>* %507
%509 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %490, <2 x double> %505, <2 x double> %498)
%510 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %491, <2 x double> %508, <2 x double> %501)
%511 = bitcast double* %496 to <2 x double>*
store <2 x double> %509, <2 x double>* %511
%512 = bitcast double* %499 to <2 x double>*
store <2 x double> %510, <2 x double>* %512
%513 = add nuw i64 %493, 4
%514 = icmp eq i64 %513, %448
br i1 %514, label %515, label %492
515: ; preds = %492
br i1 %450, label %561, label %516
516: ; preds = %474, %451, %515
%517 = phi i64 [ %294, %474 ], [ %294, %451 ], [ %449, %515 ]
%518 = trunc i64 %517 to i32
%519 = sub i32 %6, %518
%520 = xor i32 %518, -1
%521 = and i32 %519, 1
%522 = icmp eq i32 %521, 0
br i1 %522, label %534, label %523
523: ; preds = %516
%524 = add nsw i64 %517, %471
%525 = getelementptr inbounds double, double* %1, i64 %524
%526 = load double, double* %525
%527 = load double, double* %473
%528 = add nsw i64 %517, %297
%529 = getelementptr inbounds double, double* %1, i64 %528
%530 = load double, double* %529
%531 = fneg double %527
%532 = tail call double @llvm.fmuladd.f64(double %531, double %530, double %526)
store double %532, double* %525
%533 = add nsw i64 %517, 1
br label %534
534: ; preds = %523, %516
%535 = phi i64 [ %517, %516 ], [ %533, %523 ]
%536 = icmp eq i32 %520, %78
br i1 %536, label %561, label %537
537: ; preds = %534, %537
%538 = phi i64 [ %558, %537 ], [ %535, %534 ]
%539 = add nsw i64 %538, %471
%540 = getelementptr inbounds double, double* %1, i64 %539
%541 = load double, double* %540
%542 = load double, double* %473
%543 = add nsw i64 %538, %297
%544 = getelementptr inbounds double, double* %1, i64 %543
%545 = load double, double* %544
%546 = fneg double %542
%547 = tail call double @llvm.fmuladd.f64(double %546, double %545, double %541)
store double %547, double* %540
%548 = add nuw nsw i64 %538, 1
%549 = add nsw i64 %548, %471
%550 = getelementptr inbounds double, double* %1, i64 %549
%551 = load double, double* %550
%552 = load double, double* %473
%553 = add nsw i64 %548, %297
%554 = getelementptr inbounds double, double* %1, i64 %553
%555 = load double, double* %554
%556 = fneg double %552
%557 = tail call double @llvm.fmuladd.f64(double %556, double %555, double %551)
store double %557, double* %550
%558 = add nuw nsw i64 %538, 2
%559 = trunc i64 %558 to i32
%560 = icmp eq i32 %559, %6
br i1 %560, label %561, label %537
561: ; preds = %534, %537, %515
%562 = mul nsw i64 %453, %16
br i1 %132, label %646, label %563
563: ; preds = %561
%564 = add nsw i64 %562, %127
%565 = add nsw i64 %564, %259
%566 = getelementptr inbounds double, double* %1, i64 %565
br i1 %79, label %606, label %567
567: ; preds = %563
%568 = icmp ugt i8* %469, %458
%569 = icmp ult i8* %465, %461
%570 = and i1 %568, %569
%571 = icmp ult double* %457, %292
%572 = icmp ult double* %290, %460
%573 = and i1 %571, %572
%574 = or i1 %570, %573
br i1 %574, label %606, label %575
575: ; preds = %567
%576 = load double, double* %566
%577 = insertelement <2 x double> poison, double %576, i64 0
%578 = shufflevector <2 x double> %577, <2 x double> poison, <2 x i32> zeroinitializer
%579 = insertelement <2 x double> poison, double %576, i64 0
%580 = shufflevector <2 x double> %579, <2 x double> poison, <2 x i32> zeroinitializer
%581 = fneg <2 x double> %578
%582 = fneg <2 x double> %580
br label %583
583: ; preds = %583, %575
%584 = phi i64 [ 0, %575 ], [ %603, %583 ]
%585 = add nsw i64 %584, %564
%586 = getelementptr inbounds double, double* %2, i64 %585
%587 = bitcast double* %586 to <2 x double>*
%588 = load <2 x double>, <2 x double>* %587
%589 = getelementptr inbounds double, double* %586, i64 2
%590 = bitcast double* %589 to <2 x double>*
%591 = load <2 x double>, <2 x double>* %590
%592 = add nsw i64 %584, %297
%593 = getelementptr inbounds double, double* %2, i64 %592
%594 = bitcast double* %593 to <2 x double>*
%595 = load <2 x double>, <2 x double>* %594
%596 = getelementptr inbounds double, double* %593, i64 2
%597 = bitcast double* %596 to <2 x double>*
%598 = load <2 x double>, <2 x double>* %597
%599 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %581, <2 x double> %595, <2 x double> %588)
%600 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %582, <2 x double> %598, <2 x double> %591)
%601 = bitcast double* %586 to <2 x double>*
store <2 x double> %599, <2 x double>* %601
%602 = bitcast double* %589 to <2 x double>*
store <2 x double> %600, <2 x double>* %602
%603 = add nuw i64 %584, 4
%604 = icmp eq i64 %603, %80
br i1 %604, label %605, label %583
605: ; preds = %583
br i1 %81, label %646, label %606
606: ; preds = %567, %563, %605
%607 = phi i64 [ 0, %567 ], [ 0, %563 ], [ %80, %605 ]
%608 = xor i64 %607, -1
br i1 %83, label %620, label %609
609: ; preds = %606
%610 = add nsw i64 %607, %564
%611 = getelementptr inbounds double, double* %2, i64 %610
%612 = load double, double* %611
%613 = load double, double* %566
%614 = add nsw i64 %607, %297
%615 = getelementptr inbounds double, double* %2, i64 %614
%616 = load double, double* %615
%617 = fneg double %613
%618 = tail call double @llvm.fmuladd.f64(double %617, double %616, double %612)
store double %618, double* %611
%619 = or i64 %607, 1
br label %620
620: ; preds = %609, %606
%621 = phi i64 [ %607, %606 ], [ %619, %609 ]
%622 = icmp eq i64 %608, %84
br i1 %622, label %646, label %623
623: ; preds = %620, %623
%624 = phi i64 [ %644, %623 ], [ %621, %620 ]
%625 = add nsw i64 %624, %564
%626 = getelementptr inbounds double, double* %2, i64 %625
%627 = load double, double* %626
%628 = load double, double* %566
%629 = add nsw i64 %624, %297
%630 = getelementptr inbounds double, double* %2, i64 %629
%631 = load double, double* %630
%632 = fneg double %628
%633 = tail call double @llvm.fmuladd.f64(double %632, double %631, double %627)
store double %633, double* %626
%634 = add nuw nsw i64 %624, 1
%635 = add nsw i64 %634, %564
%636 = getelementptr inbounds double, double* %2, i64 %635
%637 = load double, double* %636
%638 = load double, double* %566
%639 = add nsw i64 %634, %297
%640 = getelementptr inbounds double, double* %2, i64 %639
%641 = load double, double* %640
%642 = fneg double %638
%643 = tail call double @llvm.fmuladd.f64(double %642, double %641, double %637)
store double %643, double* %636
%644 = add nuw nsw i64 %624, 2
%645 = icmp eq i64 %644, %23
br i1 %645, label %646, label %623
646: ; preds = %620, %623, %605, %561
%647 = add nsw i64 %453, %126
%648 = getelementptr inbounds double, double* %4, i64 %647
%649 = load double, double* %648
%650 = add i64 %446, %562
%651 = shl i64 %650, 32
%652 = ashr exact i64 %651, 32
%653 = getelementptr inbounds double, double* %1, i64 %652
%654 = load double, double* %653
%655 = load double, double* %442
%656 = fneg double %654
%657 = tail call double @llvm.fmuladd.f64(double %656, double %655, double %649)
store double %657, double* %648
%658 = add nsw i64 %453, 1
%659 = trunc i64 %658 to i32
%660 = icmp eq i32 %659, %6
%661 = add i64 %452, 1
br i1 %660, label %255, label %451
662: ; preds = %255, %104
%663 = add nsw i64 %127, %19
%664 = add nsw i64 %663, %17
%665 = getelementptr inbounds double, double* %1, i64 %664
%666 = load double, double* %665
%667 = fdiv double 1.000000e+00, %666
br i1 %15, label %668, label %728
668: ; preds = %662
br i1 %85, label %718, label %669
669: ; preds = %668
%670 = insertelement <2 x double> poison, double %667, i64 0
%671 = shufflevector <2 x double> %670, <2 x double> poison, <2 x i32> zeroinitializer
%672 = insertelement <2 x double> poison, double %667, i64 0
%673 = shufflevector <2 x double> %672, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %88, label %703, label %674
674: ; preds = %669, %674
%675 = phi i64 [ %700, %674 ], [ 0, %669 ]
%676 = phi i64 [ %701, %674 ], [ 0, %669 ]
%677 = add nsw i64 %675, %663
%678 = getelementptr inbounds double, double* %2, i64 %677
%679 = bitcast double* %678 to <2 x double>*
%680 = load <2 x double>, <2 x double>* %679
%681 = getelementptr inbounds double, double* %678, i64 2
%682 = bitcast double* %681 to <2 x double>*
%683 = load <2 x double>, <2 x double>* %682
%684 = fmul <2 x double> %671, %680
%685 = fmul <2 x double> %673, %683
%686 = bitcast double* %678 to <2 x double>*
store <2 x double> %684, <2 x double>* %686
%687 = bitcast double* %681 to <2 x double>*
store <2 x double> %685, <2 x double>* %687
%688 = or i64 %675, 4
%689 = add nsw i64 %688, %663
%690 = getelementptr inbounds double, double* %2, i64 %689
%691 = bitcast double* %690 to <2 x double>*
%692 = load <2 x double>, <2 x double>* %691
%693 = getelementptr inbounds double, double* %690, i64 2
%694 = bitcast double* %693 to <2 x double>*
%695 = load <2 x double>, <2 x double>* %694
%696 = fmul <2 x double> %671, %692
%697 = fmul <2 x double> %673, %695
%698 = bitcast double* %690 to <2 x double>*
store <2 x double> %696, <2 x double>* %698
%699 = bitcast double* %693 to <2 x double>*
store <2 x double> %697, <2 x double>* %699
%700 = add nuw i64 %675, 8
%701 = add i64 %676, 2
%702 = icmp eq i64 %701, %89
br i1 %702, label %703, label %674
703: ; preds = %674, %669
%704 = phi i64 [ 0, %669 ], [ %700, %674 ]
br i1 %90, label %717, label %705
705: ; preds = %703
%706 = add nsw i64 %704, %663
%707 = getelementptr inbounds double, double* %2, i64 %706
%708 = bitcast double* %707 to <2 x double>*
%709 = load <2 x double>, <2 x double>* %708
%710 = getelementptr inbounds double, double* %707, i64 2
%711 = bitcast double* %710 to <2 x double>*
%712 = load <2 x double>, <2 x double>* %711
%713 = fmul <2 x double> %671, %709
%714 = fmul <2 x double> %673, %712
%715 = bitcast double* %707 to <2 x double>*
store <2 x double> %713, <2 x double>* %715
%716 = bitcast double* %710 to <2 x double>*
store <2 x double> %714, <2 x double>* %716
br label %717
717: ; preds = %703, %705
br i1 %91, label %728, label %718
718: ; preds = %668, %717
%719 = phi i64 [ 0, %668 ], [ %86, %717 ]
br label %720
720: ; preds = %718, %720
%721 = phi i64 [ %726, %720 ], [ %719, %718 ]
%722 = add nsw i64 %721, %663
%723 = getelementptr inbounds double, double* %2, i64 %722
%724 = load double, double* %723
%725 = fmul double %667, %724
store double %725, double* %723
%726 = add nuw nsw i64 %721, 1
%727 = icmp eq i64 %726, %24
br i1 %727, label %728, label %720
728: ; preds = %720, %717, %662
%729 = add nsw i64 %126, %17
%730 = getelementptr inbounds double, double* %4, i64 %729
%731 = load double, double* %730
%732 = fmul double %667, %731
store double %732, double* %730
br i1 %12, label %876, label %733
733: ; preds = %728
%734 = icmp eq i64 %106, %18
%735 = trunc i64 %127 to i32
%736 = or i1 %734, %13
br label %737
737: ; preds = %733, %872
%738 = phi i64 [ 0, %733 ], [ %873, %872 ]
%739 = phi i32 [ %9, %733 ], [ %874, %872 ]
%740 = mul i64 %738, %42
%741 = add i64 %740, %40
%742 = sub i64 %118, %738
%743 = mul i64 %738, %16
%744 = sub i64 %119, %743
%745 = getelementptr double, double* %2, i64 %744
%746 = sub i64 %120, %743
%747 = getelementptr double, double* %2, i64 %746
%748 = sub nsw i64 %17, %738
%749 = icmp sgt i64 %748, 0
br i1 %749, label %750, label %872
750: ; preds = %737
%751 = mul nsw i64 %748, %16
%752 = add nsw i64 %751, %127
%753 = trunc i64 %748 to i32
%754 = add i32 %753, %735
%755 = add nsw i64 %748, %126
%756 = getelementptr inbounds double, double* %4, i64 %755
%757 = zext i32 %739 to i64
br label %758
758: ; preds = %750, %858
%759 = phi i64 [ 0, %750 ], [ %870, %858 ]
%760 = mul i64 %759, %42
%761 = add i64 %741, %760
%762 = shl i64 %761, 32
%763 = ashr exact i64 %762, 32
%764 = add i64 %117, %763
%765 = getelementptr double, double* %2, i64 %764
%766 = getelementptr double, double* %43, i64 %764
%767 = add i64 %742, %763
%768 = getelementptr double, double* %1, i64 %767
%769 = getelementptr double, double* %45, i64 %767
%770 = trunc i64 %759 to i32
%771 = xor i32 %770, -1
%772 = add i32 %753, %771
%773 = mul nsw i32 %772, %6
br i1 %736, label %858, label %774
774: ; preds = %758
%775 = sext i32 %773 to i64
%776 = add nsw i64 %127, %775
%777 = add nsw i64 %776, %748
%778 = getelementptr inbounds double, double* %1, i64 %777
br i1 %92, label %818, label %779
779: ; preds = %774
%780 = icmp ult double* %765, %769
%781 = icmp ult double* %768, %766
%782 = and i1 %780, %781
%783 = icmp ult double* %765, %747
%784 = icmp ult double* %745, %766
%785 = and i1 %783, %784
%786 = or i1 %782, %785
br i1 %786, label %818, label %787
787: ; preds = %779
%788 = load double, double* %778
%789 = insertelement <2 x double> poison, double %788, i64 0
%790 = shufflevector <2 x double> %789, <2 x double> poison, <2 x i32> zeroinitializer
%791 = insertelement <2 x double> poison, double %788, i64 0
%792 = shufflevector <2 x double> %791, <2 x double> poison, <2 x i32> zeroinitializer
%793 = fneg <2 x double> %790
%794 = fneg <2 x double> %792
br label %795
795: ; preds = %795, %787
%796 = phi i64 [ 0, %787 ], [ %815, %795 ]
%797 = add nsw i64 %796, %776
%798 = getelementptr inbounds double, double* %2, i64 %797
%799 = bitcast double* %798 to <2 x double>*
%800 = load <2 x double>, <2 x double>* %799
%801 = getelementptr inbounds double, double* %798, i64 2
%802 = bitcast double* %801 to <2 x double>*
%803 = load <2 x double>, <2 x double>* %802
%804 = add nsw i64 %752, %796
%805 = getelementptr inbounds double, double* %2, i64 %804
%806 = bitcast double* %805 to <2 x double>*
%807 = load <2 x double>, <2 x double>* %806
%808 = getelementptr inbounds double, double* %805, i64 2
%809 = bitcast double* %808 to <2 x double>*
%810 = load <2 x double>, <2 x double>* %809
%811 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %793, <2 x double> %807, <2 x double> %800)
%812 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %794, <2 x double> %810, <2 x double> %803)
%813 = bitcast double* %798 to <2 x double>*
store <2 x double> %811, <2 x double>* %813
%814 = bitcast double* %801 to <2 x double>*
store <2 x double> %812, <2 x double>* %814
%815 = add nuw i64 %796, 4
%816 = icmp eq i64 %815, %93
br i1 %816, label %817, label %795
817: ; preds = %795
br i1 %94, label %858, label %818
818: ; preds = %779, %774, %817
%819 = phi i64 [ 0, %779 ], [ 0, %774 ], [ %93, %817 ]
%820 = xor i64 %819, -1
br i1 %96, label %832, label %821
821: ; preds = %818
%822 = add nsw i64 %819, %776
%823 = getelementptr inbounds double, double* %2, i64 %822
%824 = load double, double* %823
%825 = load double, double* %778
%826 = add nsw i64 %752, %819
%827 = getelementptr inbounds double, double* %2, i64 %826
%828 = load double, double* %827
%829 = fneg double %825
%830 = tail call double @llvm.fmuladd.f64(double %829, double %828, double %824)
store double %830, double* %823
%831 = or i64 %819, 1
br label %832
832: ; preds = %821, %818
%833 = phi i64 [ %819, %818 ], [ %831, %821 ]
%834 = icmp eq i64 %820, %97
br i1 %834, label %858, label %835
835: ; preds = %832, %835
%836 = phi i64 [ %856, %835 ], [ %833, %832 ]
%837 = add nsw i64 %836, %776
%838 = getelementptr inbounds double, double* %2, i64 %837
%839 = load double, double* %838
%840 = load double, double* %778
%841 = add nsw i64 %752, %836
%842 = getelementptr inbounds double, double* %2, i64 %841
%843 = load double, double* %842
%844 = fneg double %840
%845 = tail call double @llvm.fmuladd.f64(double %844, double %843, double %839)
store double %845, double* %838
%846 = add nuw nsw i64 %836, 1
%847 = add nsw i64 %846, %776
%848 = getelementptr inbounds double, double* %2, i64 %847
%849 = load double, double* %848
%850 = load double, double* %778
%851 = add nsw i64 %752, %846
%852 = getelementptr inbounds double, double* %2, i64 %851
%853 = load double, double* %852
%854 = fneg double %850
%855 = tail call double @llvm.fmuladd.f64(double %854, double %853, double %849)
store double %855, double* %848
%856 = add nuw nsw i64 %836, 2
%857 = icmp eq i64 %856, %26
br i1 %857, label %858, label %835
858: ; preds = %832, %835, %817, %758
%859 = sext i32 %772 to i64
%860 = add nsw i64 %126, %859
%861 = getelementptr inbounds double, double* %4, i64 %860
%862 = load double, double* %861
%863 = add i32 %754, %773
%864 = sext i32 %863 to i64
%865 = getelementptr inbounds double, double* %1, i64 %864
%866 = load double, double* %865
%867 = load double, double* %756
%868 = fneg double %866
%869 = tail call double @llvm.fmuladd.f64(double %868, double %867, double %862)
store double %869, double* %861
%870 = add nuw nsw i64 %759, 1
%871 = icmp eq i64 %870, %757
br i1 %871, label %872, label %758
872: ; preds = %858, %737
%873 = add nuw nsw i64 %738, 1
%874 = add i32 %739, -1
%875 = icmp eq i64 %873, %25
br i1 %875, label %876, label %737
876: ; preds = %872, %728
%877 = icmp eq i64 %106, %18
%878 = or i1 %877, %13
%879 = add nuw nsw i64 %106, 1
br i1 %878, label %1009, label %880
880: ; preds = %876
%881 = mul nsw i64 %879, %16
%882 = trunc i64 %881 to i32
br label %883
883: ; preds = %880, %1006
%884 = phi i64 [ 0, %880 ], [ %1007, %1006 ]
%885 = mul i64 %884, %16
%886 = add i64 %124, %885
%887 = getelementptr double, double* %2, i64 %886
%888 = add i64 %125, %885
%889 = getelementptr double, double* %2, i64 %888
br i1 %15, label %890, label %1006
890: ; preds = %883
%891 = mul nsw i64 %884, %16
%892 = add nsw i64 %891, %127
%893 = add nsw i64 %884, %126
%894 = getelementptr inbounds double, double* %4, i64 %893
br label %895
895: ; preds = %991, %890
%896 = phi i64 [ 0, %890 ], [ %1004, %991 ]
%897 = mul i64 %896, %22
%898 = add i64 %122, %897
%899 = shl i64 %898, 32
%900 = ashr exact i64 %899, 32
%901 = getelementptr double, double* %1, i64 %900
%902 = getelementptr double, double* %32, i64 %900
%903 = add nsw i64 %884, %900
%904 = trunc i64 %896 to i32
%905 = add i32 %904, %882
%906 = mul i32 %905, %6
%907 = sext i32 %906 to i64
%908 = add nsw i64 %884, %907
%909 = getelementptr inbounds double, double* %0, i64 %908
br i1 %98, label %951, label %910
910: ; preds = %895
%911 = getelementptr double, double* %33, i64 %903
%912 = getelementptr double, double* %0, i64 %903
%913 = icmp ult double* %901, %911
%914 = icmp ult double* %912, %902
%915 = and i1 %913, %914
%916 = icmp ult double* %901, %889
%917 = icmp ult double* %887, %902
%918 = and i1 %916, %917
%919 = or i1 %915, %918
br i1 %919, label %951, label %920
920: ; preds = %910
%921 = load double, double* %909
%922 = insertelement <2 x double> poison, double %921, i64 0
%923 = shufflevector <2 x double> %922, <2 x double> poison, <2 x i32> zeroinitializer
%924 = insertelement <2 x double> poison, double %921, i64 0
%925 = shufflevector <2 x double> %924, <2 x double> poison, <2 x i32> zeroinitializer
%926 = fneg <2 x double> %923
%927 = fneg <2 x double> %925
br label %928
928: ; preds = %928, %920
%929 = phi i64 [ 0, %920 ], [ %948, %928 ]
%930 = add nsw i64 %929, %907
%931 = getelementptr inbounds double, double* %1, i64 %930
%932 = bitcast double* %931 to <2 x double>*
%933 = load <2 x double>, <2 x double>* %932
%934 = getelementptr inbounds double, double* %931, i64 2
%935 = bitcast double* %934 to <2 x double>*
%936 = load <2 x double>, <2 x double>* %935
%937 = add nsw i64 %892, %929
%938 = getelementptr inbounds double, double* %2, i64 %937
%939 = bitcast double* %938 to <2 x double>*
%940 = load <2 x double>, <2 x double>* %939
%941 = getelementptr inbounds double, double* %938, i64 2
%942 = bitcast double* %941 to <2 x double>*
%943 = load <2 x double>, <2 x double>* %942
%944 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %926, <2 x double> %940, <2 x double> %933)
%945 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %927, <2 x double> %943, <2 x double> %936)
%946 = bitcast double* %931 to <2 x double>*
store <2 x double> %944, <2 x double>* %946
%947 = bitcast double* %934 to <2 x double>*
store <2 x double> %945, <2 x double>* %947
%948 = add nuw i64 %929, 4
%949 = icmp eq i64 %948, %99
br i1 %949, label %950, label %928
950: ; preds = %928
br i1 %100, label %991, label %951
951: ; preds = %910, %895, %950
%952 = phi i64 [ 0, %910 ], [ 0, %895 ], [ %99, %950 ]
%953 = xor i64 %952, -1
br i1 %102, label %965, label %954
954: ; preds = %951
%955 = add nsw i64 %952, %907
%956 = getelementptr inbounds double, double* %1, i64 %955
%957 = load double, double* %956
%958 = load double, double* %909
%959 = add nsw i64 %892, %952
%960 = getelementptr inbounds double, double* %2, i64 %959
%961 = load double, double* %960
%962 = fneg double %958
%963 = tail call double @llvm.fmuladd.f64(double %962, double %961, double %957)
store double %963, double* %956
%964 = or i64 %952, 1
br label %965
965: ; preds = %954, %951
%966 = phi i64 [ %952, %951 ], [ %964, %954 ]
%967 = icmp eq i64 %953, %103
br i1 %967, label %991, label %968
968: ; preds = %965, %968
%969 = phi i64 [ %989, %968 ], [ %966, %965 ]
%970 = add nsw i64 %969, %907
%971 = getelementptr inbounds double, double* %1, i64 %970
%972 = load double, double* %971
%973 = load double, double* %909
%974 = add nsw i64 %892, %969
%975 = getelementptr inbounds double, double* %2, i64 %974
%976 = load double, double* %975
%977 = fneg double %973
%978 = tail call double @llvm.fmuladd.f64(double %977, double %976, double %972)
store double %978, double* %971
%979 = add nuw nsw i64 %969, 1
%980 = add nsw i64 %979, %907
%981 = getelementptr inbounds double, double* %1, i64 %980
%982 = load double, double* %981
%983 = load double, double* %909
%984 = add nsw i64 %892, %979
%985 = getelementptr inbounds double, double* %2, i64 %984
%986 = load double, double* %985
%987 = fneg double %983
%988 = tail call double @llvm.fmuladd.f64(double %987, double %986, double %982)
store double %988, double* %981
%989 = add nuw nsw i64 %969, 2
%990 = icmp eq i64 %989, %27
br i1 %990, label %991, label %968
991: ; preds = %965, %968, %950
%992 = add nsw i64 %896, %881
%993 = getelementptr inbounds double, double* %4, i64 %992
%994 = load double, double* %993
%995 = trunc i64 %992 to i32
%996 = mul i32 %995, %6
%997 = sext i32 %996 to i64
%998 = add nsw i64 %884, %997
%999 = getelementptr inbounds double, double* %0, i64 %998
%1000 = load double, double* %999
%1001 = load double, double* %894
%1002 = fneg double %1000
%1003 = tail call double @llvm.fmuladd.f64(double %1002, double %1001, double %994)
store double %1003, double* %993
%1004 = add nuw nsw i64 %896, 1
%1005 = icmp eq i64 %1004, %27
br i1 %1005, label %1006, label %895
1006: ; preds = %991, %883
%1007 = add nuw nsw i64 %884, 1
%1008 = icmp eq i64 %1007, %27
br i1 %1008, label %1009, label %883
1009: ; preds = %1006, %876
%1010 = icmp eq i64 %879, %20
%1011 = add i64 %105, 1
br i1 %1010, label %136, label %104
1012: ; preds = %252, %1025, %234, %136
%1013 = icmp slt i32 %5, 3
br i1 %1013, label %1109, label %1014
1014: ; preds = %1012
%1015 = sext i32 %9 to i64
%1016 = zext i32 %8 to i64
%1017 = sext i32 %6 to i64
%1018 = add nsw i32 %5, -2
%1019 = zext i32 %1018 to i64
%1020 = zext i32 %6 to i64
%1021 = and i64 %1020, 1
%1022 = icmp eq i32 %6, 1
%1023 = and i64 %1020, 4294967294
%1024 = icmp eq i64 %1021, 0
br label %1048
1025: ; preds = %252, %1025
%1026 = phi i64 [ %1046, %1025 ], [ %253, %252 ]
%1027 = add nsw i64 %1026, %140
%1028 = getelementptr inbounds double, double* %4, i64 %1027
%1029 = load double, double* %1028
%1030 = getelementptr inbounds double, double* %3, i64 %1027
store double %1029, double* %1030
%1031 = add nuw nsw i64 %1026, 1
%1032 = add nsw i64 %1031, %140
%1033 = getelementptr inbounds double, double* %4, i64 %1032
%1034 = load double, double* %1033
%1035 = getelementptr inbounds double, double* %3, i64 %1032
store double %1034, double* %1035
%1036 = add nuw nsw i64 %1026, 2
%1037 = add nsw i64 %1036, %140
%1038 = getelementptr inbounds double, double* %4, i64 %1037
%1039 = load double, double* %1038
%1040 = getelementptr inbounds double, double* %3, i64 %1037
store double %1039, double* %1040
%1041 = add nuw nsw i64 %1026, 3
%1042 = add nsw i64 %1041, %140
%1043 = getelementptr inbounds double, double* %4, i64 %1042
%1044 = load double, double* %1043
%1045 = getelementptr inbounds double, double* %3, i64 %1042
store double %1044, double* %1045
%1046 = add nuw nsw i64 %1026, 4
%1047 = icmp eq i64 %1046, %141
br i1 %1047, label %1012, label %1025
1048: ; preds = %1014, %1106
%1049 = phi i64 [ 0, %1014 ], [ %1107, %1106 ]
%1050 = sub nsw i64 %1016, %1049
br i1 %137, label %1051, label %1106
1051: ; preds = %1048
%1052 = add nsw i64 %1050, -1
%1053 = mul nsw i64 %1052, %1017
%1054 = mul nsw i64 %1050, %1017
%1055 = trunc i64 %1053 to i32
br label %1056
1056: ; preds = %1097, %1051
%1057 = phi i64 [ 0, %1051 ], [ %1104, %1097 ]
%1058 = sub nsw i64 %1015, %1057
%1059 = trunc i64 %1058 to i32
%1060 = add i32 %1059, %1055
%1061 = mul i32 %1060, %6
%1062 = sext i32 %1061 to i64
br i1 %1022, label %1085, label %1063
1063: ; preds = %1056, %1063
%1064 = phi i64 [ %1082, %1063 ], [ 0, %1056 ]
%1065 = phi double [ %1081, %1063 ], [ 0.000000e+00, %1056 ]
%1066 = phi i64 [ %1083, %1063 ], [ 0, %1056 ]
%1067 = add nsw i64 %1064, %1062
%1068 = getelementptr inbounds double, double* %2, i64 %1067
%1069 = load double, double* %1068
%1070 = add nsw i64 %1064, %1054
%1071 = getelementptr inbounds double, double* %3, i64 %1070
%1072 = load double, double* %1071
%1073 = tail call double @llvm.fmuladd.f64(double %1069, double %1072, double %1065)
%1074 = or i64 %1064, 1
%1075 = add nsw i64 %1074, %1062
%1076 = getelementptr inbounds double, double* %2, i64 %1075
%1077 = load double, double* %1076
%1078 = add nsw i64 %1074, %1054
%1079 = getelementptr inbounds double, double* %3, i64 %1078
%1080 = load double, double* %1079
%1081 = tail call double @llvm.fmuladd.f64(double %1077, double %1080, double %1073)
%1082 = add nuw nsw i64 %1064, 2
%1083 = add i64 %1066, 2
%1084 = icmp eq i64 %1083, %1023
br i1 %1084, label %1085, label %1063
1085: ; preds = %1063, %1056
%1086 = phi double [ undef, %1056 ], [ %1081, %1063 ]
%1087 = phi i64 [ 0, %1056 ], [ %1082, %1063 ]
%1088 = phi double [ 0.000000e+00, %1056 ], [ %1081, %1063 ]
br i1 %1024, label %1097, label %1089
1089: ; preds = %1085
%1090 = add nsw i64 %1087, %1062
%1091 = getelementptr inbounds double, double* %2, i64 %1090
%1092 = load double, double* %1091
%1093 = add nsw i64 %1087, %1054
%1094 = getelementptr inbounds double, double* %3, i64 %1093
%1095 = load double, double* %1094
%1096 = tail call double @llvm.fmuladd.f64(double %1092, double %1095, double %1088)
br label %1097
1097: ; preds = %1085, %1089
%1098 = phi double [ %1086, %1085 ], [ %1096, %1089 ]
%1099 = add nsw i64 %1058, %1053
%1100 = getelementptr inbounds double, double* %4, i64 %1099
%1101 = load double, double* %1100
%1102 = fsub double %1101, %1098
%1103 = getelementptr inbounds double, double* %3, i64 %1099
store double %1102, double* %1103
%1104 = add nuw nsw i64 %1057, 1
%1105 = icmp eq i64 %1104, %1020
br i1 %1105, label %1106, label %1056
1106: ; preds = %1097, %1048
%1107 = add nuw nsw i64 %1049, 1
%1108 = icmp eq i64 %1107, %1019
br i1 %1108, label %1109, label %1048
1109: ; preds = %1106, %1012
ret void
}