void asg_pstep3d(float ***restrict bulk, float ***restrict p0,
                 float ***restrict p1, float ***restrict p2,
                 float ***restrict v0, float ***restrict v1,
                 float ***restrict v2, float **restrict ep,
                 float **restrict epp, float *restrict sdiv, int *gsc, int *gec,
                 int *lbc, int *rbc, int maxoff, float **restrict c) {
  int i0, i1, i2;
  int ioff;
  for (i2 = gsc[2]; i2 <= gec[2]; i2++) {
    for (i1 = gsc[1]; i1 <= gec[1]; i1++) {
      for (i0 = gsc[0]; i0 <= gec[0]; i0++)
        sdiv[i0] = 0.0f;
      for (ioff = 0; ioff < maxoff; ioff++) {
        for (i0 = gsc[0]; i0 <= gec[0]; i0++) {
          sdiv[i0] += (c[0][ioff] *
                           (v0[i2][i1][i0 + ioff] - v0[i2][i1][i0 - ioff - 1]) +
                       c[1][ioff] *
                           (v1[i2][i1 + ioff][i0] - v1[i2][i1 - ioff - 1][i0]) +
                       c[2][ioff] *
                           (v2[i2 + ioff][i1][i0] - v2[i2 - ioff - 1][i1][i0]));
        }
      }
      for (i0 = gsc[0]; i0 <= gec[0]; i0++) {
        p0[i2][i1][i0] =
            (p0[i2][i1][i0] * ep[0][i0] - bulk[i2][i1][i0] * sdiv[i0]) *
            epp[0][i0];
        p1[i2][i1][i0] =
            (p1[i2][i1][i0] * ep[1][i1] - bulk[i2][i1][i0] * sdiv[i0]) *
            epp[1][i1];
        p2[i2][i1][i0] =
            (p2[i2][i1][i0] * ep[2][i2] - bulk[i2][i1][i0] * sdiv[i0]) *
            epp[2][i2];
      }
    }
  }
  if (lbc[0]) {
    for (i2 = gsc[2]; i2 <= gec[2]; i2++) {
      for (i1 = gsc[1]; i1 <= gec[1]; i1++) {
        p0[i2][i1][gsc[0] - 1] = 0.0f;
        for (ioff = 1; ioff < maxoff; ioff++) {
          p0[i2][i1][gsc[0] - ioff - 1] = -p0[i2][i1][gsc[0] + ioff - 1];
        }
      }
    }
  }
  if (rbc[0]) {
    for (i2 = gsc[2]; i2 <= gec[2]; i2++) {
      for (i1 = gsc[1]; i1 <= gec[1]; i1++) {
        p0[i2][i1][gec[0] + 1] = 0.0f;
        for (ioff = 1; ioff < maxoff; ioff++) {
          p0[i2][i1][gec[0] + ioff + 1] = -p0[i2][i1][gec[0] - ioff + 1];
        }
      }
    }
  }
  if (lbc[1]) {
    for (i2 = gsc[2]; i2 <= gec[2]; i2++) {
      for (i0 = gsc[0]; i0 <= gsc[0]; i0++) {
        p1[i2][gsc[1] - 1][i0] = 0.0f;
        for (ioff = 1; ioff < maxoff; ioff++) {
          p1[i2][gsc[1] - ioff - 1][i0] = -p1[i2][gsc[1] + ioff - 1][i0];
        }
      }
    }
  }
  if (rbc[1]) {
    for (i2 = gsc[2]; i2 <= gec[2]; i2++) {
      for (i0 = gsc[0]; i0 <= gsc[0]; i0++) {
        p1[i2][gec[1] + 1][i0] = 0.0f;
        for (ioff = 1; ioff < maxoff; ioff++) {
          p1[i2][gec[1] + ioff + 1][i0] = -p1[i2][gec[1] - ioff + 1][i0];
        }
      }
    }
  }
  if (lbc[2]) {
    for (i1 = gsc[1]; i1 <= gec[1]; i1++) {
      for (i0 = gsc[0]; i0 <= gsc[0]; i0++) {
        p2[gsc[2] - 1][i1][i0] = 0.0f;
        for (ioff = 1; ioff < maxoff; ioff++) {
          p2[gsc[2] - ioff - 1][i1][i0] = -p2[gsc[2] + ioff - 1][i1][i0];
        }
      }
    }
  }
  if (rbc[2]) {
    for (i1 = gsc[1]; i1 <= gec[1]; i1++) {
      for (i0 = gsc[0]; i0 <= gsc[0]; i0++) {
        p2[gec[2] + 1][i1][i0] = 0.0f;
        for (ioff = 1; ioff < maxoff; ioff++) {
          p2[gec[2] + ioff + 1][i1][i0] = -p2[gec[2] - ioff + 1][i1][i0];
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<asg_pstep3d>:
push   %rbp
mov    %rsp,%rbp
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%eax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    0x30(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x38(%rbp),%rcx
cmp    0x8(%rcx),%eax
jg     1541 <asg_pstep3d+0x441>
mov    0x30(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x38(%rbp),%rcx
cmp    0x4(%rcx),%eax
jg     152e <asg_pstep3d+0x42e>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x38(%rbp),%rcx
cmp    (%rcx),%eax
jg     11ad <asg_pstep3d+0xad>
mov    0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1180 <asg_pstep3d+0x80>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x50(%rbp),%eax
jge    1326 <asg_pstep3d+0x226>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x38(%rbp),%rcx
cmp    (%rcx),%eax
jg     1313 <asg_pstep3d+0x213>
mov    0x58(%rbp),%rax
mov    (%rax),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
sub    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
mov    0x58(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x58(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11c9 <asg_pstep3d+0xc9>
jmp    1318 <asg_pstep3d+0x218>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11b4 <asg_pstep3d+0xb4>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x38(%rbp),%rcx
cmp    (%rcx),%eax
jg     151b <asg_pstep3d+0x41b>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x3c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    132f <asg_pstep3d+0x22f>
jmp    1520 <asg_pstep3d+0x420>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1167 <asg_pstep3d+0x67>
jmp    1533 <asg_pstep3d+0x433>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    114d <asg_pstep3d+0x4d>
mov    0x40(%rbp),%rax
cmpl   $0x0,(%rax)
je     1653 <asg_pstep3d+0x553>
mov    0x30(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x38(%rbp),%rcx
cmp    0x8(%rcx),%eax
jg     164e <asg_pstep3d+0x54e>
mov    0x30(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x38(%rbp),%rcx
cmp    0x4(%rcx),%eax
jg     163b <asg_pstep3d+0x53b>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x30(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x50(%rbp),%eax
jge    1628 <asg_pstep3d+0x528>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x30(%rbp),%rcx
mov    (%rcx),%ecx
add    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x30(%rbp),%rcx
mov    (%rcx),%ecx
sub    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    15b1 <asg_pstep3d+0x4b1>
jmp    162d <asg_pstep3d+0x52d>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1572 <asg_pstep3d+0x472>
jmp    1640 <asg_pstep3d+0x540>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1558 <asg_pstep3d+0x458>
jmp    1653 <asg_pstep3d+0x553>
mov    0x48(%rbp),%rax
cmpl   $0x0,(%rax)
je     1765 <asg_pstep3d+0x665>
mov    0x30(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x38(%rbp),%rcx
cmp    0x8(%rcx),%eax
jg     1760 <asg_pstep3d+0x660>
mov    0x30(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x38(%rbp),%rcx
cmp    0x4(%rcx),%eax
jg     174d <asg_pstep3d+0x64d>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x50(%rbp),%eax
jge    173a <asg_pstep3d+0x63a>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
sub    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
add    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    16c3 <asg_pstep3d+0x5c3>
jmp    173f <asg_pstep3d+0x63f>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1684 <asg_pstep3d+0x584>
jmp    1752 <asg_pstep3d+0x652>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    166a <asg_pstep3d+0x56a>
jmp    1765 <asg_pstep3d+0x665>
mov    0x40(%rbp),%rax
cmpl   $0x0,0x4(%rax)
je     1879 <asg_pstep3d+0x779>
mov    0x30(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x38(%rbp),%rcx
cmp    0x8(%rcx),%eax
jg     1874 <asg_pstep3d+0x774>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x30(%rbp),%rcx
cmp    (%rcx),%eax
jg     1861 <asg_pstep3d+0x761>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x30(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x50(%rbp),%eax
jge    184e <asg_pstep3d+0x74e>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x30(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x30(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    17d5 <asg_pstep3d+0x6d5>
jmp    1853 <asg_pstep3d+0x753>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1796 <asg_pstep3d+0x696>
jmp    1866 <asg_pstep3d+0x766>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    177d <asg_pstep3d+0x67d>
jmp    1879 <asg_pstep3d+0x779>
mov    0x48(%rbp),%rax
cmpl   $0x0,0x4(%rax)
je     198d <asg_pstep3d+0x88d>
mov    0x30(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x38(%rbp),%rcx
cmp    0x8(%rcx),%eax
jg     1988 <asg_pstep3d+0x888>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x30(%rbp),%rcx
cmp    (%rcx),%eax
jg     1975 <asg_pstep3d+0x875>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x50(%rbp),%eax
jge    1962 <asg_pstep3d+0x862>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    18e9 <asg_pstep3d+0x7e9>
jmp    1967 <asg_pstep3d+0x867>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    18aa <asg_pstep3d+0x7aa>
jmp    197a <asg_pstep3d+0x87a>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1891 <asg_pstep3d+0x791>
jmp    198d <asg_pstep3d+0x88d>
mov    0x40(%rbp),%rax
cmpl   $0x0,0x8(%rax)
je     1aa1 <asg_pstep3d+0x9a1>
mov    0x30(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x38(%rbp),%rcx
cmp    0x4(%rcx),%eax
jg     1a9c <asg_pstep3d+0x99c>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x30(%rbp),%rcx
cmp    (%rcx),%eax
jg     1a89 <asg_pstep3d+0x989>
mov    -0x20(%rbp),%rax
mov    0x30(%rbp),%rcx
mov    0x8(%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x50(%rbp),%eax
jge    1a76 <asg_pstep3d+0x976>
mov    -0x20(%rbp),%rax
mov    0x30(%rbp),%rcx
mov    0x8(%rcx),%ecx
add    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x20(%rbp),%rax
mov    0x30(%rbp),%rcx
mov    0x8(%rcx),%ecx
sub    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    19fd <asg_pstep3d+0x8fd>
jmp    1a7b <asg_pstep3d+0x97b>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    19be <asg_pstep3d+0x8be>
jmp    1a8e <asg_pstep3d+0x98e>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    19a5 <asg_pstep3d+0x8a5>
jmp    1aa1 <asg_pstep3d+0x9a1>
mov    0x48(%rbp),%rax
cmpl   $0x0,0x8(%rax)
je     1bb5 <asg_pstep3d+0xab5>
mov    0x30(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x38(%rbp),%rcx
cmp    0x4(%rcx),%eax
jg     1bb0 <asg_pstep3d+0xab0>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x30(%rbp),%rcx
cmp    (%rcx),%eax
jg     1b9d <asg_pstep3d+0xa9d>
mov    -0x20(%rbp),%rax
mov    0x38(%rbp),%rcx
mov    0x8(%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x50(%rbp),%eax
jge    1b8a <asg_pstep3d+0xa8a>
mov    -0x20(%rbp),%rax
mov    0x38(%rbp),%rcx
mov    0x8(%rcx),%ecx
sub    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x20(%rbp),%rax
mov    0x38(%rbp),%rcx
mov    0x8(%rcx),%ecx
add    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1b11 <asg_pstep3d+0xa11>
jmp    1b8f <asg_pstep3d+0xa8f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1ad2 <asg_pstep3d+0x9d2>
jmp    1ba2 <asg_pstep3d+0xaa2>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1ab9 <asg_pstep3d+0x9b9>
jmp    1bb5 <asg_pstep3d+0xab5>
pop    %rbp
ret

x86 assembly (clang, -O2):
<asg_pstep3d>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %r9,0xd8(%rsp)
mov    %r8,0xd0(%rsp)
mov    %rdx,0x58(%rsp)
mov    %rsi,0x50(%rsp)
mov    %rdi,0x88(%rsp)
mov    0x158(%rsp),%r15
mov    0x148(%rsp),%rdx
mov    0x140(%rsp),%rax
mov    0x8(%rax),%esi
mov    0x8(%rdx),%eax
mov    %rax,0x20(%rsp)
mov    %rsi,0x30(%rsp)
cmp    %eax,%esi
mov    %rcx,0x38(%rsp)
jg     1bb9 <asg_pstep3d+0xaa9>
movslq 0x30(%rsp),%rcx
mov    0x140(%rsp),%rax
movslq 0x4(%rax),%rax
mov    %rax,0x68(%rsp)
mov    0x148(%rsp),%rax
mov    0x4(%rax),%eax
mov    %rax,0x80(%rsp)
add    $0x1,%eax
mov    %eax,0x60(%rsp)
mov    0x20(%rsp),%rax
add    $0x1,%eax
mov    %eax,0x14(%rsp)
mov    %rcx,0x48(%rsp)
mov    %rcx,%rbp
jmp    11ce <asg_pstep3d+0xbe>
xchg   %ax,%ax
add    $0x1,%rbp
cmp    %ebp,0x14(%rsp)
je     166a <asg_pstep3d+0x55a>
mov    0x80(%rsp),%rax
cmp    %eax,0x68(%rsp)
jg     11c0 <asg_pstep3d+0xb0>
mov    0x140(%rsp),%rax
movslq (%rax),%rcx
mov    0x148(%rsp),%rax
mov    (%rax),%edx
mov    0x138(%rsp),%rax
lea    (%rax,%rcx,4),%r14
mov    %edx,%eax
sub    %ecx,%eax
lea    0x4(,%rax,4),%rsi
mov    %rsi,0x98(%rsp)
mov    %rax,0xe0(%rsp)
add    $0x1,%rax
mov    %rax,0xb8(%rsp)
and    $0xfffffffffffffffc,%rax
mov    %rax,0xb0(%rsp)
add    %rcx,%rax
mov    %rax,0xa8(%rsp)
lea    -0x1(%rcx),%eax
mov    %rax,0xa0(%rsp)
mov    %rdx,0x18(%rsp)
lea    0x1(%rdx),%eax
mov    %eax,0x64(%rsp)
mov    %eax,%r15d
mov    %rcx,0x8(%rsp)
sub    %ecx,%r15d
mov    0x68(%rsp),%rax
mov    %rbp,0x70(%rsp)
mov    %r15,0x90(%rsp)
jmp    128e <asg_pstep3d+0x17e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rax
cmp    %eax,0x60(%rsp)
je     11c0 <asg_pstep3d+0xb0>
mov    %rax,0x40(%rsp)
mov    0x18(%rsp),%rax
cmp    0x8(%rsp),%eax
jl     12b0 <asg_pstep3d+0x1a0>
mov    %r14,%rdi
xor    %esi,%esi
mov    0x98(%rsp),%rdx
call   1030 <memset@plt>
cmpl   $0x0,0x160(%rsp)
jle    1540 <asg_pstep3d+0x430>
mov    $0xffffffff,%eax
mov    %rax,0x28(%rsp)
mov    0x8(%rsp),%rax
mov    %rax,0x78(%rsp)
mov    0xa0(%rsp),%r13
xor    %r10d,%r10d
jmp    130b <asg_pstep3d+0x1fb>
nop
add    $0x1,%r10
add    $0xffffffffffffffff,%r13
addq   $0x1,0x78(%rsp)
mov    0x28(%rsp),%rax
add    $0xffffffff,%eax
mov    %rax,0x28(%rsp)
mov    0x160(%rsp),%eax
cmp    %rax,%r10
je     1540 <asg_pstep3d+0x430>
mov    0x18(%rsp),%rax
cmp    0x8(%rsp),%eax
jl     12e0 <asg_pstep3d+0x1d0>
mov    0x40(%rsp),%rsi
lea    (%r10,%rsi,1),%r8
mov    %r10d,%ecx
not    %ecx
lea    (%rsi,%rcx,1),%edx
mov    0x70(%rsp),%rax
lea    (%r10,%rax,1),%r9
add    %eax,%ecx
mov    0x168(%rsp),%rbp
mov    0x0(%rbp),%rdi
mov    0x8(%rbp),%rbx
movss  (%rdi,%r10,4),%xmm8
mov    0xd0(%rsp),%rdi
mov    (%rdi,%rax,8),%rdi
mov    (%rdi,%rsi,8),%r11
movss  (%rbx,%r10,4),%xmm1
mov    0xd8(%rsp),%rdi
mov    (%rdi,%rax,8),%rdi
mov    (%rdi,%r8,8),%rbx
movslq %edx,%rax
mov    (%rdi,%rax,8),%rdi
mov    0x10(%rbp),%rax
movss  (%rax,%r10,4),%xmm2
mov    0x120(%rsp),%rdx
mov    (%rdx,%r9,8),%rax
mov    (%rax,%rsi,8),%rbp
movslq %ecx,%rax
mov    (%rdx,%rax,8),%rax
mov    (%rax,%rsi,8),%r15
mov    0x8(%rsp),%r12
cmpl   $0x3,0xe0(%rsp)
03
jb     1499 <asg_pstep3d+0x389>
mov    %r10d,%eax
not    %eax
mov    0x8(%rsp),%r12
lea    (%r12,%rax,1),%ecx
add    0x18(%rsp),%eax
cmp    %ecx,%eax
jl     1499 <asg_pstep3d+0x389>
movaps %xmm1,%xmm3
shufps $0x0,%xmm1,%xmm3
movaps %xmm8,%xmm4
shufps $0x0,%xmm8,%xmm4
movaps %xmm2,%xmm5
shufps $0x0,%xmm2,%xmm5
mov    0x78(%rsp),%rax
mov    %rbp,%rdx
lea    (%r11,%rax,4),%r8
mov    0x8(%rsp),%rcx
mov    %rbx,0xc8(%rsp)
lea    (%rbx,%rcx,4),%rbx
mov    %rdi,0xc0(%rsp)
lea    (%rdi,%rcx,4),%rbp
mov    %rdx,%r9
lea    (%rdx,%rcx,4),%rax
lea    (%r15,%rcx,4),%rcx
xor    %esi,%esi
mov    0xb0(%rsp),%rdx
nopl   0x0(%rax)
movups (%r8,%rsi,4),%xmm6
lea    (%rsi,%r13,1),%edi
movslq %edi,%rdi
movups (%r11,%rdi,4),%xmm7
subps  %xmm7,%xmm6
mulps  %xmm4,%xmm6
movups (%rbx,%rsi,4),%xmm7
movups 0x0(%rbp,%rsi,4),%xmm0
subps  %xmm0,%xmm7
mulps  %xmm3,%xmm7
addps  %xmm6,%xmm7
movups (%rax,%rsi,4),%xmm0
movups (%rcx,%rsi,4),%xmm6
subps  %xmm6,%xmm0
mulps  %xmm5,%xmm0
addps  %xmm7,%xmm0
movups (%r14,%rsi,4),%xmm6
addps  %xmm0,%xmm6
movups %xmm6,(%r14,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    1420 <asg_pstep3d+0x310>
mov    0xa8(%rsp),%r12
cmp    %rdx,0xb8(%rsp)
mov    0xc8(%rsp),%rbx
mov    0xc0(%rsp),%rdi
mov    %r9,%rbp
je     12e0 <asg_pstep3d+0x1d0>
lea    (%rbx,%r12,4),%r9
lea    (%rdi,%r12,4),%rbx
lea    0x0(,%r12,4),%rax
add    %rbp,%rax
lea    (%r15,%r12,4),%rcx
mov    0x138(%rsp),%rdx
lea    (%rdx,%r12,4),%rsi
lea    (%r12,%r10,1),%rdx
lea    (%r11,%rdx,4),%rdx
mov    0x28(%rsp),%rdi
add    %r12d,%edi
mov    0x64(%rsp),%ebp
mov    %ebp,%r15d
sub    %r12d,%r15d
xor    %r12d,%r12d
nopl   0x0(%rax)
movss  (%rdx,%r12,4),%xmm0
lea    (%rdi,%r12,1),%r8d
movslq %r8d,%rbp
subss  (%r11,%rbp,4),%xmm0
movss  (%r9,%r12,4),%xmm3
subss  (%rbx,%r12,4),%xmm3
mulss  %xmm1,%xmm3
mulss  %xmm8,%xmm0
addss  %xmm3,%xmm0
movss  (%rax,%r12,4),%xmm3
subss  (%rcx,%r12,4),%xmm3
mulss  %xmm2,%xmm3
addss  %xmm0,%xmm3
addss  (%rsi,%r12,4),%xmm3
movss  %xmm3,(%rsi,%r12,4)
add    $0x1,%r12
cmp    %r12d,%r15d
jne    14e0 <asg_pstep3d+0x3d0>
jmp    12e0 <asg_pstep3d+0x1d0>
nopw   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rax
cmp    0x8(%rsp),%eax
mov    0x70(%rsp),%rbp
mov    0x40(%rsp),%rax
jl     1280 <asg_pstep3d+0x170>
mov    0x50(%rsp),%rax
mov    (%rax,%rbp,8),%rax
mov    0x88(%rsp),%rcx
mov    (%rcx,%rbp,8),%rcx
mov    0x58(%rsp),%rdx
mov    (%rdx,%rbp,8),%r15
mov    0x128(%rsp),%rdx
mov    0x8(%rdx),%r8
mov    0x10(%rdx),%r9
mov    0x130(%rsp),%r13
mov    0x8(%r13),%r10
mov    0x10(%r13),%r11
mov    0x38(%rsp),%rsi
mov    (%rsi,%rbp,8),%rsi
mov    0x8(%rsp),%rdi
lea    0x0(,%rdi,4),%rdi
mov    0x40(%rsp),%rbx
mov    (%rax,%rbx,8),%rbx
add    %rdi,%rbx
mov    (%rdx),%r12
add    %rdi,%r12
mov    0x40(%rsp),%rax
mov    (%rcx,%rax,8),%rcx
add    %rdi,%rcx
mov    0x0(%r13),%r13
mov    0x40(%rsp),%rax
add    %rdi,%r13
mov    (%r15,%rax,8),%rdx
mov    0x90(%rsp),%r15
add    %rdi,%rdx
add    (%rsi,%rax,8),%rdi
xor    %esi,%esi
nopl   0x0(%rax)
movss  (%rbx,%rsi,4),%xmm0
movss  (%r14,%rsi,4),%xmm1
movss  (%rcx,%rsi,4),%xmm2
mulss  (%r12,%rsi,4),%xmm0
mulss  %xmm1,%xmm2
subss  %xmm2,%xmm0
mulss  0x0(%r13,%rsi,4),%xmm0
movss  %xmm0,(%rbx,%rsi,4)
movss  (%rdx,%rsi,4),%xmm0
movss  (%rcx,%rsi,4),%xmm2
mulss  %xmm1,%xmm2
mulss  (%r8,%rax,4),%xmm0
subss  %xmm2,%xmm0
mulss  (%r10,%rax,4),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
movss  (%rdi,%rsi,4),%xmm0
mulss  (%rcx,%rsi,4),%xmm1
mulss  (%r9,%rbp,4),%xmm0
subss  %xmm1,%xmm0
mulss  (%r11,%rbp,4),%xmm0
movss  %xmm0,(%rdi,%rsi,4)
add    $0x1,%rsi
cmp    %esi,%r15d
jne    15f0 <asg_pstep3d+0x4e0>
jmp    1280 <asg_pstep3d+0x170>
mov    0x150(%rsp),%rax
cmpl   $0x0,(%rax)
je     17d5 <asg_pstep3d+0x6c5>
mov    0x30(%rsp),%rax
cmp    0x20(%rsp),%eax
jg     17d5 <asg_pstep3d+0x6c5>
mov    0x140(%rsp),%rax
movslq 0x4(%rax),%rax
mov    %rax,0x8(%rsp)
mov    0x148(%rsp),%rax
mov    0x4(%rax),%eax
mov    %rax,0x18(%rsp)
lea    0x1(%rax),%r13d
mov    0x160(%rsp),%eax
lea    -0x1(%rax),%r15
mov    %r15,%rdi
and    $0xfffffffffffffffe,%rdi
movaps 0x938(%rip),%xmm0
mov    0x48(%rsp),%r14
jmp    16df <asg_pstep3d+0x5cf>
nop
add    $0x1,%r14
cmp    %r14d,0x14(%rsp)
je     17d5 <asg_pstep3d+0x6c5>
mov    0x18(%rsp),%rax
cmp    %eax,0x8(%rsp)
jg     16d0 <asg_pstep3d+0x5c0>
mov    0x50(%rsp),%rax
mov    (%rax,%r14,8),%r11
mov    0x140(%rsp),%rax
mov    (%rax),%r12d
lea    -0x1(%r12),%r10d
movslq %r10d,%rax
lea    -0x3(%r12),%ecx
mov    %ecx,0x28(%rsp)
mov    0x8(%rsp),%rbp
jmp    1729 <asg_pstep3d+0x619>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    %ebp,%r13d
je     16d0 <asg_pstep3d+0x5c0>
mov    (%r11,%rbp,8),%rsi
movl   $0x0,(%rsi,%rax,4)
cmpl   $0x2,0x160(%rsp)
02
jl     1720 <asg_pstep3d+0x610>
mov    $0x1,%ecx
je     17aa <asg_pstep3d+0x69a>
mov    $0xffffffffffffffff,%rcx
mov    %r12d,%edx
mov    0x28(%rsp),%ebx
mov    %ebx,%r8d
cs nopw 0x0(%rax,%rax,1)
movslq %edx,%rdx
movss  (%rsi,%rdx,4),%xmm1
xorps  %xmm0,%xmm1
lea    0x1(%r8),%r9d
movslq %r9d,%rbx
movss  %xmm1,(%rsi,%rbx,4)
lea    0x1(%rdx),%ebx
movslq %ebx,%rbx
movss  (%rsi,%rbx,4),%xmm1
xorps  %xmm0,%xmm1
movslq %r8d,%r8
movss  %xmm1,(%rsi,%r8,4)
add    $0xfffffffe,%r8d
add    $0x2,%edx
lea    (%rdi,%rcx,1),%rbx
add    $0xfffffffffffffffe,%rbx
add    $0xfffffffffffffffe,%rcx
cmp    $0xffffffffffffffff,%rbx
jne    1760 <asg_pstep3d+0x650>
neg    %rcx
test   $0x1,%r15b
je     1720 <asg_pstep3d+0x610>
lea    (%r10,%rcx,1),%edx
movslq %edx,%rdx
movss  (%rsi,%rdx,4),%xmm1
xorps  %xmm0,%xmm1
not    %ecx
add    %r12d,%ecx
movslq %ecx,%rcx
movss  %xmm1,(%rsi,%rcx,4)
jmp    1720 <asg_pstep3d+0x610>
mov    0x158(%rsp),%rax
cmpl   $0x0,(%rax)
je     1941 <asg_pstep3d+0x831>
mov    0x30(%rsp),%rax
cmp    0x20(%rsp),%eax
jg     1941 <asg_pstep3d+0x831>
mov    0x140(%rsp),%rax
movslq 0x4(%rax),%rax
mov    %rax,0x8(%rsp)
mov    0x148(%rsp),%rax
mov    0x4(%rax),%eax
mov    %rax,0x18(%rsp)
lea    0x1(%rax),%r13d
mov    0x160(%rsp),%eax
lea    -0x1(%rax),%r15
mov    %r15,%rdi
and    $0xfffffffffffffffe,%rdi
neg    %rdi
movaps 0x7ca(%rip),%xmm0
mov    0x48(%rsp),%r14
jmp    184f <asg_pstep3d+0x73f>
nopl   (%rax)
add    $0x1,%r14
cmp    %r14d,0x14(%rsp)
je     1941 <asg_pstep3d+0x831>
mov    0x18(%rsp),%rax
cmp    %eax,0x8(%rsp)
jg     1840 <asg_pstep3d+0x730>
mov    0x50(%rsp),%rax
mov    (%rax,%r14,8),%r11
mov    0x148(%rsp),%rax
mov    (%rax),%r8d
lea    0x1(%r8),%r12d
movslq %r12d,%rcx
lea    0x3(%r8),%eax
mov    %eax,0x28(%rsp)
mov    0x8(%rsp),%rbp
jmp    1899 <asg_pstep3d+0x789>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbp
cmp    %ebp,%r13d
je     1840 <asg_pstep3d+0x730>
mov    (%r11,%rbp,8),%rsi
movl   $0x0,(%rsi,%rcx,4)
cmpl   $0x2,0x160(%rsp)
02
jl     1890 <asg_pstep3d+0x780>
mov    $0x1,%eax
je     1918 <asg_pstep3d+0x808>
mov    $0x1,%eax
mov    0x28(%rsp),%edx
mov    %r8d,%r10d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %r10d,%r10
movss  (%rsi,%r10,4),%xmm1
xorps  %xmm0,%xmm1
lea    -0x1(%rdx),%r9d
movslq %r9d,%rbx
movss  %xmm1,(%rsi,%rbx,4)
lea    -0x1(%r10),%ebx
movslq %ebx,%rbx
movss  (%rsi,%rbx,4),%xmm1
xorps  %xmm0,%xmm1
movslq %edx,%rdx
movss  %xmm1,(%rsi,%rdx,4)
add    $0xfffffffe,%r10d
add    $0x2,%edx
lea    (%rdi,%rax,1),%rbx
add    $0x2,%rbx
add    $0x2,%rax
cmp    $0x1,%rbx
jne    18d0 <asg_pstep3d+0x7c0>
test   $0x1,%r15b
je     1890 <asg_pstep3d+0x780>
mov    %r12d,%edx
sub    %eax,%edx
movslq %edx,%rdx
movss  (%rsi,%rdx,4),%xmm1
xorps  %xmm0,%xmm1
add    %r12d,%eax
cltq
movss  %xmm1,(%rsi,%rax,4)
jmp    1890 <asg_pstep3d+0x780>
mov    0x150(%rsp),%rax
cmpl   $0x0,0x4(%rax)
mov    0x48(%rsp),%rsi
je     1a6f <asg_pstep3d+0x95f>
mov    0x30(%rsp),%rax
cmp    0x20(%rsp),%eax
jg     1a6f <asg_pstep3d+0x95f>
mov    0x140(%rsp),%rcx
movslq (%rcx),%rax
mov    0x4(%rcx),%r11d
lea    -0x1(%r11),%r9d
movslq %r9d,%r14
mov    0x160(%rsp),%ecx
lea    -0x1(%rcx),%r10
mov    %r10,%r15
and    $0xfffffffffffffffe,%r15
lea    -0x3(%r11),%r8d
movaps 0x666(%rip),%xmm0
mov    %rsi,%rbx
jmp    19ae <asg_pstep3d+0x89e>
nop
add    $0x1,%rbx
cmp    %ebx,0x14(%rsp)
je     1a6f <asg_pstep3d+0x95f>
mov    0x58(%rsp),%rcx
mov    (%rcx,%rbx,8),%rdx
mov    (%rdx,%r14,8),%rcx
movl   $0x0,(%rcx,%rax,4)
cmpl   $0x2,0x160(%rsp)
02
jl     19a0 <asg_pstep3d+0x890>
mov    $0x1,%ebp
je     1a3c <asg_pstep3d+0x92c>
mov    $0xffffffffffffffff,%rbp
mov    %r11d,%ecx
mov    %r8d,%esi
movslq %ecx,%rcx
mov    (%rdx,%rcx,8),%rdi
movss  (%rdi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
lea    0x1(%rsi),%edi
movslq %edi,%rdi
mov    (%rdx,%rdi,8),%rdi
movss  %xmm1,(%rdi,%rax,4)
lea    0x1(%rcx),%edi
movslq %edi,%rdi
mov    (%rdx,%rdi,8),%rdi
movss  (%rdi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movslq %esi,%rsi
mov    (%rdx,%rsi,8),%rdi
movss  %xmm1,(%rdi,%rax,4)
add    $0xfffffffe,%esi
add    $0x2,%ecx
lea    (%r15,%rbp,1),%rdi
add    $0xfffffffffffffffe,%rdi
add    $0xfffffffffffffffe,%rbp
cmp    $0xffffffffffffffff,%rdi
jne    19e0 <asg_pstep3d+0x8d0>
neg    %rbp
mov    0x48(%rsp),%rsi
test   $0x1,%r10b
je     19a0 <asg_pstep3d+0x890>
lea    (%r9,%rbp,1),%ecx
movslq %ecx,%rcx
mov    (%rdx,%rcx,8),%rcx
movss  (%rcx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
not    %ebp
add    %r11d,%ebp
movslq %ebp,%rcx
mov    (%rdx,%rcx,8),%rcx
movss  %xmm1,(%rcx,%rax,4)
jmp    19a0 <asg_pstep3d+0x890>
mov    0x158(%rsp),%r15
cmpl   $0x0,0x4(%r15)
mov    0x38(%rsp),%rcx
je     1bb9 <asg_pstep3d+0xaa9>
mov    0x30(%rsp),%rax
cmp    0x20(%rsp),%eax
jg     1bb9 <asg_pstep3d+0xaa9>
mov    0x140(%rsp),%rax
movslq (%rax),%rax
mov    0x148(%rsp),%rdx
mov    0x4(%rdx),%r9d
lea    0x1(%r9),%r10d
movslq %r10d,%r11
mov    0x160(%rsp),%r14d
add    $0xffffffffffffffff,%r14
lea    0x3(%r9),%r8d
mov    %r14,%r13
and    $0xfffffffffffffffe,%r14
neg    %r14
movaps 0x52b(%rip),%xmm0
jmp    1aee <asg_pstep3d+0x9de>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rsi
cmp    %esi,0x14(%rsp)
je     1bb9 <asg_pstep3d+0xaa9>
mov    0x58(%rsp),%rdx
mov    (%rdx,%rsi,8),%rbx
mov    (%rbx,%r11,8),%rdx
movl   $0x0,(%rdx,%rax,4)
cmpl   $0x2,0x160(%rsp)
02
jl     1ae0 <asg_pstep3d+0x9d0>
mov    %rsi,%r12
mov    $0x1,%edi
je     1b84 <asg_pstep3d+0xa74>
mov    $0x1,%edi
mov    %r8d,%ebp
mov    %r9d,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %edx,%rdx
mov    (%rbx,%rdx,8),%rsi
movss  (%rsi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
lea    -0x1(%rbp),%esi
movslq %esi,%rsi
mov    (%rbx,%rsi,8),%rsi
movss  %xmm1,(%rsi,%rax,4)
lea    -0x1(%rdx),%esi
movslq %esi,%rsi
mov    (%rbx,%rsi,8),%rsi
movss  (%rsi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movslq %ebp,%rbp
mov    (%rbx,%rbp,8),%rsi
movss  %xmm1,(%rsi,%rax,4)
add    $0xfffffffe,%edx
add    $0x2,%ebp
lea    (%r14,%rdi,1),%rsi
add    $0x2,%rsi
add    $0x2,%rdi
cmp    $0x1,%rsi
jne    1b30 <asg_pstep3d+0xa20>
test   $0x1,%r13b
mov    %r12,%rsi
je     1ae0 <asg_pstep3d+0x9d0>
mov    %r10d,%edx
sub    %edi,%edx
movslq %edx,%rdx
mov    (%rbx,%rdx,8),%rdx
movss  (%rdx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
add    %r10d,%edi
movslq %edi,%rdx
mov    (%rbx,%rdx,8),%rdx
movss  %xmm1,(%rdx,%rax,4)
jmp    1ae0 <asg_pstep3d+0x9d0>
mov    0x150(%rsp),%rax
cmpl   $0x0,0x8(%rax)
mov    0x30(%rsp),%r14
je     1be9 <asg_pstep3d+0xad9>
mov    0x140(%rsp),%rax
movslq 0x4(%rax),%rax
mov    0x148(%rsp),%rdx
mov    0x4(%rdx),%r11d
cmp    %r11d,%eax
jle    1c23 <asg_pstep3d+0xb13>
cmpl   $0x0,0x8(%r15)
je     1c11 <asg_pstep3d+0xb01>
mov    0x140(%rsp),%rax
movslq 0x4(%rax),%rax
mov    0x148(%rsp),%rcx
mov    0x4(%rcx),%r14d
cmp    %r14d,%eax
jle    1cc1 <asg_pstep3d+0xbb1>
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x140(%rsp),%rdx
movslq (%rdx),%rdx
lea    -0x1(%r14),%esi
movslq %esi,%rsi
mov    (%rcx,%rsi,8),%r10
add    $0x1,%r11d
mov    0x160(%rsp),%r9d
lea    -0x2(%r14),%r8d
add    $0xffffffffffffffff,%r9
movaps 0x3ac(%rip),%xmm0
jmp    1c69 <asg_pstep3d+0xb59>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %eax,%r11d
je     1be9 <asg_pstep3d+0xad9>
mov    (%r10,%rax,8),%rdi
movl   $0x0,(%rdi,%rdx,4)
cmpl   $0x2,0x160(%rsp)
02
jl     1c60 <asg_pstep3d+0xb50>
mov    %r9,%rdi
mov    %r14d,%ebp
mov    %r8d,%ebx
nopw   0x0(%rax,%rax,1)
movslq %ebp,%rbp
mov    (%rcx,%rbp,8),%rsi
mov    (%rsi,%rax,8),%rsi
movss  (%rsi,%rdx,4),%xmm1
xorps  %xmm0,%xmm1
movslq %ebx,%rbx
mov    (%rcx,%rbx,8),%rsi
mov    (%rsi,%rax,8),%rsi
movss  %xmm1,(%rsi,%rdx,4)
add    $0xffffffff,%ebx
add    $0x1,%ebp
add    $0xffffffffffffffff,%rdi
jne    1c90 <asg_pstep3d+0xb80>
jmp    1c60 <asg_pstep3d+0xb50>
mov    0x140(%rsp),%rcx
movslq (%rcx),%rdx
mov    0x20(%rsp),%rdi
lea    0x1(%rdi),%r9d
movslq %r9d,%rsi
mov    0x38(%rsp),%rcx
mov    (%rcx,%rsi,8),%r11
add    $0x1,%r14d
mov    0x160(%rsp),%r10d
add    $0xffffffffffffffff,%r10
lea    0x3(%rdi),%r8d
mov    %r10,%r15
and    $0xfffffffffffffffe,%r15
neg    %r15
movaps 0x2fa(%rip),%xmm0
mov    0x38(%rsp),%rbp
jmp    1d1d <asg_pstep3d+0xc0d>
nopl   (%rax)
add    $0x1,%rax
cmp    %eax,%r14d
je     1c11 <asg_pstep3d+0xb01>
mov    (%r11,%rax,8),%rsi
movl   $0x0,(%rsi,%rdx,4)
cmpl   $0x2,0x160(%rsp)
02
jl     1d10 <asg_pstep3d+0xc00>
mov    $0x1,%esi
je     1db8 <asg_pstep3d+0xca8>
mov    $0x1,%esi
mov    %r8d,%ebx
mov    0x20(%rsp),%rdi
nopw   0x0(%rax,%rax,1)
movslq %edi,%rdi
mov    0x0(%rbp,%rdi,8),%rcx
mov    (%rcx,%rax,8),%rcx
movss  (%rcx,%rdx,4),%xmm1
xorps  %xmm0,%xmm1
lea    -0x1(%rbx),%ecx
movslq %ecx,%rcx
mov    0x0(%rbp,%rcx,8),%rcx
mov    (%rcx,%rax,8),%rcx
movss  %xmm1,(%rcx,%rdx,4)
lea    -0x1(%rdi),%ecx
movslq %ecx,%rcx
mov    0x0(%rbp,%rcx,8),%rcx
mov    (%rcx,%rax,8),%rcx
movss  (%rcx,%rdx,4),%xmm1
xorps  %xmm0,%xmm1
movslq %ebx,%rbx
mov    0x0(%rbp,%rbx,8),%rcx
mov    (%rcx,%rax,8),%rcx
movss  %xmm1,(%rcx,%rdx,4)
add    $0xfffffffe,%edi
add    $0x2,%ebx
lea    (%r15,%rsi,1),%rcx
add    $0x2,%rcx
add    $0x2,%rsi
cmp    $0x1,%rcx
jne    1d50 <asg_pstep3d+0xc40>
test   $0x1,%r10b
je     1d10 <asg_pstep3d+0xc00>
mov    %r9d,%ecx
sub    %esi,%ecx
movslq %ecx,%rcx
mov    0x38(%rsp),%rdi
mov    (%rdi,%rcx,8),%rcx
mov    (%rcx,%rax,8),%rcx
movss  (%rcx,%rdx,4),%xmm1
xorps  %xmm0,%xmm1
add    %r9d,%esi
movslq %esi,%rcx
mov    (%rdi,%rcx,8),%rcx
mov    (%rcx,%rax,8),%rcx
movss  %xmm1,(%rcx,%rdx,4)
jmp    1d10 <asg_pstep3d+0xc00>

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

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