void asg_vstep3d(float ***restrict buoy, float ***restrict p0,
                 float ***restrict p1, float ***restrict p2,
                 float ***restrict v0, float ***restrict v1,
                 float ***restrict v2, float **restrict ev,
                 float **restrict evp, float **restrict gradp, int *gsc_v0,
                 int *gec_v0, int *gsc_v1, int *gec_v1, int *gsc_v2,
                 int *gec_v2, int *lbc, int *rbc, int maxoff,
                 float **restrict c) {
  int i0, i1, i2;
  int ioff;
  for (i2 = gsc_v0[2]; i2 <= gec_v0[2]; i2++) {
    for (i1 = gsc_v0[1]; i1 <= gec_v0[1]; i1++) {
      for (i0 = gsc_v0[0]; i0 <= gec_v0[0]; i0++)
        gradp[0][i0] = 0;
      for (ioff = 0; ioff < maxoff; ioff++) {
        for (i0 = gsc_v0[0]; i0 <= gec_v0[0]; i0++)
          gradp[0][i0] +=
              c[0][ioff] * (p0[i2][i1][i0 + ioff + 1] - p0[i2][i1][i0 - ioff]);
      }
      for (i0 = gsc_v0[0]; i0 <= gec_v0[0]; i0++)
        v0[i2][i1][i0] =
            evp[0][i0] *
            (v0[i2][i1][i0] * ev[0][i0] -
             0.5 * (buoy[i2][i1][i0] + buoy[i2][i1][i0 + 1]) * gradp[0][i0]);
    }
  }
  for (i2 = gsc_v1[2]; i2 <= gec_v1[2]; i2++) {
    for (i1 = gsc_v1[1]; i1 <= gec_v1[1]; i1++) {
      for (i0 = gsc_v1[0]; i0 <= gec_v1[0]; i0++)
        gradp[1][i0] = 0;
      for (ioff = 0; ioff < maxoff; ioff++) {
        for (i0 = gsc_v1[0]; i0 <= gec_v1[0]; i0++)
          gradp[1][i0] +=
              c[1][ioff] * (p1[i2][i1 + ioff + 1][i0] - p1[i2][i1 - ioff][i0]);
      }
      for (i0 = gsc_v1[0]; i0 <= gec_v1[0]; i0++)
        v1[i2][i1][i0] =
            evp[1][i1] *
            (v1[i2][i1][i0] * ev[1][i1] -
             0.5 * (buoy[i2][i1][i0] + buoy[i2][i1 + 1][i0]) * gradp[1][i0]);
    }
  }
  for (i2 = gsc_v2[2]; i2 <= gec_v2[2]; i2++) {
    for (i1 = gsc_v2[1]; i1 <= gec_v2[1]; i1++) {
      for (i0 = gsc_v2[0]; i0 <= gec_v2[0]; i0++)
        gradp[2][i0] = 0;
      for (ioff = 0; ioff < maxoff; ioff++) {
        for (i0 = gsc_v2[0]; i0 <= gec_v2[0]; i0++)
          gradp[2][i0] +=
              c[2][ioff] * (p2[i2 + ioff + 1][i1][i0] - p2[i2 - ioff][i1][i0]);
      }
      for (i0 = gsc_v2[0]; i0 <= gec_v2[0]; i0++)
        v2[i2][i1][i0] =
            evp[2][i2] *
            (v2[i2][i1][i0] * ev[2][i2] -
             0.5 * (buoy[i2][i1][i0] + buoy[i2 + 1][i1][i0]) * gradp[2][i0]);
    }
  }
  if (lbc[0]) {
    for (i2 = gsc_v0[2]; i2 <= gec_v0[2]; i2++) {
      for (i1 = gsc_v0[1]; i1 <= gec_v0[1]; i1++) {
        for (ioff = 1; ioff < maxoff; ioff++) {
          v0[i2][i1][gsc_v0[0] - ioff] = v0[i2][i1][gsc_v0[0] + ioff - 1];
        }
      }
    }
  }
  if (rbc[0]) {
    for (i2 = gsc_v0[2]; i2 <= gec_v0[2]; i2++) {
      for (i1 = gsc_v0[1]; i1 <= gec_v0[1]; i1++) {
        for (ioff = 1; ioff < maxoff; ioff++) {
          v0[i2][i1][gec_v0[0] + ioff] = v0[i2][i1][gec_v0[0] - ioff + 1];
        }
      }
    }
  }
  if (lbc[1]) {
    for (i2 = gsc_v1[2]; i2 <= gec_v1[2]; i2++) {
      for (i0 = gsc_v1[0]; i0 <= gec_v1[0]; i0++) {
        for (ioff = 1; ioff < maxoff; ioff++) {
          v1[i2][gsc_v1[1] - ioff][i0] = v1[i2][gsc_v1[1] + ioff - 1][i0];
        }
      }
    }
  }
  if (rbc[1]) {
    for (i2 = gsc_v1[2]; i2 <= gec_v1[2]; i2++) {
      for (i0 = gsc_v1[0]; i0 <= gec_v1[0]; i0++) {
        for (ioff = 1; ioff < maxoff; ioff++) {
          v1[i2][gec_v1[1] + ioff][i0] = v1[i2][gec_v1[1] - ioff + 1][i0];
        }
      }
    }
  }
  if (lbc[2]) {
    for (i1 = gsc_v2[1]; i1 <= gec_v2[1]; i1++) {
      for (i0 = gsc_v2[0]; i0 <= gec_v2[0]; i0++) {
        for (ioff = 1; ioff < maxoff; ioff++) {
          v2[gsc_v2[2] - ioff][i1][i0] = v2[gsc_v2[2] + ioff - 1][i1][i0];
        }
      }
    }
  }
  if (rbc[2]) {
    for (i1 = gsc_v2[1]; i1 <= gec_v2[1]; i1++) {
      for (i0 = gsc_v2[0]; i0 <= gec_v2[0]; i0++) {
        for (ioff = 1; ioff < maxoff; ioff++) {
          v2[gec_v2[2] + ioff][i1][i0] = v2[gec_v2[2] - ioff + 1][i1][i0];
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<asg_vstep3d>:
push   %rbp
mov    %rsp,%rbp
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%eax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
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     13b8 <asg_vstep3d+0x2b8>
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     13a5 <asg_vstep3d+0x2a5>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x38(%rbp),%rcx
cmp    (%rcx),%eax
jg     11c0 <asg_vstep3d+0xc0>
mov    0x28(%rbp),%rax
mov    (%rax),%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    1190 <asg_vstep3d+0x90>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x70(%rbp),%eax
jge    1280 <asg_vstep3d+0x180>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x38(%rbp),%rcx
cmp    (%rcx),%eax
jg     126d <asg_vstep3d+0x16d>
mov    0x78(%rbp),%rax
mov    (%rax),%rax
movslq -0x40(%rbp),%rcx
movss  (%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
mov    -0x34(%rbp),%ecx
add    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%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
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
mov    0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11dc <asg_vstep3d+0xdc>
jmp    1272 <asg_vstep3d+0x172>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11c7 <asg_vstep3d+0xc7>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x38(%rbp),%rcx
cmp    (%rcx),%eax
jg     1392 <asg_vstep3d+0x292>
mov    0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x28(%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    0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%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    -0x8(%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    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm3
movsd  0xcd8(%rip),%xmm1
mulsd  %xmm3,%xmm1
mov    0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
cvtss2sd %xmm3,%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%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    1289 <asg_vstep3d+0x189>
jmp    1397 <asg_vstep3d+0x297>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1177 <asg_vstep3d+0x77>
jmp    13aa <asg_vstep3d+0x2aa>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    115d <asg_vstep3d+0x5d>
mov    0x40(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x48(%rbp),%rcx
cmp    0x8(%rcx),%eax
jg     1623 <asg_vstep3d+0x523>
mov    0x40(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x48(%rbp),%rcx
cmp    0x4(%rcx),%eax
jg     1610 <asg_vstep3d+0x510>
mov    0x40(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x48(%rbp),%rcx
cmp    (%rcx),%eax
jg     1426 <asg_vstep3d+0x326>
mov    0x28(%rbp),%rax
mov    0x8(%rax),%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    13f5 <asg_vstep3d+0x2f5>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x70(%rbp),%eax
jge    14e8 <asg_vstep3d+0x3e8>
mov    0x40(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x48(%rbp),%rcx
cmp    (%rcx),%eax
jg     14d5 <asg_vstep3d+0x3d5>
mov    0x78(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    -0x40(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm2
mov    0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1442 <asg_vstep3d+0x342>
jmp    14da <asg_vstep3d+0x3da>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    142d <asg_vstep3d+0x32d>
mov    0x40(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x48(%rbp),%rcx
cmp    (%rcx),%eax
jg     15fd <asg_vstep3d+0x4fd>
mov    0x20(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x30(%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    0x18(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%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    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm3
movsd  0xa6e(%rip),%xmm1
mulsd  %xmm3,%xmm1
mov    0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
cvtss2sd %xmm3,%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x30(%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    14f1 <asg_vstep3d+0x3f1>
jmp    1602 <asg_vstep3d+0x502>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13dc <asg_vstep3d+0x2dc>
jmp    1615 <asg_vstep3d+0x515>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13c2 <asg_vstep3d+0x2c2>
mov    0x50(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x58(%rbp),%rcx
cmp    0x8(%rcx),%eax
jg     188e <asg_vstep3d+0x78e>
mov    0x50(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x58(%rbp),%rcx
cmp    0x4(%rcx),%eax
jg     187b <asg_vstep3d+0x77b>
mov    0x50(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x58(%rbp),%rcx
cmp    (%rcx),%eax
jg     1691 <asg_vstep3d+0x591>
mov    0x28(%rbp),%rax
mov    0x10(%rax),%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    1660 <asg_vstep3d+0x560>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x70(%rbp),%eax
jge    1753 <asg_vstep3d+0x653>
mov    0x50(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x58(%rbp),%rcx
cmp    (%rcx),%eax
jg     1740 <asg_vstep3d+0x640>
mov    0x78(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%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  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    -0x40(%rbp),%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
mov    0x28(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    16ad <asg_vstep3d+0x5ad>
jmp    1745 <asg_vstep3d+0x645>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1698 <asg_vstep3d+0x598>
mov    0x50(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x58(%rbp),%rcx
cmp    (%rcx),%eax
jg     1868 <asg_vstep3d+0x768>
mov    0x20(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%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  (%rax,%rcx,4),%xmm1
mov    0x18(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x3c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%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    -0x8(%rbp),%rax
mov    -0x3c(%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
addss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm3
movsd  0x803(%rip),%xmm1
mulsd  %xmm3,%xmm1
mov    0x28(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
cvtss2sd %xmm3,%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%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    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    175c <asg_vstep3d+0x65c>
jmp    186d <asg_vstep3d+0x76d>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1647 <asg_vstep3d+0x547>
jmp    1880 <asg_vstep3d+0x780>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    162d <asg_vstep3d+0x52d>
mov    0x60(%rbp),%rax
cmpl   $0x0,(%rax)
je     1968 <asg_vstep3d+0x868>
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     1963 <asg_vstep3d+0x863>
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     1950 <asg_vstep3d+0x850>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x70(%rbp),%eax
jge    193d <asg_vstep3d+0x83d>
mov    -0x28(%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
mov    -0x28(%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
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    18d6 <asg_vstep3d+0x7d6>
jmp    1942 <asg_vstep3d+0x842>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    18bf <asg_vstep3d+0x7bf>
jmp    1955 <asg_vstep3d+0x855>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    18a5 <asg_vstep3d+0x7a5>
jmp    1968 <asg_vstep3d+0x868>
mov    0x68(%rbp),%rax
cmpl   $0x0,(%rax)
je     1a42 <asg_vstep3d+0x942>
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     1a3d <asg_vstep3d+0x93d>
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     1a2a <asg_vstep3d+0x92a>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x70(%rbp),%eax
jge    1a17 <asg_vstep3d+0x917>
mov    -0x28(%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
mov    -0x28(%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
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    19b0 <asg_vstep3d+0x8b0>
jmp    1a1c <asg_vstep3d+0x91c>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1999 <asg_vstep3d+0x899>
jmp    1a2f <asg_vstep3d+0x92f>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    197f <asg_vstep3d+0x87f>
jmp    1a42 <asg_vstep3d+0x942>
mov    0x60(%rbp),%rax
cmpl   $0x0,0x4(%rax)
je     1b1d <asg_vstep3d+0xa1d>
mov    0x40(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x48(%rbp),%rcx
cmp    0x8(%rcx),%eax
jg     1b18 <asg_vstep3d+0xa18>
mov    0x40(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x48(%rbp),%rcx
cmp    (%rcx),%eax
jg     1b05 <asg_vstep3d+0xa05>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x70(%rbp),%eax
jge    1af2 <asg_vstep3d+0x9f2>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%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
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    -0x40(%rbp),%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    1a89 <asg_vstep3d+0x989>
jmp    1af7 <asg_vstep3d+0x9f7>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1a73 <asg_vstep3d+0x973>
jmp    1b0a <asg_vstep3d+0xa0a>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1a5a <asg_vstep3d+0x95a>
jmp    1b1d <asg_vstep3d+0xa1d>
mov    0x68(%rbp),%rax
cmpl   $0x0,0x4(%rax)
je     1bf8 <asg_vstep3d+0xaf8>
mov    0x40(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x48(%rbp),%rcx
cmp    0x8(%rcx),%eax
jg     1bf3 <asg_vstep3d+0xaf3>
mov    0x40(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x48(%rbp),%rcx
cmp    (%rcx),%eax
jg     1be0 <asg_vstep3d+0xae0>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x70(%rbp),%eax
jge    1bcd <asg_vstep3d+0xacd>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x48(%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
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x48(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    -0x40(%rbp),%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    1b64 <asg_vstep3d+0xa64>
jmp    1bd2 <asg_vstep3d+0xad2>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1b4e <asg_vstep3d+0xa4e>
jmp    1be5 <asg_vstep3d+0xae5>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1b35 <asg_vstep3d+0xa35>
jmp    1bf8 <asg_vstep3d+0xaf8>
mov    0x60(%rbp),%rax
cmpl   $0x0,0x8(%rax)
je     1cd3 <asg_vstep3d+0xbd3>
mov    0x50(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x58(%rbp),%rcx
cmp    0x4(%rcx),%eax
jg     1cce <asg_vstep3d+0xbce>
mov    0x50(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x58(%rbp),%rcx
cmp    (%rcx),%eax
jg     1cbb <asg_vstep3d+0xbbb>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x70(%rbp),%eax
jge    1ca8 <asg_vstep3d+0xba8>
mov    0x10(%rbp),%rax
mov    0x50(%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
mov    0x10(%rbp),%rax
mov    0x50(%rbp),%rcx
mov    0x8(%rcx),%ecx
sub    -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  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1c3f <asg_vstep3d+0xb3f>
jmp    1cad <asg_vstep3d+0xbad>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1c29 <asg_vstep3d+0xb29>
jmp    1cc0 <asg_vstep3d+0xbc0>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1c10 <asg_vstep3d+0xb10>
jmp    1cd3 <asg_vstep3d+0xbd3>
mov    0x68(%rbp),%rax
cmpl   $0x0,0x8(%rax)
je     1dae <asg_vstep3d+0xcae>
mov    0x50(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x58(%rbp),%rcx
cmp    0x4(%rcx),%eax
jg     1da9 <asg_vstep3d+0xca9>
mov    0x50(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x58(%rbp),%rcx
cmp    (%rcx),%eax
jg     1d96 <asg_vstep3d+0xc96>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x70(%rbp),%eax
jge    1d83 <asg_vstep3d+0xc83>
mov    0x10(%rbp),%rax
mov    0x58(%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
mov    0x10(%rbp),%rax
mov    0x58(%rbp),%rcx
mov    0x8(%rcx),%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  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1d1a <asg_vstep3d+0xc1a>
jmp    1d88 <asg_vstep3d+0xc88>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1d04 <asg_vstep3d+0xc04>
jmp    1d9b <asg_vstep3d+0xc9b>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1ceb <asg_vstep3d+0xbeb>
jmp    1dae <asg_vstep3d+0xcae>
pop    %rbp
ret

x86 assembly (clang, -O2):
<asg_vstep3d>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    %r9,0x110(%rsp)
mov    %r8,0x108(%rsp)
mov    %rcx,0x120(%rsp)
mov    %rdx,0xe8(%rsp)
mov    %rsi,0x48(%rsp)
mov    %rdi,0x100(%rsp)
mov    0x188(%rsp),%rax
mov    0x180(%rsp),%rcx
mov    0x178(%rsp),%r15
movslq 0x8(%rcx),%rcx
mov    0x8(%rax),%edx
mov    %rcx,%rax
mov    %rcx,0xb0(%rsp)
mov    %rdx,0x88(%rsp)
cmp    %edx,%ecx
jle    1e49 <asg_vstep3d+0xd39>
mov    0x190(%rsp),%rax
movslq 0x8(%rax),%rcx
mov    0x198(%rsp),%rax
mov    0x8(%rax),%edx
mov    %rcx,%rax
mov    %rcx,0x60(%rsp)
mov    %rdx,0x50(%rsp)
cmp    %edx,%ecx
jle    24e9 <asg_vstep3d+0x13d9>
mov    0x1a0(%rsp),%rax
mov    0x8(%rax),%eax
mov    %eax,0xd8(%rsp)
movslq %eax,%rcx
mov    0x1a8(%rsp),%rax
mov    0x8(%rax),%eax
mov    %rax,0x98(%rsp)
mov    %rcx,0x90(%rsp)
cmp    %eax,%ecx
jg     18c5 <asg_vstep3d+0x7b5>
mov    0x1a0(%rsp),%rax
movslq 0x4(%rax),%rcx
mov    0x1a8(%rsp),%rax
mov    0x4(%rax),%edx
lea    0x1(%rdx),%eax
mov    %eax,0x68(%rsp)
mov    0x98(%rsp),%rax
add    $0x1,%eax
mov    0x1c0(%rsp),%r13d
movsd  0x1dea(%rip),%xmm8
movapd 0x1dd1(%rip),%xmm9
mov    0x90(%rsp),%rsi
mov    %rsi,0x8(%rsp)
mov    %rcx,0xf8(%rsp)
mov    %rdx,0xf0(%rsp)
mov    %eax,0x11c(%rsp)
jmp    127a <asg_vstep3d+0x16a>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x8(%rsp),%rsi
add    $0x1,%rsi
mov    %rsi,0x8(%rsp)
mov    %rsi,%r11
cmp    %r11d,%eax
je     18c5 <asg_vstep3d+0x7b5>
cmp    %edx,%ecx
jg     1260 <asg_vstep3d+0x150>
mov    0x1a0(%rsp),%rax
movslq (%rax),%r14
mov    0x1a8(%rsp),%rax
mov    (%rax),%edx
mov    0x8(%rsp),%rax
lea    0x1(%rax),%r11
mov    %edx,%eax
sub    %r14d,%eax
lea    0x4(,%rax,4),%rsi
mov    %rsi,0xd0(%rsp)
lea    (%r14,%rax,1),%rsi
mov    %rsi,0x48(%rsp)
mov    %rax,0x78(%rsp)
lea    0x1(%rax),%rsi
mov    %rdx,0x10(%rsp)
lea    0x1(%rdx),%r12d
mov    %rsi,%rdx
movabs $0x1fffffff8,%rax
and    %rax,%rdx
mov    %rdx,0x20(%rsp)
add    %r14,%rdx
mov    %rdx,0x70(%rsp)
add    $0x4,%rax
mov    %rsi,0x40(%rsp)
and    %rsi,%rax
mov    %rax,0xc8(%rsp)
add    %r14,%rax
mov    %rax,0xc0(%rsp)
mov    %rcx,0x18(%rsp)
mov    %r11,0xe8(%rsp)
jmp    1348 <asg_vstep3d+0x238>
nopw   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rax
add    $0x1,%rax
mov    %rax,0x18(%rsp)
cmp    %eax,0x68(%rsp)
mov    0x1c0(%rsp),%r13d
mov    0xe8(%rsp),%r11
je     18a0 <asg_vstep3d+0x790>
cmp    %r14d,0x10(%rsp)
jl     1384 <asg_vstep3d+0x274>
lea    0x0(,%r14,4),%rdi
add    0x10(%r15),%rdi
xor    %esi,%esi
mov    0xd0(%rsp),%rdx
call   1030 <memset@plt>
mov    0xe8(%rsp),%r11
movapd 0x1c85(%rip),%xmm9
movsd  0x1c8c(%rip),%xmm8
cmpl   $0x0,0x1c0(%rsp)
jle    15d0 <asg_vstep3d+0x4c0>
xor    %r8d,%r8d
jmp    13a9 <asg_vstep3d+0x299>
nopw   0x0(%rax,%rax,1)
cmp    %r13,%r8
je     15d0 <asg_vstep3d+0x4c0>
mov    %r8,%rax
add    $0x1,%r8
cmp    %r14d,0x10(%rsp)
jl     13a0 <asg_vstep3d+0x290>
lea    (%r11,%rax,1),%edx
mov    0x8(%rsp),%rsi
sub    %rax,%rsi
mov    0x1c8(%rsp),%rcx
mov    0x10(%rcx),%rbx
lea    (%rbx,%rax,4),%r9
movslq %edx,%rax
mov    0x120(%rsp),%rdi
mov    (%rdi,%rax,8),%rax
mov    0x18(%rsp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    (%rdi,%rsi,8),%rax
mov    (%rax,%rcx,8),%rsi
mov    0x10(%r15),%rdi
mov    %r14,%rax
cmpl   $0x7,0x78(%rsp)
jb     1530 <asg_vstep3d+0x420>
lea    (%rdi,%r14,4),%rax
mov    0x48(%rsp),%rcx
lea    (%rdi,%rcx,4),%rbp
add    $0x4,%rbp
lea    (%rbx,%r8,4),%r11
lea    (%rdx,%r14,4),%r10
lea    (%rdx,%rcx,4),%rbx
add    $0x4,%rbx
lea    (%rsi,%r14,4),%r13
lea    (%rsi,%rcx,4),%r15
add    $0x4,%r15
cmp    %r11,%rax
setb   0x28(%rsp)
cmp    %rbp,%r9
setb   %r11b
cmp    %rbx,%rax
setb   %bl
cmp    %rbp,%r10
setb   %r10b
cmp    %r15,%rax
mov    0x178(%rsp),%r15
setb   %cl
cmp    %rbp,%r13
mov    0x1c0(%rsp),%r13d
setb   %bpl
mov    %r14,%rax
test   %r11b,0x28(%rsp)
mov    0xe8(%rsp),%r11
jne    1530 <asg_vstep3d+0x420>
mov    %r14,%rax
and    %r10b,%bl
jne    1530 <asg_vstep3d+0x420>
mov    %r14,%rax
and    %bpl,%cl
jne    1530 <asg_vstep3d+0x420>
movss  (%r9),%xmm0
shufps $0x0,%xmm0,%xmm0
lea    (%rdx,%r14,4),%rax
add    $0x10,%rax
lea    (%rsi,%r14,4),%rbx
add    $0x10,%rbx
lea    (%rdi,%r14,4),%rbp
add    $0x10,%rbp
xor    %ecx,%ecx
mov    0x20(%rsp),%r10
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x10(%rax,%rcx,4),%xmm1
movups (%rax,%rcx,4),%xmm2
movups -0x10(%rbx,%rcx,4),%xmm3
subps  %xmm3,%xmm1
movups (%rbx,%rcx,4),%xmm3
subps  %xmm3,%xmm2
movups -0x10(%rbp,%rcx,4),%xmm3
movups 0x0(%rbp,%rcx,4),%xmm4
mulps  %xmm0,%xmm1
addps  %xmm3,%xmm1
mulps  %xmm0,%xmm2
addps  %xmm4,%xmm2
movups %xmm1,-0x10(%rbp,%rcx,4)
movups %xmm2,0x0(%rbp,%rcx,4)
add    $0x8,%rcx
cmp    %rcx,%r10
jne    14d0 <asg_vstep3d+0x3c0>
mov    0x70(%rsp),%rax
cmp    %r10,0x40(%rsp)
je     13a0 <asg_vstep3d+0x290>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r12d,%ecx
sub    %eax,%ecx
test   $0x1,%cl
jne    1550 <asg_vstep3d+0x440>
mov    %rax,%rbx
cmp    %eax,0x10(%rsp)
jne    1580 <asg_vstep3d+0x470>
jmp    13a0 <asg_vstep3d+0x290>
nopl   0x0(%rax,%rax,1)
movss  (%rdx,%rax,4),%xmm0
subss  (%rsi,%rax,4),%xmm0
mulss  (%r9),%xmm0
addss  (%rdi,%rax,4),%xmm0
movss  %xmm0,(%rdi,%rax,4)
mov    %rax,%rbx
add    $0x1,%rbx
cmp    %eax,0x10(%rsp)
je     13a0 <asg_vstep3d+0x290>
nopw   0x0(%rax,%rax,1)
movss  (%rdx,%rbx,4),%xmm0
subss  (%rsi,%rbx,4),%xmm0
mulss  (%r9),%xmm0
addss  (%rdi,%rbx,4),%xmm0
movss  %xmm0,(%rdi,%rbx,4)
movss  0x4(%rdx,%rbx,4),%xmm0
subss  0x4(%rsi,%rbx,4),%xmm0
mulss  (%r9),%xmm0
addss  0x4(%rdi,%rbx,4),%xmm0
movss  %xmm0,0x4(%rdi,%rbx,4)
add    $0x2,%rbx
cmp    %ebx,%r12d
jne    1580 <asg_vstep3d+0x470>
jmp    13a0 <asg_vstep3d+0x290>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %r14d,0x10(%rsp)
jl     1320 <asg_vstep3d+0x210>
mov    0x170(%rsp),%rax
mov    0x10(%rax),%r11
mov    0x8(%rsp),%rbx
lea    (%r11,%rbx,4),%r9
mov    0x160(%rsp),%rcx
mov    (%rcx,%rbx,8),%rcx
mov    0x18(%rsp),%rax
mov    (%rcx,%rax,8),%rcx
mov    0x168(%rsp),%rdx
mov    0x10(%rdx),%r10
lea    (%r10,%rbx,4),%rdx
mov    0x100(%rsp),%rdi
mov    (%rdi,%rbx,8),%rsi
mov    0x8(%rdi,%rbx,8),%rdi
mov    (%rsi,%rax,8),%rsi
mov    (%rdi,%rax,8),%rdi
mov    0x10(%r15),%rbx
mov    %r14,%r13
cmpl   $0x3,0x78(%rsp)
jb     1840 <asg_vstep3d+0x730>
lea    (%rcx,%r14,4),%r8
mov    0x48(%rsp),%rax
lea    (%rcx,%rax,4),%r13
add    $0x4,%r13
mov    0x8(%rsp),%rbp
lea    0x4(%r11,%rbp,4),%rbp
mov    %rbp,0x80(%rsp)
mov    0x8(%rsp),%rbp
lea    0x4(%r10,%rbp,4),%rbp
mov    %rbp,0x30(%rsp)
lea    (%rsi,%r14,4),%r10
lea    0x4(%rsi,%rax,4),%rbp
mov    %rbp,0x58(%rsp)
lea    (%rdi,%r14,4),%rbp
mov    %rbp,0x28(%rsp)
lea    0x4(%rdi,%rax,4),%rbp
mov    %rbp,0x38(%rsp)
lea    (%rbx,%r14,4),%r11
lea    (%rbx,%rax,4),%rax
add    $0x4,%rax
mov    %rax,0xb8(%rsp)
cmp    0x80(%rsp),%r8
setb   0x80(%rsp)
cmp    %r13,%r9
setb   0xe0(%rsp)
cmp    0x30(%rsp),%r8
setb   %al
cmp    %r13,%rdx
setb   0x30(%rsp)
cmp    0x58(%rsp),%r8
setb   0x58(%rsp)
mov    %r10,0xa0(%rsp)
cmp    %r13,%r10
setb   0xa8(%rsp)
cmp    0x38(%rsp),%r8
setb   0x38(%rsp)
cmp    %r13,0x28(%rsp)
setb   0x7(%rsp)
cmp    0xb8(%rsp),%r8
setb   %r10b
cmp    %r13,%r11
setb   0xb8(%rsp)
mov    %r14,%r13
mov    0xe0(%rsp),%bpl
test   %bpl,0x80(%rsp)
jne    1840 <asg_vstep3d+0x730>
mov    %r14,%r13
and    0x30(%rsp),%al
jne    1840 <asg_vstep3d+0x730>
mov    %r14,%r13
mov    0xa8(%rsp),%al
and    %al,0x58(%rsp)
jne    1840 <asg_vstep3d+0x730>
mov    %r14,%r13
mov    0x7(%rsp),%al
and    %al,0x38(%rsp)
jne    1840 <asg_vstep3d+0x730>
mov    %r14,%r13
and    0xb8(%rsp),%r10b
jne    1840 <asg_vstep3d+0x730>
movss  (%r9),%xmm0
shufps $0x0,%xmm0,%xmm0
cvtps2pd %xmm0,%xmm0
movss  (%rdx),%xmm1
shufps $0x0,%xmm1,%xmm1
xor    %eax,%eax
mov    0xc8(%rsp),%r10
mov    0xa0(%rsp),%r13
mov    0x28(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%r8,%rax,4),%xmm2
mulps  %xmm1,%xmm2
cvtps2pd %xmm2,%xmm3
movhlps %xmm2,%xmm2
cvtps2pd %xmm2,%xmm2
movups 0x0(%r13,%rax,4),%xmm4
movups 0x0(%rbp,%rax,4),%xmm5
addps  %xmm4,%xmm5
cvtps2pd %xmm5,%xmm4
movhlps %xmm5,%xmm5
cvtps2pd %xmm5,%xmm5
cvtps2pd 0x8(%r11,%rax,4),%xmm6
cvtps2pd (%r11,%rax,4),%xmm7
mulpd  %xmm9,%xmm5
mulpd  %xmm6,%xmm5
addpd  %xmm2,%xmm5
mulpd  %xmm9,%xmm4
mulpd  %xmm7,%xmm4
addpd  %xmm3,%xmm4
mulpd  %xmm0,%xmm5
mulpd  %xmm0,%xmm4
cvtpd2ps %xmm4,%xmm2
cvtpd2ps %xmm5,%xmm3
unpcklpd %xmm3,%xmm2
movupd %xmm2,(%r8,%rax,4)
add    $0x4,%rax
cmp    %rax,%r10
jne    17b0 <asg_vstep3d+0x6a0>
mov    0xc0(%rsp),%r13
cmp    %r10,0x40(%rsp)
je     1320 <asg_vstep3d+0x210>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%r9),%xmm0
cvtss2sd %xmm0,%xmm0
movss  (%rcx,%r13,4),%xmm1
mulss  (%rdx),%xmm1
cvtss2sd %xmm1,%xmm1
movss  (%rsi,%r13,4),%xmm2
addss  (%rdi,%r13,4),%xmm2
cvtss2sd %xmm2,%xmm2
movss  (%rbx,%r13,4),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm8,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
xorps  %xmm0,%xmm0
cvtsd2ss %xmm2,%xmm0
movss  %xmm0,(%rcx,%r13,4)
add    $0x1,%r13
cmp    %r13d,%r12d
jne    1840 <asg_vstep3d+0x730>
jmp    1320 <asg_vstep3d+0x210>
nopl   (%rax)
mov    %r11,0x8(%rsp)
mov    0xf8(%rsp),%rcx
mov    0xf0(%rsp),%rdx
mov    0x11c(%rsp),%eax
cmp    %r11d,%eax
jne    127a <asg_vstep3d+0x16a>
mov    0x1b8(%rsp),%r8
mov    0x1b0(%rsp),%rax
cmpl   $0x0,(%rax)
je     1a0b <asg_vstep3d+0x8fb>
mov    0x88(%rsp),%rax
cmp    %eax,0xb0(%rsp)
jg     1a0b <asg_vstep3d+0x8fb>
mov    0x180(%rsp),%rax
movslq 0x4(%rax),%r11
mov    0x188(%rsp),%rax
mov    0x4(%rax),%r9d
lea    0x1(%r9),%r15d
mov    0x88(%rsp),%rax
lea    0x1(%rax),%r10d
mov    0x1c0(%rsp),%r14d
add    $0xffffffffffffffff,%r14
mov    %r14,%rdi
and    $0xfffffffffffffffe,%rdi
mov    0xb0(%rsp),%r12
jmp    194d <asg_vstep3d+0x83d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
cmp    %r12d,%r10d
je     1a0b <asg_vstep3d+0x8fb>
cmp    %r9d,%r11d
jg     1940 <asg_vstep3d+0x830>
mov    %r11,%rax
jmp    1969 <asg_vstep3d+0x859>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %eax,%r15d
je     1940 <asg_vstep3d+0x830>
cmpl   $0x2,0x1c0(%rsp)
02
jl     1960 <asg_vstep3d+0x850>
mov    0x108(%rsp),%rcx
mov    (%rcx,%r12,8),%rcx
mov    (%rcx,%rax,8),%rsi
mov    0x180(%rsp),%rcx
mov    (%rcx),%edx
movslq %edx,%r13
mov    $0x1,%ebp
je     19e6 <asg_vstep3d+0x8d6>
lea    (%rsi,%r13,4),%rbx
mov    $0xffffffffffffffff,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq %edx,%rdx
movss  (%rsi,%rdx,4),%xmm0
movss  %xmm0,(%rbx,%rbp,4)
lea    0x1(%rdx),%ecx
movslq %ecx,%rcx
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,-0x4(%rbx,%rbp,4)
add    $0x2,%edx
lea    (%rdi,%rbp,1),%rcx
add    $0xfffffffffffffffe,%rcx
add    $0xfffffffffffffffe,%rbp
cmp    $0xffffffffffffffff,%rcx
jne    19b0 <asg_vstep3d+0x8a0>
neg    %rbp
test   $0x1,%r14b
je     1960 <asg_vstep3d+0x850>
lea    -0x1(%rbp,%r13,1),%ecx
movslq %ecx,%rcx
movss  (%rsi,%rcx,4),%xmm0
sub    %rbp,%r13
movss  %xmm0,(%rsi,%r13,4)
jmp    1960 <asg_vstep3d+0x850>
cmpl   $0x0,(%r8)
mov    0x188(%rsp),%r12
je     1b5a <asg_vstep3d+0xa4a>
mov    0x88(%rsp),%rax
cmp    %eax,0xb0(%rsp)
jg     1b5a <asg_vstep3d+0xa4a>
mov    0x180(%rsp),%rax
movslq 0x4(%rax),%r10
mov    0x4(%r12),%r9d
lea    0x1(%r9),%r14d
mov    0x88(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x88(%rsp)
mov    0x1c0(%rsp),%r11d
add    $0xffffffffffffffff,%r11
mov    %r11,%rdi
and    $0xfffffffffffffffe,%rdi
neg    %rdi
jmp    1aa4 <asg_vstep3d+0x994>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0xb0(%rsp),%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0xb0(%rsp)
cmp    %ecx,0x88(%rsp)
je     1b5a <asg_vstep3d+0xa4a>
cmp    %r9d,%r10d
jg     1a80 <asg_vstep3d+0x970>
mov    %r10,%rax
jmp    1ab9 <asg_vstep3d+0x9a9>
xchg   %ax,%ax
add    $0x1,%rax
cmp    %eax,%r14d
je     1a80 <asg_vstep3d+0x970>
cmpl   $0x2,0x1c0(%rsp)
02
jl     1ab0 <asg_vstep3d+0x9a0>
mov    0x108(%rsp),%rcx
mov    0xb0(%rsp),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    (%rcx,%rax,8),%rbx
mov    (%r12),%esi
movslq %esi,%r15
mov    $0x1,%ebp
je     1b33 <asg_vstep3d+0xa23>
lea    (%rbx,%r15,4),%rdx
add    $0x4,%rdx
mov    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
movslq %esi,%rsi
movss  (%rbx,%rsi,4),%xmm0
movss  %xmm0,-0x4(%rdx,%rbp,4)
lea    -0x1(%rsi),%ecx
movslq %ecx,%rcx
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rbp,4)
add    $0xfffffffe,%esi
lea    (%rdi,%rbp,1),%rcx
add    $0x2,%rcx
add    $0x2,%rbp
cmp    $0x1,%rcx
jne    1b00 <asg_vstep3d+0x9f0>
test   $0x1,%r11b
je     1ab0 <asg_vstep3d+0x9a0>
mov    %r15d,%ecx
sub    %ebp,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rbx,%rcx,4),%xmm0
add    %r15,%rbp
movss  %xmm0,(%rbx,%rbp,4)
jmp    1ab0 <asg_vstep3d+0x9a0>
mov    0x1b0(%rsp),%rax
cmpl   $0x0,0x4(%rax)
je     1c92 <asg_vstep3d+0xb82>
mov    0x50(%rsp),%rax
cmp    %eax,0x60(%rsp)
jg     1c92 <asg_vstep3d+0xb82>
mov    0x190(%rsp),%rax
movslq (%rax),%r11
mov    0x198(%rsp),%rax
mov    (%rax),%r9d
lea    0x1(%r9),%r15d
mov    0x50(%rsp),%rax
lea    0x1(%rax),%r10d
mov    0x1c0(%rsp),%r14d
add    $0xffffffffffffffff,%r14
mov    %r14,%rdi
and    $0xfffffffffffffffe,%rdi
mov    0x60(%rsp),%r12
jmp    1bcd <asg_vstep3d+0xabd>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
cmp    %r12d,%r10d
je     1c92 <asg_vstep3d+0xb82>
cmp    %r9d,%r11d
jg     1bc0 <asg_vstep3d+0xab0>
mov    %r11,%rcx
jmp    1be9 <asg_vstep3d+0xad9>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %ecx,%r15d
je     1bc0 <asg_vstep3d+0xab0>
cmpl   $0x2,0x1c0(%rsp)
02
jl     1be0 <asg_vstep3d+0xad0>
mov    0x110(%rsp),%rax
mov    (%rax,%r12,8),%rax
mov    0x190(%rsp),%rdx
mov    0x4(%rdx),%esi
movslq %esi,%r13
mov    $0x1,%ebp
je     1c66 <asg_vstep3d+0xb56>
lea    (%rax,%r13,8),%rbx
mov    $0xffffffffffffffff,%rbp
nop
movslq %esi,%rsi
mov    (%rax,%rsi,8),%rdx
movss  (%rdx,%rcx,4),%xmm0
mov    (%rbx,%rbp,8),%rdx
movss  %xmm0,(%rdx,%rcx,4)
lea    0x1(%rsi),%edx
movslq %edx,%rdx
mov    (%rax,%rdx,8),%rdx
movss  (%rdx,%rcx,4),%xmm0
mov    -0x8(%rbx,%rbp,8),%rdx
movss  %xmm0,(%rdx,%rcx,4)
add    $0x2,%esi
lea    (%rdi,%rbp,1),%rdx
add    $0xfffffffffffffffe,%rdx
add    $0xfffffffffffffffe,%rbp
cmp    $0xffffffffffffffff,%rdx
jne    1c20 <asg_vstep3d+0xb10>
neg    %rbp
test   $0x1,%r14b
je     1be0 <asg_vstep3d+0xad0>
lea    -0x1(%rbp,%r13,1),%edx
movslq %edx,%rdx
mov    (%rax,%rdx,8),%rdx
movss  (%rdx,%rcx,4),%xmm0
sub    %rbp,%r13
mov    (%rax,%r13,8),%rax
movss  %xmm0,(%rax,%rcx,4)
jmp    1be0 <asg_vstep3d+0xad0>
cmpl   $0x0,0x4(%r8)
mov    0x198(%rsp),%r12
mov    0x160(%rsp),%r13
je     1de0 <asg_vstep3d+0xcd0>
mov    0x50(%rsp),%rax
cmp    %eax,0x60(%rsp)
jg     1de0 <asg_vstep3d+0xcd0>
mov    0x190(%rsp),%rax
movslq (%rax),%r10
mov    (%r12),%r9d
lea    0x1(%r9),%r14d
mov    0x50(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x50(%rsp)
mov    0x1c0(%rsp),%r11d
add    $0xffffffffffffffff,%r11
mov    %r11,%rdi
and    $0xfffffffffffffffe,%rdi
neg    %rdi
jmp    1d1b <asg_vstep3d+0xc0b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x60(%rsp),%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x60(%rsp)
cmp    %ecx,0x50(%rsp)
je     1de0 <asg_vstep3d+0xcd0>
cmp    %r9d,%r10d
jg     1d00 <asg_vstep3d+0xbf0>
mov    %r10,%rcx
jmp    1d39 <asg_vstep3d+0xc29>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rcx
cmp    %ecx,%r14d
je     1d00 <asg_vstep3d+0xbf0>
cmpl   $0x2,0x1c0(%rsp)
02
jl     1d30 <asg_vstep3d+0xc20>
mov    0x110(%rsp),%rax
mov    0x60(%rsp),%rdx
mov    (%rax,%rdx,8),%rbx
mov    0x4(%r12),%eax
movslq %eax,%r15
mov    $0x1,%ebp
je     1db2 <asg_vstep3d+0xca2>
lea    (%rbx,%r15,8),%rsi
add    $0x8,%rsi
mov    $0x1,%ebp
cltq
mov    (%rbx,%rax,8),%rdx
movss  (%rdx,%rcx,4),%xmm0
mov    -0x8(%rsi,%rbp,8),%rdx
movss  %xmm0,(%rdx,%rcx,4)
lea    -0x1(%rax),%edx
movslq %edx,%rdx
mov    (%rbx,%rdx,8),%rdx
movss  (%rdx,%rcx,4),%xmm0
mov    (%rsi,%rbp,8),%rdx
movss  %xmm0,(%rdx,%rcx,4)
add    $0xfffffffe,%eax
lea    (%rdi,%rbp,1),%rdx
add    $0x2,%rdx
add    $0x2,%rbp
cmp    $0x1,%rdx
jne    1d70 <asg_vstep3d+0xc60>
test   $0x1,%r11b
je     1d30 <asg_vstep3d+0xc20>
mov    %r15d,%eax
sub    %ebp,%eax
add    $0x1,%eax
cltq
mov    (%rbx,%rax,8),%rax
movss  (%rax,%rcx,4),%xmm0
add    %r15,%rbp
mov    (%rbx,%rbp,8),%rax
movss  %xmm0,(%rax,%rcx,4)
jmp    1d30 <asg_vstep3d+0xc20>
mov    0x1b0(%rsp),%rax
cmpl   $0x0,0x8(%rax)
je     1e0f <asg_vstep3d+0xcff>
mov    0x1a0(%rsp),%rax
movslq 0x4(%rax),%rcx
mov    0x1a8(%rsp),%rax
mov    0x4(%rax),%r10d
cmp    %r10d,%ecx
jle    2b93 <asg_vstep3d+0x1a83>
cmpl   $0x0,0x8(%r8)
je     1e37 <asg_vstep3d+0xd27>
mov    0x1a0(%rsp),%rax
movslq 0x4(%rax),%rax
mov    0x1a8(%rsp),%rcx
mov    0x4(%rcx),%r9d
cmp    %r9d,%eax
jle    2cc5 <asg_vstep3d+0x1bb5>
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x180(%rsp),%rax
movslq 0x4(%rax),%rax
mov    %rax,0xc8(%rsp)
mov    0x188(%rsp),%rax
mov    0x4(%rax),%eax
mov    %rax,0xc0(%rsp)
add    $0x1,%eax
mov    %eax,0x58(%rsp)
mov    0x88(%rsp),%rax
add    $0x1,%eax
mov    %eax,0x50(%rsp)
movabs $0x100000000,%r13
movsd  0x1177(%rip),%xmm8
movapd 0x115e(%rip),%xmm9
mov    0xb0(%rsp),%rax
mov    %rax,0x28(%rsp)
jmp    1edb <asg_vstep3d+0xdcb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x28(%rsp),%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x28(%rsp)
cmp    %ecx,0x50(%rsp)
je     1188 <asg_vstep3d+0x78>
mov    0xc0(%rsp),%rax
cmp    %eax,0xc8(%rsp)
jg     1ec0 <asg_vstep3d+0xdb0>
mov    0x180(%rsp),%rax
movslq (%rax),%r11
mov    0x188(%rsp),%rax
mov    (%rax),%ebx
mov    %ebx,%eax
sub    %r11d,%eax
lea    0x4(,%rax,4),%rcx
mov    %rcx,0xa8(%rsp)
lea    0x1(%rbx),%r12d
lea    (%r11,%rax,1),%rcx
mov    %rcx,0xd0(%rsp)
mov    %rax,0x10(%rsp)
lea    0x1(%rax),%rcx
lea    0x1(%r11),%eax
mov    %rax,0x40(%rsp)
mov    %rcx,%rbp
movabs $0x1fffffff8,%rax
and    %rax,%rbp
lea    (%r11,%rbp,1),%rdx
mov    %rdx,0x60(%rsp)
add    $0x4,%rax
mov    %rcx,0x80(%rsp)
and    %rcx,%rax
mov    %rax,0x90(%rsp)
add    %r11,%rax
mov    %rax,0xd8(%rsp)
lea    0x1(%r11),%rax
mov    %rax,0xb8(%rsp)
mov    0xc8(%rsp),%rax
mov    %rax,0x18(%rsp)
mov    %r11,0x8(%rsp)
mov    %rbx,0x78(%rsp)
mov    %rbp,0xe0(%rsp)
jmp    1fc0 <asg_vstep3d+0xeb0>
mov    0x18(%rsp),%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x18(%rsp)
cmp    %ecx,0x58(%rsp)
mov    0x78(%rsp),%rbx
je     1ec0 <asg_vstep3d+0xdb0>
cmp    %r11d,%ebx
jl     1ff6 <asg_vstep3d+0xee6>
lea    0x0(,%r11,4),%rdi
add    (%r15),%rdi
xor    %esi,%esi
mov    0xa8(%rsp),%rdx
call   1030 <memset@plt>
mov    0x8(%rsp),%r11
movapd 0x1013(%rip),%xmm9
movsd  0x101a(%rip),%xmm8
cmpl   $0x0,0x1c0(%rsp)
jle    2240 <asg_vstep3d+0x1130>
xor    %r10d,%r10d
jmp    202a <asg_vstep3d+0xf1a>
nopl   0x0(%rax)
add    $0x1,%r10
mov    %r10,%r8
mov    %r8,%r10
mov    0x1c0(%rsp),%eax
cmp    %rax,%r8
je     2240 <asg_vstep3d+0x1130>
cmp    %r11d,%ebx
jl     2010 <asg_vstep3d+0xf00>
lea    0x1(%r10),%r8
mov    0x1c8(%rsp),%rax
mov    (%rax),%rax
lea    (%rax,%r10,4),%rcx
mov    0x48(%rsp),%rdx
mov    0x28(%rsp),%rsi
mov    (%rdx,%rsi,8),%rdx
mov    0x18(%rsp),%rsi
mov    (%rdx,%rsi,8),%rdi
mov    (%r15),%rsi
mov    %r11,%rbx
cmpl   $0x7,0x10(%rsp)
jb     21e0 <asg_vstep3d+0x10d0>
mov    0x40(%rsp),%rdx
add    %r10d,%edx
mov    0x10(%rsp),%rbp
add    %edx,%ebp
mov    %r11,%rbx
cmp    %edx,%ebp
jl     21e0 <asg_vstep3d+0x10d0>
lea    (%rsi,%r11,4),%r14
mov    0xd0(%rsp),%rbx
lea    (%rsi,%rbx,4),%rbp
add    $0x4,%rbp
lea    0x4(%rax,%r10,4),%rax
mov    %rax,0x20(%rsp)
lea    0x0(,%r10,4),%rdx
lea    (%rdi,%r11,4),%r9
sub    %rdx,%r9
lea    (%rdi,%rbx,4),%rax
add    $0x4,%rax
sub    %rdx,%rax
mov    0x40(%rsp),%rdx
add    %r10d,%edx
movslq %edx,%rbx
mov    0x10(%rsp),%rdx
lea    (%rdi,%rdx,4),%rdx
add    $0x4,%rdx
lea    (%rdx,%rbx,4),%r15
cmp    0x20(%rsp),%r14
setb   0x20(%rsp)
cmp    %rbp,%rcx
setb   0x70(%rsp)
cmp    %rax,%r14
setb   %dl
cmp    %rbp,%r9
setb   0x68(%rsp)
cmp    %r15,%r14
lea    (%rdi,%rbx,4),%rbx
setb   %r14b
cmp    %rbp,%rbx
setb   %bpl
mov    %r11,%rbx
mov    0x70(%rsp),%al
test   %al,0x20(%rsp)
mov    0x178(%rsp),%r15
jne    21e0 <asg_vstep3d+0x10d0>
mov    %r11,%rbx
and    0x68(%rsp),%dl
jne    21e0 <asg_vstep3d+0x10d0>
mov    %r11,%rbx
and    %bpl,%r14b
jne    21e0 <asg_vstep3d+0x10d0>
movss  (%rcx),%xmm0
shufps $0x0,%xmm0,%xmm0
mov    0xb8(%rsp),%rax
lea    (%rax,%r10,1),%ebx
shl    $0x20,%rbx
add    $0x10,%r9
lea    (%rsi,%r11,4),%rax
add    $0x10,%rax
xor    %ebp,%ebp
movabs $0x800000000,%r11
mov    0xe0(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbx,%rdx
sar    $0x1e,%rdx
movups (%rdi,%rdx,1),%xmm1
movups 0x10(%rdi,%rdx,1),%xmm2
movups -0x10(%r9,%rbp,4),%xmm3
subps  %xmm3,%xmm1
movups (%r9,%rbp,4),%xmm3
subps  %xmm3,%xmm2
movups -0x10(%rax,%rbp,4),%xmm3
movups (%rax,%rbp,4),%xmm4
mulps  %xmm0,%xmm1
addps  %xmm3,%xmm1
mulps  %xmm0,%xmm2
addps  %xmm4,%xmm2
movups %xmm1,-0x10(%rax,%rbp,4)
movups %xmm2,(%rax,%rbp,4)
add    $0x8,%rbp
add    %r11,%rbx
cmp    %rbp,%r14
jne    2180 <asg_vstep3d+0x1070>
mov    0x60(%rsp),%rbx
cmp    %r14,0x80(%rsp)
mov    0x8(%rsp),%r11
je     2230 <asg_vstep3d+0x1120>
nop
lea    (%rbx,%r10,1),%ebp
add    $0x1,%ebp
shl    $0x20,%rbp
shl    $0x2,%r10
mov    %rdi,%rdx
sub    %r10,%rdx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbp,%rax
sar    $0x1e,%rax
movss  (%rdi,%rax,1),%xmm0
subss  (%rdx,%rbx,4),%xmm0
mulss  (%rcx),%xmm0
addss  (%rsi,%rbx,4),%xmm0
movss  %xmm0,(%rsi,%rbx,4)
add    $0x1,%rbx
add    %r13,%rbp
cmp    %ebx,%r12d
jne    2200 <asg_vstep3d+0x10f0>
mov    0x8(%rsp),%r11
mov    0x78(%rsp),%rbx
jmp    2017 <asg_vstep3d+0xf07>
nopw   0x0(%rax,%rax,1)
cmp    %r11d,%ebx
jl     1fa0 <asg_vstep3d+0xe90>
mov    0x170(%rsp),%rax
mov    (%rax),%rax
mov    %rax,0x70(%rsp)
mov    0x108(%rsp),%rax
mov    0x28(%rsp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rsp),%rdx
mov    (%rax,%rdx,8),%rsi
mov    0x168(%rsp),%rax
mov    (%rax),%rax
mov    %rax,0x68(%rsp)
mov    0x100(%rsp),%rax
mov    (%rax,%rcx,8),%rax
mov    (%rax,%rdx,8),%rax
mov    %rax,0x20(%rsp)
mov    (%r15),%rax
mov    %rax,0x38(%rsp)
mov    %r11,%rbx
cmpl   $0x3,0x10(%rsp)
jb     2460 <asg_vstep3d+0x1350>
lea    (%rsi,%r11,4),%rax
mov    %rsi,0x30(%rsp)
mov    0xd0(%rsp),%rsi
mov    0x30(%rsp),%rcx
lea    (%rcx,%rsi,4),%rbx
add    $0x4,%rbx
mov    0x70(%rsp),%rdx
lea    (%rdx,%r11,4),%rcx
lea    0x4(%rdx,%rsi,4),%r8
mov    0x68(%rsp),%rbp
lea    0x0(%rbp,%r11,4),%rdx
lea    0x4(%rbp,%rsi,4),%r9
mov    0x20(%rsp),%rbp
lea    0x0(%rbp,%r11,4),%rdi
mov    %rdi,0xa0(%rsp)
lea    0x8(,%rsi,4),%r10
add    %rbp,%r10
mov    0x38(%rsp),%rdi
lea    (%rdi,%r11,4),%rbp
cmp    %r8,%rax
setb   0x7(%rsp)
cmp    %rbx,%rcx
setb   %r11b
cmp    %r9,%rax
setb   %r9b
cmp    %rbx,%rdx
setb   0x98(%rsp)
cmp    %r10,%rax
setb   %r8b
cmp    %rbx,0xa0(%rsp)
lea    0x4(%rdi,%rsi,4),%rdi
mov    0x30(%rsp),%rsi
setb   %r10b
cmp    %rdi,%rax
setb   %dil
cmp    %rbx,%rbp
setb   0xa0(%rsp)
mov    0x8(%rsp),%rbx
test   %r11b,0x7(%rsp)
mov    0x8(%rsp),%r11
jne    2460 <asg_vstep3d+0x1350>
mov    %r11,%rbx
and    0x98(%rsp),%r9b
jne    2460 <asg_vstep3d+0x1350>
mov    %r11,%rbx
and    %r10b,%r8b
jne    2460 <asg_vstep3d+0x1350>
mov    %r11,%rbx
and    0xa0(%rsp),%dil
jne    2460 <asg_vstep3d+0x1350>
mov    0x20(%rsp),%rsi
lea    (%rsi,%r11,4),%rbx
add    $0x4,%rbx
xor    %edi,%edi
mov    0x90(%rsp),%rsi
nopl   0x0(%rax)
cvtps2pd (%rcx,%rdi,4),%xmm0
cvtps2pd 0x8(%rcx,%rdi,4),%xmm1
movups (%rax,%rdi,4),%xmm2
movups (%rdx,%rdi,4),%xmm3
mulps  %xmm2,%xmm3
cvtps2pd %xmm3,%xmm2
movhlps %xmm3,%xmm3
cvtps2pd %xmm3,%xmm3
movups -0x4(%rbx,%rdi,4),%xmm4
movups (%rbx,%rdi,4),%xmm5
addps  %xmm4,%xmm5
cvtps2pd %xmm5,%xmm4
movhlps %xmm5,%xmm5
cvtps2pd %xmm5,%xmm5
cvtps2pd 0x8(%rbp,%rdi,4),%xmm6
cvtps2pd 0x0(%rbp,%rdi,4),%xmm7
mulpd  %xmm9,%xmm5
mulpd  %xmm6,%xmm5
addpd  %xmm3,%xmm5
mulpd  %xmm1,%xmm5
mulpd  %xmm9,%xmm4
mulpd  %xmm7,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm0,%xmm4
cvtpd2ps %xmm4,%xmm0
cvtpd2ps %xmm5,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,(%rax,%rdi,4)
add    $0x4,%rdi
cmp    %rdi,%rsi
jne    23c0 <asg_vstep3d+0x12b0>
mov    0xd8(%rsp),%rbx
cmp    %rsi,0x80(%rsp)
mov    0x30(%rsp),%rsi
je     1fa0 <asg_vstep3d+0xe90>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x70(%rsp),%rax
lea    (%rax,%rbx,4),%rax
lea    (%rsi,%rbx,4),%rcx
mov    0x68(%rsp),%rdx
lea    (%rdx,%rbx,4),%rdx
mov    0x20(%rsp),%rsi
lea    0x4(%rsi,%rbx,4),%rsi
mov    0x38(%rsp),%rdi
lea    (%rdi,%rbx,4),%rdi
mov    %r12d,%ebp
sub    %ebx,%ebp
xor    %ebx,%ebx
movss  (%rax,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  (%rcx,%rbx,4),%xmm1
mulss  (%rdx,%rbx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x4(%rsi,%rbx,4),%xmm2
addss  (%rsi,%rbx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movss  (%rdi,%rbx,4),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm8,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
xorps  %xmm0,%xmm0
cvtsd2ss %xmm2,%xmm0
movss  %xmm0,(%rcx,%rbx,4)
add    $0x1,%rbx
cmp    %ebx,%ebp
jne    2490 <asg_vstep3d+0x1380>
jmp    1fa0 <asg_vstep3d+0xe90>
mov    0x190(%rsp),%rax
movslq 0x4(%rax),%rax
mov    %rax,0xc0(%rsp)
mov    0x198(%rsp),%rax
mov    0x4(%rax),%eax
mov    %rax,0xf8(%rsp)
add    $0x1,%eax
mov    %eax,0xe0(%rsp)
mov    0x50(%rsp),%rax
add    $0x1,%eax
mov    %eax,0xf0(%rsp)
movsd  0xade(%rip),%xmm8
movapd 0xac5(%rip),%xmm9
mov    0x60(%rsp),%rax
mov    %rax,0x18(%rsp)
jmp    256e <asg_vstep3d+0x145e>
nopw   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x18(%rsp)
cmp    %ecx,0xf0(%rsp)
je     11b4 <asg_vstep3d+0xa4>
mov    0xf8(%rsp),%rax
cmp    %eax,0xc0(%rsp)
jg     2550 <asg_vstep3d+0x1440>
mov    0x190(%rsp),%rax
movslq (%rax),%rbx
mov    0x198(%rsp),%rax
mov    (%rax),%r9d
mov    %r9d,%ecx
sub    %ebx,%ecx
lea    0x4(,%rcx,4),%rax
mov    %rax,0xb8(%rsp)
lea    (%rbx,%rcx,1),%rax
mov    %rax,0x70(%rsp)
mov    %rcx,0x78(%rsp)
add    $0x1,%rcx
lea    0x1(%r9),%r12d
mov    %rcx,%rdx
movabs $0x1fffffff8,%rax
and    %rax,%rdx
lea    (%rdx,%rbx,1),%rsi
mov    %rsi,0x80(%rsp)
add    $0x4,%rax
mov    %rcx,0x68(%rsp)
and    %rcx,%rax
lea    (%rax,%rbx,1),%rcx
mov    %rcx,0xc8(%rsp)
mov    0xc0(%rsp),%r14
mov    %rbx,0x10(%rsp)
mov    %r9,0x40(%rsp)
mov    %rdx,0xd0(%rsp)
mov    %rax,0xd8(%rsp)
jmp    2638 <asg_vstep3d+0x1528>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14
mov    %r14,%r10
mov    %r10,%r14
cmp    %r10d,0xe0(%rsp)
je     2550 <asg_vstep3d+0x1440>
cmp    %ebx,%r9d
jl     266f <asg_vstep3d+0x155f>
lea    0x0(,%rbx,4),%rdi
add    0x8(%r15),%rdi
xor    %esi,%esi
mov    0xb8(%rsp),%rdx
call   1030 <memset@plt>
mov    0x40(%rsp),%r9
movapd 0x99a(%rip),%xmm9
movsd  0x9a1(%rip),%xmm8
cmpl   $0x0,0x1c0(%rsp)
jle    28d0 <asg_vstep3d+0x17c0>
lea    0x1(%r14),%rax
mov    %rax,0x8(%rsp)
xor    %r11d,%r11d
mov    %r14,0x20(%rsp)
jmp    26a5 <asg_vstep3d+0x1595>
mov    0x1c0(%rsp),%eax
cmp    %rax,%r11
mov    0x10(%rsp),%rbx
je     28d0 <asg_vstep3d+0x17c0>
mov    %r11,%rax
add    $0x1,%r11
cmp    %ebx,%r9d
jl     2690 <asg_vstep3d+0x1580>
mov    0x8(%rsp),%rcx
lea    (%rcx,%rax,1),%edx
mov    %r14,%rdi
sub    %rax,%rdi
mov    0x1c8(%rsp),%rcx
mov    0x8(%rcx),%rbx
lea    (%rbx,%rax,4),%r10
mov    0xe8(%rsp),%rax
mov    0x18(%rsp),%rsi
mov    (%rax,%rsi,8),%rax
movslq %edx,%rdx
mov    (%rax,%rdx,8),%rsi
mov    (%rax,%rdi,8),%rdi
mov    0x8(%r15),%rbp
mov    0x10(%rsp),%rax
cmpl   $0x7,0x78(%rsp)
jb     2830 <asg_vstep3d+0x1720>
mov    0x10(%rsp),%rax
lea    0x0(,%rax,4),%r9
add    %rbp,%r9
mov    0x70(%rsp),%rcx
lea    0x4(%rbp,%rcx,4),%r14
lea    (%rbx,%r11,4),%rbx
lea    (%rsi,%rax,4),%r15
lea    0x4(%rsi,%rcx,4),%r8
lea    (%rdi,%rax,4),%rdx
mov    %rdx,0x28(%rsp)
lea    (%rdi,%rcx,4),%r13
add    $0x4,%r13
cmp    %rbx,%r9
setb   0x48(%rsp)
cmp    %r14,%r10
setb   %bl
cmp    %r8,%r9
setb   %dl
cmp    %r14,%r15
setb   %r8b
cmp    %r13,%r9
mov    0x40(%rsp),%r9
setb   %cl
cmp    %r14,0x28(%rsp)
mov    0x20(%rsp),%r14
setb   %r13b
test   %bl,0x48(%rsp)
mov    0x178(%rsp),%r15
jne    2830 <asg_vstep3d+0x1720>
mov    0x10(%rsp),%rax
and    %r8b,%dl
jne    2830 <asg_vstep3d+0x1720>
mov    0x10(%rsp),%rax
and    %r13b,%cl
jne    2830 <asg_vstep3d+0x1720>
movss  (%r10),%xmm0
shufps $0x0,%xmm0,%xmm0
mov    0x10(%rsp),%rcx
lea    (%rsi,%rcx,4),%rax
add    $0x10,%rax
lea    (%rdi,%rcx,4),%rbx
add    $0x10,%rbx
lea    0x10(,%rcx,4),%rcx
add    %rbp,%rcx
xor    %edx,%edx
mov    0xd0(%rsp),%r8
nopl   0x0(%rax)
movups -0x10(%rax,%rdx,4),%xmm1
movups (%rax,%rdx,4),%xmm2
movups -0x10(%rbx,%rdx,4),%xmm3
subps  %xmm3,%xmm1
movups (%rbx,%rdx,4),%xmm3
subps  %xmm3,%xmm2
movups -0x10(%rcx,%rdx,4),%xmm3
movups (%rcx,%rdx,4),%xmm4
mulps  %xmm0,%xmm1
addps  %xmm3,%xmm1
mulps  %xmm0,%xmm2
addps  %xmm4,%xmm2
movups %xmm1,-0x10(%rcx,%rdx,4)
movups %xmm2,(%rcx,%rdx,4)
add    $0x8,%rdx
cmp    %rdx,%r8
jne    27d0 <asg_vstep3d+0x16c0>
mov    0x80(%rsp),%rax
cmp    %r8,0x68(%rsp)
je     2690 <asg_vstep3d+0x1580>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r12d,%ecx
sub    %eax,%ecx
test   $0x1,%cl
jne    2850 <asg_vstep3d+0x1740>
mov    %rax,%rbx
cmp    %eax,%r9d
jne    2880 <asg_vstep3d+0x1770>
jmp    2690 <asg_vstep3d+0x1580>
nopw   0x0(%rax,%rax,1)
movss  (%rsi,%rax,4),%xmm0
subss  (%rdi,%rax,4),%xmm0
mulss  (%r10),%xmm0
addss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
mov    %rax,%rbx
add    $0x1,%rbx
cmp    %eax,%r9d
je     2690 <asg_vstep3d+0x1580>
nopl   0x0(%rax,%rax,1)
movss  (%rsi,%rbx,4),%xmm0
subss  (%rdi,%rbx,4),%xmm0
mulss  (%r10),%xmm0
addss  0x0(%rbp,%rbx,4),%xmm0
movss  %xmm0,0x0(%rbp,%rbx,4)
movss  0x4(%rsi,%rbx,4),%xmm0
subss  0x4(%rdi,%rbx,4),%xmm0
mulss  (%r10),%xmm0
addss  0x4(%rbp,%rbx,4),%xmm0
movss  %xmm0,0x4(%rbp,%rbx,4)
add    $0x2,%rbx
cmp    %ebx,%r12d
jne    2880 <asg_vstep3d+0x1770>
jmp    2690 <asg_vstep3d+0x1580>
cs nopw 0x0(%rax,%rax,1)
cmp    %ebx,%r9d
jl     2620 <asg_vstep3d+0x1510>
lea    0x1(%r14),%r10
mov    0x170(%rsp),%rax
mov    0x8(%rax),%rcx
lea    (%rcx,%r14,4),%r11
mov    0x110(%rsp),%rax
mov    0x18(%rsp),%rdi
mov    (%rax,%rdi,8),%rax
mov    (%rax,%r14,8),%rdx
mov    0x168(%rsp),%rax
mov    0x8(%rax),%r13
lea    0x0(%r13,%r14,4),%rsi
mov    0x100(%rsp),%rax
mov    (%rax,%rdi,8),%rax
mov    (%rax,%r14,8),%rdi
mov    0x8(%rax,%r14,8),%rax
mov    0x8(%r15),%rbp
cmpl   $0x3,0x78(%rsp)
jb     2b30 <asg_vstep3d+0x1a20>
mov    %rbx,%r8
lea    (%rdx,%rbx,4),%r9
mov    %r10,0x28(%rsp)
mov    0x70(%rsp),%r10
lea    (%rdx,%r10,4),%rbx
add    $0x4,%rbx
lea    0x4(%rcx,%r14,4),%rcx
mov    %rcx,0x48(%rsp)
lea    0x4(%r13,%r14,4),%rcx
mov    %rcx,0xa8(%rsp)
lea    (%rdi,%r8,4),%rcx
mov    %rcx,0x8(%rsp)
lea    0x4(%rdi,%r10,4),%rcx
mov    %rcx,0x30(%rsp)
lea    (%rax,%r8,4),%r14
lea    0x4(%rax,%r10,4),%rcx
mov    %rcx,0x58(%rsp)
lea    0x0(%rbp,%r8,4),%r13
lea    0x4(,%r10,4),%rcx
add    %rbp,%rcx
mov    %rcx,0x38(%rsp)
mov    0x28(%rsp),%r10
cmp    0x48(%rsp),%r9
setb   0x48(%rsp)
cmp    %rbx,%r11
setb   0x20(%rsp)
cmp    0xa8(%rsp),%r9
setb   0xa8(%rsp)
cmp    %rbx,%rsi
setb   0x7(%rsp)
cmp    0x30(%rsp),%r9
setb   0x30(%rsp)
cmp    %rbx,0x8(%rsp)
setb   0xa0(%rsp)
cmp    0x58(%rsp),%r9
setb   0x58(%rsp)
cmp    %rbx,%r14
setb   0x98(%rsp)
cmp    0x38(%rsp),%r9
setb   0x38(%rsp)
cmp    %rbx,%r13
setb   0x90(%rsp)
mov    %r8,%rbx
mov    0x20(%rsp),%cl
test   %cl,0x48(%rsp)
jne    2b30 <asg_vstep3d+0x1a20>
mov    %r8,%rbx
mov    0x7(%rsp),%cl
and    %cl,0xa8(%rsp)
jne    2b30 <asg_vstep3d+0x1a20>
mov    %r8,%rbx
mov    0xa0(%rsp),%cl
and    %cl,0x30(%rsp)
jne    2b30 <asg_vstep3d+0x1a20>
mov    %r8,%rbx
mov    0x98(%rsp),%cl
and    %cl,0x58(%rsp)
jne    2b30 <asg_vstep3d+0x1a20>
mov    %r8,%rbx
mov    0x90(%rsp),%cl
and    %cl,0x38(%rsp)
mov    0x8(%rsp),%rcx
jne    2b30 <asg_vstep3d+0x1a20>
movss  (%r11),%xmm0
shufps $0x0,%xmm0,%xmm0
cvtps2pd %xmm0,%xmm0
movss  (%rsi),%xmm1
shufps $0x0,%xmm1,%xmm1
xor    %ebx,%ebx
mov    0xd8(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%r9,%rbx,4),%xmm2
mulps  %xmm1,%xmm2
cvtps2pd %xmm2,%xmm3
movhlps %xmm2,%xmm2
cvtps2pd %xmm2,%xmm2
movups (%rcx,%rbx,4),%xmm4
movups (%r14,%rbx,4),%xmm5
addps  %xmm4,%xmm5
cvtps2pd %xmm5,%xmm4
movhlps %xmm5,%xmm5
cvtps2pd %xmm5,%xmm5
cvtps2pd 0x8(%r13,%rbx,4),%xmm6
cvtps2pd 0x0(%r13,%rbx,4),%xmm7
mulpd  %xmm9,%xmm5
mulpd  %xmm6,%xmm5
addpd  %xmm2,%xmm5
mulpd  %xmm9,%xmm4
mulpd  %xmm7,%xmm4
addpd  %xmm3,%xmm4
mulpd  %xmm0,%xmm5
mulpd  %xmm0,%xmm4
cvtpd2ps %xmm4,%xmm2
cvtpd2ps %xmm5,%xmm3
unpcklpd %xmm3,%xmm2
movupd %xmm2,(%r9,%rbx,4)
add    $0x4,%rbx
cmp    %rbx,%r8
jne    2aa0 <asg_vstep3d+0x1990>
mov    0xc8(%rsp),%rbx
cmp    %r8,0x68(%rsp)
mov    0x10(%rsp),%r8
jne    2b30 <asg_vstep3d+0x1a20>
mov    %r8,%rbx
jmp    2b89 <asg_vstep3d+0x1a79>
nopl   0x0(%rax,%rax,1)
movss  (%r11),%xmm0
cvtss2sd %xmm0,%xmm0
movss  (%rdx,%rbx,4),%xmm1
mulss  (%rsi),%xmm1
cvtss2sd %xmm1,%xmm1
movss  (%rdi,%rbx,4),%xmm2
addss  (%rax,%rbx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movss  0x0(%rbp,%rbx,4),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm8,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
xorps  %xmm0,%xmm0
cvtsd2ss %xmm2,%xmm0
movss  %xmm0,(%rdx,%rbx,4)
add    $0x1,%rbx
cmp    %ebx,%r12d
jne    2b30 <asg_vstep3d+0x1a20>
mov    0x10(%rsp),%rbx
mov    0x40(%rsp),%r9
jmp    2627 <asg_vstep3d+0x1517>
mov    0x1a0(%rsp),%rax
movslq (%rax),%r11
mov    0x1a8(%rsp),%rax
mov    (%rax),%r9d
mov    0x90(%rsp),%rdx
lea    -0x1(%rdx),%r14d
lea    0x1(%r9),%r12d
add    $0x1,%r10d
mov    0x1c0(%rsp),%r15d
add    $0xffffffffffffffff,%r15
mov    %r15,%rax
and    $0xfffffffffffffffe,%rax
lea    0x0(,%rdx,8),%rdx
add    %r13,%rdx
jmp    2bed <asg_vstep3d+0x1add>
nopl   (%rax)
add    $0x1,%rcx
cmp    %ecx,%r10d
je     1e0f <asg_vstep3d+0xcff>
cmp    %r9d,%r11d
jg     2be0 <asg_vstep3d+0x1ad0>
mov    %r11,%rsi
jmp    2c09 <asg_vstep3d+0x1af9>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rsi
cmp    %esi,%r12d
je     2be0 <asg_vstep3d+0x1ad0>
cmpl   $0x2,0x1c0(%rsp)
02
jl     2c00 <asg_vstep3d+0x1af0>
mov    $0x1,%ebp
je     2c88 <asg_vstep3d+0x1b78>
mov    $0xffffffffffffffff,%rbp
mov    0xd8(%rsp),%edi
nopl   0x0(%rax,%rax,1)
movslq %edi,%rdi
mov    0x0(%r13,%rdi,8),%rbx
mov    (%rbx,%rcx,8),%rbx
movss  (%rbx,%rsi,4),%xmm0
mov    (%rdx,%rbp,8),%rbx
mov    (%rbx,%rcx,8),%rbx
movss  %xmm0,(%rbx,%rsi,4)
lea    0x1(%rdi),%ebx
movslq %ebx,%rbx
mov    0x0(%r13,%rbx,8),%rbx
mov    (%rbx,%rcx,8),%rbx
movss  (%rbx,%rsi,4),%xmm0
mov    -0x8(%rdx,%rbp,8),%rbx
mov    (%rbx,%rcx,8),%rbx
movss  %xmm0,(%rbx,%rsi,4)
add    $0x2,%edi
lea    (%rax,%rbp,1),%rbx
add    $0xfffffffffffffffe,%rbx
add    $0xfffffffffffffffe,%rbp
cmp    $0xffffffffffffffff,%rbx
jne    2c30 <asg_vstep3d+0x1b20>
neg    %rbp
test   $0x1,%r15b
je     2c00 <asg_vstep3d+0x1af0>
lea    (%r14,%rbp,1),%edi
movslq %edi,%rdi
mov    0x0(%r13,%rdi,8),%rdi
mov    (%rdi,%rcx,8),%rdi
movss  (%rdi,%rsi,4),%xmm0
mov    0x90(%rsp),%rdi
sub    %rbp,%rdi
mov    0x0(%r13,%rdi,8),%rdi
mov    (%rdi,%rcx,8),%rdi
movss  %xmm0,(%rdi,%rsi,4)
jmp    2c00 <asg_vstep3d+0x1af0>
mov    0x98(%rsp),%rdx
movslq %edx,%r11
mov    0x1a0(%rsp),%rcx
movslq (%rcx),%r10
mov    0x1a8(%rsp),%rcx
mov    (%rcx),%r8d
lea    0x1(%rdx),%r14d
lea    0x1(%r8),%r12d
add    $0x1,%r9d
mov    0x1c0(%rsp),%r15d
add    $0xffffffffffffffff,%r15
lea    0x8(,%r11,8),%rcx
add    %r13,%rcx
mov    %r15,%rdi
and    $0xfffffffffffffffe,%rdi
neg    %rdi
jmp    2d2d <asg_vstep3d+0x1c1d>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rax
cmp    %eax,%r9d
je     1e37 <asg_vstep3d+0xd27>
cmp    %r8d,%r10d
jg     2d20 <asg_vstep3d+0x1c10>
mov    %r10,%rdx
jmp    2d49 <asg_vstep3d+0x1c39>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    %edx,%r12d
je     2d20 <asg_vstep3d+0x1c10>
cmpl   $0x2,0x1c0(%rsp)
02
jl     2d40 <asg_vstep3d+0x1c30>
mov    $0x1,%ebp
je     2dc5 <asg_vstep3d+0x1cb5>
mov    $0x1,%ebp
mov    0x98(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
movslq %esi,%rsi
mov    0x0(%r13,%rsi,8),%rbx
mov    (%rbx,%rax,8),%rbx
movss  (%rbx,%rdx,4),%xmm0
mov    -0x8(%rcx,%rbp,8),%rbx
mov    (%rbx,%rax,8),%rbx
movss  %xmm0,(%rbx,%rdx,4)
lea    -0x1(%rsi),%ebx
movslq %ebx,%rbx
mov    0x0(%r13,%rbx,8),%rbx
mov    (%rbx,%rax,8),%rbx
movss  (%rbx,%rdx,4),%xmm0
mov    (%rcx,%rbp,8),%rbx
mov    (%rbx,%rax,8),%rbx
movss  %xmm0,(%rbx,%rdx,4)
add    $0xfffffffe,%esi
lea    (%rdi,%rbp,1),%rbx
add    $0x2,%rbx
add    $0x2,%rbp
cmp    $0x1,%rbx
jne    2d70 <asg_vstep3d+0x1c60>
test   $0x1,%r15b
je     2d40 <asg_vstep3d+0x1c30>
mov    %r14d,%esi
sub    %ebp,%esi
movslq %esi,%rsi
mov    0x0(%r13,%rsi,8),%rsi
mov    (%rsi,%rax,8),%rsi
movss  (%rsi,%rdx,4),%xmm0
add    %r11,%rbp
mov    0x0(%r13,%rbp,8),%rsi
mov    (%rsi,%rax,8),%rsi
movss  %xmm0,(%rsi,%rdx,4)
jmp    2d40 <asg_vstep3d+0x1c30>

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

LLVM IR (-O2):
define void @asg_vstep3d(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* nocapture %14, i32* nocapture %15, i32* nocapture %16, i32* nocapture %17, i32 %18, float** noalias nocapture %19) {
%21 = getelementptr inbounds i32, i32* %10, i64 2
%22 = load i32, i32* %21
%23 = getelementptr inbounds i32, i32* %11, i64 2
%24 = load i32, i32* %23
%25 = icmp sgt i32 %22, %24
br i1 %25, label %305, label %26
26: ; preds = %20
%27 = getelementptr inbounds i32, i32* %10, i64 1
%28 = load i32, i32* %27
%29 = getelementptr inbounds i32, i32* %11, i64 1
%30 = load i32, i32* %29
%31 = icmp sgt i32 %28, %30
%32 = icmp sgt i32 %18, 0
%33 = sext i32 %28 to i64
%34 = add i32 %30, 1
%35 = sext i32 %22 to i64
%36 = add i32 %24, 1
%37 = zext i32 %18 to i64
br label %38
38: ; preds = %26, %301
%39 = phi i64 [ %35, %26 ], [ %302, %301 ]
br i1 %31, label %301, label %40
40: ; preds = %38
%41 = load i32, i32* %10
%42 = load i32, i32* %11
%43 = icmp slt i32 %42, %41
%44 = getelementptr inbounds float**, float*** %1, i64 %39
%45 = getelementptr inbounds float**, float*** %4, i64 %39
%46 = getelementptr inbounds float**, float*** %0, i64 %39
%47 = sext i32 %41 to i64
%48 = sub i32 %42, %41
%49 = zext i32 %48 to i64
%50 = shl nuw nsw i64 %49, 2
%51 = add nuw nsw i64 %50, 4
%52 = add i32 %42, 1
%53 = zext i32 %48 to i64
%54 = add nsw i64 %47, %53
%55 = sub i32 %42, %41
%56 = zext i32 %55 to i64
%57 = add nuw nsw i64 %56, 1
%58 = add i32 %41, 1
%59 = zext i32 %55 to i64
%60 = add nsw i64 %47, %59
%61 = add i32 %41, 1
%62 = sub i32 %42, %41
%63 = zext i32 %62 to i64
%64 = add nuw nsw i64 %63, 1
%65 = icmp ult i32 %62, 7
%66 = and i64 %64, 8589934584
%67 = add nsw i64 %66, %47
%68 = icmp eq i64 %64, %66
%69 = icmp ult i32 %55, 3
%70 = and i64 %57, 8589934588
%71 = add nsw i64 %70, %47
%72 = icmp eq i64 %57, %70
br label %73
73: ; preds = %40, %297
%74 = phi i64 [ %33, %40 ], [ %298, %297 ]
br i1 %43, label %79, label %75
75: ; preds = %73
%76 = load float*, float** %9
%77 = getelementptr float, float* %76, i64 %47
%78 = bitcast float* %77 to i8*
br label %79
79: ; preds = %75, %73
br i1 %32, label %160, label %80
80: ; preds = %267, %79
br i1 %43, label %297, label %81
81: ; preds = %80
%82 = load float*, float** %8
%83 = load float**, float*** %45
%84 = getelementptr inbounds float*, float** %83, i64 %74
%85 = load float*, float** %84
%86 = load float*, float** %7
%87 = load float**, float*** %46
%88 = getelementptr inbounds float*, float** %87, i64 %74
%89 = load float*, float** %88
%90 = load float*, float** %9
br i1 %69, label %158, label %91
91: ; preds = %81
%92 = getelementptr float, float* %85, i64 %47
%93 = getelementptr float, float* %85, i64 1
%94 = getelementptr float, float* %93, i64 %54
%95 = getelementptr float, float* %82, i64 %47
%96 = getelementptr float, float* %82, i64 1
%97 = getelementptr float, float* %96, i64 %54
%98 = getelementptr float, float* %86, i64 %47
%99 = getelementptr float, float* %86, i64 1
%100 = getelementptr float, float* %99, i64 %54
%101 = getelementptr float, float* %89, i64 %47
%102 = getelementptr float, float* %89, i64 2
%103 = getelementptr float, float* %102, i64 %54
%104 = getelementptr float, float* %90, i64 %47
%105 = getelementptr float, float* %90, i64 1
%106 = getelementptr float, float* %105, i64 %54
%107 = icmp ult float* %92, %97
%108 = icmp ult float* %95, %94
%109 = and i1 %107, %108
%110 = icmp ult float* %92, %100
%111 = icmp ult float* %98, %94
%112 = and i1 %110, %111
%113 = or i1 %109, %112
%114 = icmp ult float* %92, %103
%115 = icmp ult float* %101, %94
%116 = and i1 %114, %115
%117 = or i1 %113, %116
%118 = icmp ult float* %92, %106
%119 = icmp ult float* %104, %94
%120 = and i1 %118, %119
%121 = or i1 %117, %120
br i1 %121, label %158, label %122
122: ; preds = %91, %122
%123 = phi i64 [ %155, %122 ], [ 0, %91 ]
%124 = add i64 %123, %47
%125 = getelementptr inbounds float, float* %82, i64 %124
%126 = bitcast float* %125 to <4 x float>*
%127 = load <4 x float>, <4 x float>* %126
%128 = fpext <4 x float> %127 to <4 x double>
%129 = getelementptr inbounds float, float* %85, i64 %124
%130 = bitcast float* %129 to <4 x float>*
%131 = load <4 x float>, <4 x float>* %130
%132 = getelementptr inbounds float, float* %86, i64 %124
%133 = bitcast float* %132 to <4 x float>*
%134 = load <4 x float>, <4 x float>* %133
%135 = fmul <4 x float> %131, %134
%136 = fpext <4 x float> %135 to <4 x double>
%137 = getelementptr inbounds float, float* %89, i64 %124
%138 = bitcast float* %137 to <4 x float>*
%139 = load <4 x float>, <4 x float>* %138
%140 = add nsw i64 %124, 1
%141 = getelementptr inbounds float, float* %89, i64 %140
%142 = bitcast float* %141 to <4 x float>*
%143 = load <4 x float>, <4 x float>* %142
%144 = fadd <4 x float> %139, %143
%145 = fpext <4 x float> %144 to <4 x double>
%146 = getelementptr inbounds float, float* %90, i64 %124
%147 = bitcast float* %146 to <4 x float>*
%148 = load <4 x float>, <4 x float>* %147
%149 = fpext <4 x float> %148 to <4 x double>
%150 = fmul <4 x double> %145, <double -5.000000e-01, double -5.000000e-01, double -5.000000e-01, double -5.000000e-01>
%151 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %150, <4 x double> %149, <4 x double> %136)
%152 = fmul <4 x double> %151, %128
%153 = fptrunc <4 x double> %152 to <4 x float>
%154 = bitcast float* %129 to <4 x float>*
store <4 x float> %153, <4 x float>* %154
%155 = add nuw i64 %123, 4
%156 = icmp eq i64 %155, %70
br i1 %156, label %157, label %122
157: ; preds = %122
br i1 %72, label %297, label %158
158: ; preds = %91, %81, %157
%159 = phi i64 [ %47, %91 ], [ %47, %81 ], [ %71, %157 ]
br label %270
160: ; preds = %79, %267
%161 = phi i64 [ %268, %267 ], [ 0, %79 ]
br i1 %43, label %162, label %164
162: ; preds = %160
%163 = add nuw nsw i64 %161, 1
br label %267
164: ; preds = %160
%165 = load float*, float** %19
%166 = getelementptr inbounds float, float* %165, i64 %161
%167 = load float**, float*** %44
%168 = getelementptr inbounds float*, float** %167, i64 %74
%169 = load float*, float** %168
%170 = add nuw nsw i64 %161, 1
%171 = load float*, float** %9
br i1 %65, label %247, label %172
172: ; preds = %164
%173 = trunc i64 %161 to i32
%174 = add i32 %58, %173
%175 = add i32 %174, %55
%176 = icmp slt i32 %175, %174
br i1 %176, label %247, label %177
177: ; preds = %172
%178 = getelementptr float, float* %171, i64 %47
%179 = getelementptr float, float* %171, i64 1
%180 = getelementptr float, float* %179, i64 %60
%181 = getelementptr float, float* %165, i64 1
%182 = getelementptr float, float* %181, i64 %161
%183 = getelementptr float, float* %169, i64 %47
%184 = sub i64 0, %161
%185 = getelementptr float, float* %183, i64 %184
%186 = getelementptr float, float* %169, i64 1
%187 = getelementptr float, float* %186, i64 %60
%188 = getelementptr float, float* %187, i64 %184
%189 = trunc i64 %161 to i32
%190 = add i32 %61, %189
%191 = sext i32 %190 to i64
%192 = getelementptr float, float* %169, i64 %191
%193 = getelementptr float, float* %169, i64 1
%194 = getelementptr float, float* %193, i64 %59
%195 = getelementptr float, float* %194, i64 %191
%196 = icmp ult float* %178, %182
%197 = icmp ult float* %166, %180
%198 = and i1 %196, %197
%199 = icmp ult float* %178, %188
%200 = icmp ult float* %185, %180
%201 = and i1 %199, %200
%202 = or i1 %198, %201
%203 = icmp ult float* %178, %195
%204 = icmp ult float* %192, %180
%205 = and i1 %203, %204
%206 = or i1 %202, %205
br i1 %206, label %247, label %207
207: ; preds = %177
%208 = load float, float* %166
%209 = insertelement <4 x float> poison, float %208, i64 0
%210 = shufflevector <4 x float> %209, <4 x float> poison, <4 x i32> zeroinitializer
%211 = insertelement <4 x float> poison, float %208, i64 0
%212 = shufflevector <4 x float> %211, <4 x float> poison, <4 x i32> zeroinitializer
br label %213
213: ; preds = %213, %207
%214 = phi i64 [ 0, %207 ], [ %244, %213 ]
%215 = add i64 %214, %47
%216 = add i64 %170, %215
%217 = shl i64 %216, 32
%218 = ashr exact i64 %217, 32
%219 = getelementptr inbounds float, float* %169, i64 %218
%220 = bitcast float* %219 to <4 x float>*
%221 = load <4 x float>, <4 x float>* %220
%222 = getelementptr inbounds float, float* %219, i64 4
%223 = bitcast float* %222 to <4 x float>*
%224 = load <4 x float>, <4 x float>* %223
%225 = sub nsw i64 %215, %161
%226 = getelementptr inbounds float, float* %169, i64 %225
%227 = bitcast float* %226 to <4 x float>*
%228 = load <4 x float>, <4 x float>* %227
%229 = getelementptr inbounds float, float* %226, i64 4
%230 = bitcast float* %229 to <4 x float>*
%231 = load <4 x float>, <4 x float>* %230
%232 = fsub <4 x float> %221, %228
%233 = fsub <4 x float> %224, %231
%234 = getelementptr inbounds float, float* %171, i64 %215
%235 = bitcast float* %234 to <4 x float>*
%236 = load <4 x float>, <4 x float>* %235
%237 = getelementptr inbounds float, float* %234, i64 4
%238 = bitcast float* %237 to <4 x float>*
%239 = load <4 x float>, <4 x float>* %238
%240 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %210, <4 x float> %232, <4 x float> %236)
%241 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %212, <4 x float> %233, <4 x float> %239)
%242 = bitcast float* %234 to <4 x float>*
store <4 x float> %240, <4 x float>* %242
%243 = bitcast float* %237 to <4 x float>*
store <4 x float> %241, <4 x float>* %243
%244 = add nuw i64 %214, 8
%245 = icmp eq i64 %244, %66
br i1 %245, label %246, label %213
246: ; preds = %213
br i1 %68, label %267, label %247
247: ; preds = %177, %172, %164, %246
%248 = phi i64 [ %47, %177 ], [ %47, %172 ], [ %47, %164 ], [ %67, %246 ]
br label %249
249: ; preds = %247, %249
%250 = phi i64 [ %264, %249 ], [ %248, %247 ]
%251 = load float, float* %166
%252 = add i64 %170, %250
%253 = shl i64 %252, 32
%254 = ashr exact i64 %253, 32
%255 = getelementptr inbounds float, float* %169, i64 %254
%256 = load float, float* %255
%257 = sub nsw i64 %250, %161
%258 = getelementptr inbounds float, float* %169, i64 %257
%259 = load float, float* %258
%260 = fsub float %256, %259
%261 = getelementptr inbounds float, float* %171, i64 %250
%262 = load float, float* %261
%263 = tail call float @llvm.fmuladd.f32(float %251, float %260, float %262)
store float %263, float* %261
%264 = add nsw i64 %250, 1
%265 = trunc i64 %264 to i32
%266 = icmp eq i32 %52, %265
br i1 %266, label %267, label %249
267: ; preds = %249, %246, %162
%268 = phi i64 [ %163, %162 ], [ %170, %246 ], [ %170, %249 ]
%269 = icmp eq i64 %268, %37
br i1 %269, label %80, label %160
270: ; preds = %158, %270
%271 = phi i64 [ %283, %270 ], [ %159, %158 ]
%272 = getelementptr inbounds float, float* %82, i64 %271
%273 = load float, float* %272
%274 = fpext float %273 to double
%275 = getelementptr inbounds float, float* %85, i64 %271
%276 = load float, float* %275
%277 = getelementptr inbounds float, float* %86, i64 %271
%278 = load float, float* %277
%279 = fmul float %276, %278
%280 = fpext float %279 to double
%281 = getelementptr inbounds float, float* %89, i64 %271
%282 = load float, float* %281
%283 = add nsw i64 %271, 1
%284 = getelementptr inbounds float, float* %89, i64 %283
%285 = load float, float* %284
%286 = fadd float %282, %285
%287 = fpext float %286 to double
%288 = getelementptr inbounds float, float* %90, i64 %271
%289 = load float, float* %288
%290 = fpext float %289 to double
%291 = fmul double %287, -5.000000e-01
%292 = tail call double @llvm.fmuladd.f64(double %291, double %290, double %280)
%293 = fmul double %292, %274
%294 = fptrunc double %293 to float
store float %294, float* %275
%295 = trunc i64 %283 to i32
%296 = icmp eq i32 %52, %295
br i1 %296, label %297, label %270
297: ; preds = %270, %157, %80
%298 = add nsw i64 %74, 1
%299 = trunc i64 %298 to i32
%300 = icmp eq i32 %34, %299
br i1 %300, label %301, label %73
301: ; preds = %297, %38
%302 = add nsw i64 %39, 1
%303 = trunc i64 %302 to i32
%304 = icmp eq i32 %36, %303
br i1 %304, label %305, label %38
305: ; preds = %301, %20
%306 = getelementptr inbounds i32, i32* %12, i64 2
%307 = load i32, i32* %306
%308 = getelementptr inbounds i32, i32* %13, i64 2
%309 = load i32, i32* %308
%310 = icmp sgt i32 %307, %309
br i1 %310, label %615, label %311
311: ; preds = %305
%312 = getelementptr inbounds i32, i32* %12, i64 1
%313 = load i32, i32* %312
%314 = getelementptr inbounds i32, i32* %13, i64 1
%315 = load i32, i32* %314
%316 = icmp sgt i32 %313, %315
%317 = getelementptr inbounds float*, float** %9, i64 1
%318 = icmp sgt i32 %18, 0
%319 = getelementptr inbounds float*, float** %19, i64 1
%320 = getelementptr inbounds float*, float** %8, i64 1
%321 = getelementptr inbounds float*, float** %7, i64 1
%322 = sext i32 %313 to i64
%323 = add i32 %315, 1
%324 = sext i32 %307 to i64
%325 = add i32 %309, 1
%326 = zext i32 %18 to i64
br label %327
327: ; preds = %311, %611
%328 = phi i64 [ %324, %311 ], [ %612, %611 ]
br i1 %316, label %611, label %329
329: ; preds = %327
%330 = load i32, i32* %12
%331 = load i32, i32* %13
%332 = icmp slt i32 %331, %330
%333 = getelementptr inbounds float**, float*** %2, i64 %328
%334 = getelementptr inbounds float**, float*** %5, i64 %328
%335 = getelementptr inbounds float**, float*** %0, i64 %328
%336 = sext i32 %330 to i64
%337 = sub i32 %331, %330
%338 = zext i32 %337 to i64
%339 = shl nuw nsw i64 %338, 2
%340 = add nuw nsw i64 %339, 4
%341 = add i32 %331, 1
%342 = zext i32 %337 to i64
%343 = add nsw i64 %336, %342
%344 = sub i32 %331, %330
%345 = zext i32 %344 to i64
%346 = add nuw nsw i64 %345, 1
%347 = zext i32 %344 to i64
%348 = add nsw i64 %336, %347
%349 = zext i32 %344 to i64
%350 = add nuw nsw i64 %349, 1
%351 = add i32 %331, 1
%352 = icmp ult i32 %344, 7
%353 = and i64 %350, 8589934584
%354 = add nsw i64 %353, %336
%355 = icmp eq i64 %350, %353
%356 = icmp ult i32 %344, 3
%357 = and i64 %346, 8589934588
%358 = add nsw i64 %357, %336
%359 = icmp eq i64 %346, %357
br label %360
360: ; preds = %329, %607
%361 = phi i64 [ %322, %329 ], [ %608, %607 ]
br i1 %332, label %366, label %362
362: ; preds = %360
%363 = load float*, float** %317
%364 = getelementptr float, float* %363, i64 %336
%365 = bitcast float* %364 to i8*
br label %366
366: ; preds = %362, %360
br i1 %318, label %367, label %369
367: ; preds = %366
%368 = add i64 %361, 1
br label %461
369: ; preds = %579, %366
br i1 %332, label %370, label %372
370: ; preds = %369
%371 = add nsw i64 %361, 1
br label %607
372: ; preds = %369
%373 = load float*, float** %320
%374 = getelementptr inbounds float, float* %373, i64 %361
%375 = load float**, float*** %334
%376 = getelementptr inbounds float*, float** %375, i64 %361
%377 = load float*, float** %376
%378 = load float*, float** %321
%379 = getelementptr inbounds float, float* %378, i64 %361
%380 = load float**, float*** %335
%381 = getelementptr inbounds float*, float** %380, i64 %361
%382 = load float*, float** %381
%383 = add nsw i64 %361, 1
%384 = getelementptr inbounds float*, float** %380, i64 %383
%385 = load float*, float** %384
%386 = load float*, float** %317
br i1 %356, label %459, label %387
387: ; preds = %372
%388 = getelementptr float, float* %377, i64 %336
%389 = getelementptr float, float* %377, i64 1
%390 = getelementptr float, float* %389, i64 %343
%391 = getelementptr float, float* %373, i64 1
%392 = getelementptr float, float* %391, i64 %361
%393 = getelementptr float, float* %378, i64 1
%394 = getelementptr float, float* %393, i64 %361
%395 = getelementptr float, float* %382, i64 %336
%396 = getelementptr float, float* %382, i64 1
%397 = getelementptr float, float* %396, i64 %343
%398 = getelementptr float, float* %385, i64 %336
%399 = getelementptr float, float* %385, i64 1
%400 = getelementptr float, float* %399, i64 %343
%401 = getelementptr float, float* %386, i64 %336
%402 = getelementptr float, float* %386, i64 1
%403 = getelementptr float, float* %402, i64 %343
%404 = icmp ult float* %388, %392
%405 = icmp ult float* %374, %390
%406 = and i1 %404, %405
%407 = icmp ult float* %388, %394
%408 = icmp ult float* %379, %390
%409 = and i1 %407, %408
%410 = or i1 %406, %409
%411 = icmp ult float* %388, %397
%412 = icmp ult float* %395, %390
%413 = and i1 %411, %412
%414 = or i1 %410, %413
%415 = icmp ult float* %388, %400
%416 = icmp ult float* %398, %390
%417 = and i1 %415, %416
%418 = or i1 %414, %417
%419 = icmp ult float* %388, %403
%420 = icmp ult float* %401, %390
%421 = and i1 %419, %420
%422 = or i1 %418, %421
br i1 %422, label %459, label %423
423: ; preds = %387
%424 = load float, float* %374
%425 = insertelement <4 x float> poison, float %424, i64 0
%426 = shufflevector <4 x float> %425, <4 x float> poison, <4 x i32> zeroinitializer
%427 = fpext <4 x float> %426 to <4 x double>
%428 = load float, float* %379
%429 = insertelement <4 x float> poison, float %428, i64 0
%430 = shufflevector <4 x float> %429, <4 x float> poison, <4 x i32> zeroinitializer
br label %431
431: ; preds = %431, %423
%432 = phi i64 [ 0, %423 ], [ %456, %431 ]
%433 = add i64 %432, %336
%434 = getelementptr inbounds float, float* %377, i64 %433
%435 = bitcast float* %434 to <4 x float>*
%436 = load <4 x float>, <4 x float>* %435
%437 = fmul <4 x float> %436, %430
%438 = fpext <4 x float> %437 to <4 x double>
%439 = getelementptr inbounds float, float* %382, i64 %433
%440 = bitcast float* %439 to <4 x float>*
%441 = load <4 x float>, <4 x float>* %440
%442 = getelementptr inbounds float, float* %385, i64 %433
%443 = bitcast float* %442 to <4 x float>*
%444 = load <4 x float>, <4 x float>* %443
%445 = fadd <4 x float> %441, %444
%446 = fpext <4 x float> %445 to <4 x double>
%447 = getelementptr inbounds float, float* %386, i64 %433
%448 = bitcast float* %447 to <4 x float>*
%449 = load <4 x float>, <4 x float>* %448
%450 = fpext <4 x float> %449 to <4 x double>
%451 = fmul <4 x double> %446, <double -5.000000e-01, double -5.000000e-01, double -5.000000e-01, double -5.000000e-01>
%452 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %451, <4 x double> %450, <4 x double> %438)
%453 = fmul <4 x double> %452, %427
%454 = fptrunc <4 x double> %453 to <4 x float>
%455 = bitcast float* %434 to <4 x float>*
store <4 x float> %454, <4 x float>* %455
%456 = add nuw i64 %432, 4
%457 = icmp eq i64 %456, %357
br i1 %457, label %458, label %431
458: ; preds = %431
br i1 %359, label %607, label %459
459: ; preds = %387, %372, %458
%460 = phi i64 [ %336, %387 ], [ %336, %372 ], [ %358, %458 ]
br label %582
461: ; preds = %367, %579
%462 = phi i64 [ 0, %367 ], [ %580, %579 ]
%463 = add nuw i64 %462, 1
br i1 %332, label %579, label %464
464: ; preds = %461
%465 = load float*, float** %319
%466 = getelementptr inbounds float, float* %465, i64 %462
%467 = load float**, float*** %333
%468 = add i64 %368, %462
%469 = shl i64 %468, 32
%470 = ashr exact i64 %469, 32
%471 = getelementptr inbounds float*, float** %467, i64 %470
%472 = load float*, float** %471
%473 = sub nsw i64 %361, %462
%474 = getelementptr inbounds float*, float** %467, i64 %473
%475 = load float*, float** %474
%476 = load float*, float** %317
br i1 %352, label %535, label %477
477: ; preds = %464
%478 = getelementptr float, float* %476, i64 %336
%479 = getelementptr float, float* %476, i64 1
%480 = getelementptr float, float* %479, i64 %348
%481 = getelementptr float, float* %465, i64 %463
%482 = getelementptr float, float* %472, i64 %336
%483 = getelementptr float, float* %472, i64 1
%484 = getelementptr float, float* %483, i64 %348
%485 = getelementptr float, float* %475, i64 %336
%486 = getelementptr float, float* %475, i64 1
%487 = getelementptr float, float* %486, i64 %348
%488 = icmp ult float* %478, %481
%489 = icmp ult float* %466, %480
%490 = and i1 %488, %489
%491 = icmp ult float* %478, %484
%492 = icmp ult float* %482, %480
%493 = and i1 %491, %492
%494 = or i1 %490, %493
%495 = icmp ult float* %478, %487
%496 = icmp ult float* %485, %480
%497 = and i1 %495, %496
%498 = or i1 %494, %497
br i1 %498, label %535, label %499
499: ; preds = %477
%500 = load float, float* %466
%501 = insertelement <4 x float> poison, float %500, i64 0
%502 = shufflevector <4 x float> %501, <4 x float> poison, <4 x i32> zeroinitializer
%503 = insertelement <4 x float> poison, float %500, i64 0
%504 = shufflevector <4 x float> %503, <4 x float> poison, <4 x i32> zeroinitializer
br label %505
505: ; preds = %505, %499
%506 = phi i64 [ 0, %499 ], [ %532, %505 ]
%507 = add i64 %506, %336
%508 = getelementptr inbounds float, float* %472, i64 %507
%509 = bitcast float* %508 to <4 x float>*
%510 = load <4 x float>, <4 x float>* %509
%511 = getelementptr inbounds float, float* %508, i64 4
%512 = bitcast float* %511 to <4 x float>*
%513 = load <4 x float>, <4 x float>* %512
%514 = getelementptr inbounds float, float* %475, i64 %507
%515 = bitcast float* %514 to <4 x float>*
%516 = load <4 x float>, <4 x float>* %515
%517 = getelementptr inbounds float, float* %514, i64 4
%518 = bitcast float* %517 to <4 x float>*
%519 = load <4 x float>, <4 x float>* %518
%520 = fsub <4 x float> %510, %516
%521 = fsub <4 x float> %513, %519
%522 = getelementptr inbounds float, float* %476, i64 %507
%523 = bitcast float* %522 to <4 x float>*
%524 = load <4 x float>, <4 x float>* %523
%525 = getelementptr inbounds float, float* %522, i64 4
%526 = bitcast float* %525 to <4 x float>*
%527 = load <4 x float>, <4 x float>* %526
%528 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %502, <4 x float> %520, <4 x float> %524)
%529 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %504, <4 x float> %521, <4 x float> %527)
%530 = bitcast float* %522 to <4 x float>*
store <4 x float> %528, <4 x float>* %530
%531 = bitcast float* %525 to <4 x float>*
store <4 x float> %529, <4 x float>* %531
%532 = add nuw i64 %506, 8
%533 = icmp eq i64 %532, %353
br i1 %533, label %534, label %505
534: ; preds = %505
br i1 %355, label %579, label %535
535: ; preds = %477, %464, %534
%536 = phi i64 [ %336, %477 ], [ %336, %464 ], [ %354, %534 ]
%537 = trunc i64 %536 to i32
%538 = sub i32 %351, %537
%539 = and i32 %538, 1
%540 = icmp eq i32 %539, 0
br i1 %540, label %552, label %541
541: ; preds = %535
%542 = load float, float* %466
%543 = getelementptr inbounds float, float* %472, i64 %536
%544 = load float, float* %543
%545 = getelementptr inbounds float, float* %475, i64 %536
%546 = load float, float* %545
%547 = fsub float %544, %546
%548 = getelementptr inbounds float, float* %476, i64 %536
%549 = load float, float* %548
%550 = tail call float @llvm.fmuladd.f32(float %542, float %547, float %549)
store float %550, float* %548
%551 = add nsw i64 %536, 1
br label %552
552: ; preds = %541, %535
%553 = phi i64 [ %536, %535 ], [ %551, %541 ]
%554 = icmp eq i32 %331, %537
br i1 %554, label %579, label %555
555: ; preds = %552, %555
%556 = phi i64 [ %576, %555 ], [ %553, %552 ]
%557 = load float, float* %466
%558 = getelementptr inbounds float, float* %472, i64 %556
%559 = load float, float* %558
%560 = getelementptr inbounds float, float* %475, i64 %556
%561 = load float, float* %560
%562 = fsub float %559, %561
%563 = getelementptr inbounds float, float* %476, i64 %556
%564 = load float, float* %563
%565 = tail call float @llvm.fmuladd.f32(float %557, float %562, float %564)
store float %565, float* %563
%566 = add nsw i64 %556, 1
%567 = load float, float* %466
%568 = getelementptr inbounds float, float* %472, i64 %566
%569 = load float, float* %568
%570 = getelementptr inbounds float, float* %475, i64 %566
%571 = load float, float* %570
%572 = fsub float %569, %571
%573 = getelementptr inbounds float, float* %476, i64 %566
%574 = load float, float* %573
%575 = tail call float @llvm.fmuladd.f32(float %567, float %572, float %574)
store float %575, float* %573
%576 = add nsw i64 %556, 2
%577 = trunc i64 %576 to i32
%578 = icmp eq i32 %341, %577
br i1 %578, label %579, label %555
579: ; preds = %552, %555, %534, %461
%580 = add nuw nsw i64 %462, 1
%581 = icmp eq i64 %580, %326
br i1 %581, label %369, label %461
582: ; preds = %459, %582
%583 = phi i64 [ %604, %582 ], [ %460, %459 ]
%584 = load float, float* %374
%585 = fpext float %584 to double
%586 = getelementptr inbounds float, float* %377, i64 %583
%587 = load float, float* %586
%588 = load float, float* %379
%589 = fmul float %587, %588
%590 = fpext float %589 to double
%591 = getelementptr inbounds float, float* %382, i64 %583
%592 = load float, float* %591
%593 = getelementptr inbounds float, float* %385, i64 %583
%594 = load float, float* %593
%595 = fadd float %592, %594
%596 = fpext float %595 to double
%597 = getelementptr inbounds float, float* %386, i64 %583
%598 = load float, float* %597
%599 = fpext float %598 to double
%600 = fmul double %596, -5.000000e-01
%601 = tail call double @llvm.fmuladd.f64(double %600, double %599, double %590)
%602 = fmul double %601, %585
%603 = fptrunc double %602 to float
store float %603, float* %586
%604 = add nsw i64 %583, 1
%605 = trunc i64 %604 to i32
%606 = icmp eq i32 %341, %605
br i1 %606, label %607, label %582
607: ; preds = %582, %458, %370
%608 = phi i64 [ %371, %370 ], [ %383, %458 ], [ %383, %582 ]
%609 = trunc i64 %608 to i32
%610 = icmp eq i32 %323, %609
br i1 %610, label %611, label %360
611: ; preds = %607, %327
%612 = add nsw i64 %328, 1
%613 = trunc i64 %612 to i32
%614 = icmp eq i32 %325, %613
br i1 %614, label %615, label %327
615: ; preds = %611, %305
%616 = getelementptr inbounds i32, i32* %14, i64 2
%617 = load i32, i32* %616
%618 = getelementptr inbounds i32, i32* %15, i64 2
%619 = load i32, i32* %618
%620 = icmp sgt i32 %617, %619
br i1 %620, label %928, label %621
621: ; preds = %615
%622 = getelementptr inbounds i32, i32* %14, i64 1
%623 = load i32, i32* %622
%624 = getelementptr inbounds i32, i32* %15, i64 1
%625 = load i32, i32* %624
%626 = icmp sgt i32 %623, %625
%627 = getelementptr inbounds float*, float** %9, i64 2
%628 = icmp sgt i32 %18, 0
%629 = getelementptr inbounds float*, float** %19, i64 2
%630 = getelementptr inbounds float*, float** %8, i64 2
%631 = getelementptr inbounds float*, float** %7, i64 2
%632 = sext i32 %623 to i64
%633 = add i32 %625, 1
%634 = sext i32 %617 to i64
%635 = add i32 %619, 1
%636 = zext i32 %18 to i64
br label %637
637: ; preds = %621, %924
%638 = phi i64 [ %634, %621 ], [ %925, %924 ]
br i1 %626, label %639, label %641
639: ; preds = %637
%640 = add nsw i64 %638, 1
br label %924
641: ; preds = %637
%642 = load i32, i32* %14
%643 = load i32, i32* %15
%644 = icmp slt i32 %643, %642
%645 = add i64 %638, 1
%646 = getelementptr inbounds float**, float*** %6, i64 %638
%647 = getelementptr inbounds float**, float*** %0, i64 %638
%648 = add nsw i64 %638, 1
%649 = getelementptr inbounds float**, float*** %0, i64 %648
%650 = sext i32 %642 to i64
%651 = sub i32 %643, %642
%652 = zext i32 %651 to i64
%653 = shl nuw nsw i64 %652, 2
%654 = add nuw nsw i64 %653, 4
%655 = add i32 %643, 1
%656 = zext i32 %651 to i64
%657 = add nsw i64 %650, %656
%658 = sub i32 %643, %642
%659 = zext i32 %658 to i64
%660 = add nuw nsw i64 %659, 1
%661 = zext i32 %658 to i64
%662 = add nsw i64 %650, %661
%663 = zext i32 %658 to i64
%664 = add nuw nsw i64 %663, 1
%665 = add i32 %643, 1
%666 = icmp ult i32 %658, 7
%667 = and i64 %664, 8589934584
%668 = add nsw i64 %667, %650
%669 = icmp eq i64 %664, %667
%670 = icmp ult i32 %658, 3
%671 = and i64 %660, 8589934588
%672 = add nsw i64 %671, %650
%673 = icmp eq i64 %660, %671
br label %674
674: ; preds = %641, %920
%675 = phi i64 [ %632, %641 ], [ %921, %920 ]
br i1 %644, label %680, label %676
676: ; preds = %674
%677 = load float*, float** %627
%678 = getelementptr float, float* %677, i64 %650
%679 = bitcast float* %678 to i8*
br label %680
680: ; preds = %676, %674
br i1 %628, label %771, label %681
681: ; preds = %892, %680
br i1 %644, label %920, label %682
682: ; preds = %681
%683 = load float*, float** %630
%684 = getelementptr inbounds float, float* %683, i64 %638
%685 = load float**, float*** %646
%686 = getelementptr inbounds float*, float** %685, i64 %675
%687 = load float*, float** %686
%688 = load float*, float** %631
%689 = getelementptr inbounds float, float* %688, i64 %638
%690 = load float**, float*** %647
%691 = getelementptr inbounds float*, float** %690, i64 %675
%692 = load float*, float** %691
%693 = load float**, float*** %649
%694 = getelementptr inbounds float*, float** %693, i64 %675
%695 = load float*, float** %694
%696 = load float*, float** %627
br i1 %670, label %769, label %697
697: ; preds = %682
%698 = getelementptr float, float* %687, i64 %650
%699 = getelementptr float, float* %687, i64 1
%700 = getelementptr float, float* %699, i64 %657
%701 = getelementptr float, float* %683, i64 1
%702 = getelementptr float, float* %701, i64 %638
%703 = getelementptr float, float* %688, i64 1
%704 = getelementptr float, float* %703, i64 %638
%705 = getelementptr float, float* %692, i64 %650
%706 = getelementptr float, float* %692, i64 1
%707 = getelementptr float, float* %706, i64 %657
%708 = getelementptr float, float* %695, i64 %650
%709 = getelementptr float, float* %695, i64 1
%710 = getelementptr float, float* %709, i64 %657
%711 = getelementptr float, float* %696, i64 %650
%712 = getelementptr float, float* %696, i64 1
%713 = getelementptr float, float* %712, i64 %657
%714 = icmp ult float* %698, %702
%715 = icmp ult float* %684, %700
%716 = and i1 %714, %715
%717 = icmp ult float* %698, %704
%718 = icmp ult float* %689, %700
%719 = and i1 %717, %718
%720 = or i1 %716, %719
%721 = icmp ult float* %698, %707
%722 = icmp ult float* %705, %700
%723 = and i1 %721, %722
%724 = or i1 %720, %723
%725 = icmp ult float* %698, %710
%726 = icmp ult float* %708, %700
%727 = and i1 %725, %726
%728 = or i1 %724, %727
%729 = icmp ult float* %698, %713
%730 = icmp ult float* %711, %700
%731 = and i1 %729, %730
%732 = or i1 %728, %731
br i1 %732, label %769, label %733
733: ; preds = %697
%734 = load float, float* %684
%735 = insertelement <4 x float> poison, float %734, i64 0
%736 = shufflevector <4 x float> %735, <4 x float> poison, <4 x i32> zeroinitializer
%737 = fpext <4 x float> %736 to <4 x double>
%738 = load float, float* %689
%739 = insertelement <4 x float> poison, float %738, i64 0
%740 = shufflevector <4 x float> %739, <4 x float> poison, <4 x i32> zeroinitializer
br label %741
741: ; preds = %741, %733
%742 = phi i64 [ 0, %733 ], [ %766, %741 ]
%743 = add i64 %742, %650
%744 = getelementptr inbounds float, float* %687, i64 %743
%745 = bitcast float* %744 to <4 x float>*
%746 = load <4 x float>, <4 x float>* %745
%747 = fmul <4 x float> %746, %740
%748 = fpext <4 x float> %747 to <4 x double>
%749 = getelementptr inbounds float, float* %692, i64 %743
%750 = bitcast float* %749 to <4 x float>*
%751 = load <4 x float>, <4 x float>* %750
%752 = getelementptr inbounds float, float* %695, i64 %743
%753 = bitcast float* %752 to <4 x float>*
%754 = load <4 x float>, <4 x float>* %753
%755 = fadd <4 x float> %751, %754
%756 = fpext <4 x float> %755 to <4 x double>
%757 = getelementptr inbounds float, float* %696, i64 %743
%758 = bitcast float* %757 to <4 x float>*
%759 = load <4 x float>, <4 x float>* %758
%760 = fpext <4 x float> %759 to <4 x double>
%761 = fmul <4 x double> %756, <double -5.000000e-01, double -5.000000e-01, double -5.000000e-01, double -5.000000e-01>
%762 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %761, <4 x double> %760, <4 x double> %748)
%763 = fmul <4 x double> %762, %737
%764 = fptrunc <4 x double> %763 to <4 x float>
%765 = bitcast float* %744 to <4 x float>*
store <4 x float> %764, <4 x float>* %765
%766 = add nuw i64 %742, 4
%767 = icmp eq i64 %766, %671
br i1 %767, label %768, label %741
768: ; preds = %741
br i1 %673, label %920, label %769
769: ; preds = %697, %682, %768
%770 = phi i64 [ %650, %697 ], [ %650, %682 ], [ %672, %768 ]
br label %895
771: ; preds = %680, %892
%772 = phi i64 [ %893, %892 ], [ 0, %680 ]
%773 = add nuw i64 %772, 1
br i1 %644, label %892, label %774
774: ; preds = %771
%775 = load float*, float** %629
%776 = getelementptr inbounds float, float* %775, i64 %772
%777 = add i64 %645, %772
%778 = shl i64 %777, 32
%779 = ashr exact i64 %778, 32
%780 = getelementptr inbounds float**, float*** %3, i64 %779
%781 = load float**, float*** %780
%782 = getelementptr inbounds float*, float** %781, i64 %675
%783 = load float*, float** %782
%784 = sub nsw i64 %638, %772
%785 = getelementptr inbounds float**, float*** %3, i64 %784
%786 = load float**, float*** %785
%787 = getelementptr inbounds float*, float** %786, i64 %675
%788 = load float*, float** %787
%789 = load float*, float** %627
br i1 %666, label %848, label %790
790: ; preds = %774
%791 = getelementptr float, float* %789, i64 %650
%792 = getelementptr float, float* %789, i64 1
%793 = getelementptr float, float* %792, i64 %662
%794 = getelementptr float, float* %775, i64 %773
%795 = getelementptr float, float* %783, i64 %650
%796 = getelementptr float, float* %783, i64 1
%797 = getelementptr float, float* %796, i64 %662
%798 = getelementptr float, float* %788, i64 %650
%799 = getelementptr float, float* %788, i64 1
%800 = getelementptr float, float* %799, i64 %662
%801 = icmp ult float* %791, %794
%802 = icmp ult float* %776, %793
%803 = and i1 %801, %802
%804 = icmp ult float* %791, %797
%805 = icmp ult float* %795, %793
%806 = and i1 %804, %805
%807 = or i1 %803, %806
%808 = icmp ult float* %791, %800
%809 = icmp ult float* %798, %793
%810 = and i1 %808, %809
%811 = or i1 %807, %810
br i1 %811, label %848, label %812
812: ; preds = %790
%813 = load float, float* %776
%814 = insertelement <4 x float> poison, float %813, i64 0
%815 = shufflevector <4 x float> %814, <4 x float> poison, <4 x i32> zeroinitializer
%816 = insertelement <4 x float> poison, float %813, i64 0
%817 = shufflevector <4 x float> %816, <4 x float> poison, <4 x i32> zeroinitializer
br label %818
818: ; preds = %818, %812
%819 = phi i64 [ 0, %812 ], [ %845, %818 ]
%820 = add i64 %819, %650
%821 = getelementptr inbounds float, float* %783, i64 %820
%822 = bitcast float* %821 to <4 x float>*
%823 = load <4 x float>, <4 x float>* %822
%824 = getelementptr inbounds float, float* %821, i64 4
%825 = bitcast float* %824 to <4 x float>*
%826 = load <4 x float>, <4 x float>* %825
%827 = getelementptr inbounds float, float* %788, i64 %820
%828 = bitcast float* %827 to <4 x float>*
%829 = load <4 x float>, <4 x float>* %828
%830 = getelementptr inbounds float, float* %827, i64 4
%831 = bitcast float* %830 to <4 x float>*
%832 = load <4 x float>, <4 x float>* %831
%833 = fsub <4 x float> %823, %829
%834 = fsub <4 x float> %826, %832
%835 = getelementptr inbounds float, float* %789, i64 %820
%836 = bitcast float* %835 to <4 x float>*
%837 = load <4 x float>, <4 x float>* %836
%838 = getelementptr inbounds float, float* %835, i64 4
%839 = bitcast float* %838 to <4 x float>*
%840 = load <4 x float>, <4 x float>* %839
%841 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %815, <4 x float> %833, <4 x float> %837)
%842 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %817, <4 x float> %834, <4 x float> %840)
%843 = bitcast float* %835 to <4 x float>*
store <4 x float> %841, <4 x float>* %843
%844 = bitcast float* %838 to <4 x float>*
store <4 x float> %842, <4 x float>* %844
%845 = add nuw i64 %819, 8
%846 = icmp eq i64 %845, %667
br i1 %846, label %847, label %818
847: ; preds = %818
br i1 %669, label %892, label %848
848: ; preds = %790, %774, %847
%849 = phi i64 [ %650, %790 ], [ %650, %774 ], [ %668, %847 ]
%850 = trunc i64 %849 to i32
%851 = sub i32 %665, %850
%852 = and i32 %851, 1
%853 = icmp eq i32 %852, 0
br i1 %853, label %865, label %854
854: ; preds = %848
%855 = load float, float* %776
%856 = getelementptr inbounds float, float* %783, i64 %849
%857 = load float, float* %856
%858 = getelementptr inbounds float, float* %788, i64 %849
%859 = load float, float* %858
%860 = fsub float %857, %859
%861 = getelementptr inbounds float, float* %789, i64 %849
%862 = load float, float* %861
%863 = tail call float @llvm.fmuladd.f32(float %855, float %860, float %862)
store float %863, float* %861
%864 = add nsw i64 %849, 1
br label %865
865: ; preds = %854, %848
%866 = phi i64 [ %849, %848 ], [ %864, %854 ]
%867 = icmp eq i32 %643, %850
br i1 %867, label %892, label %868
868: ; preds = %865, %868
%869 = phi i64 [ %889, %868 ], [ %866, %865 ]
%870 = load float, float* %776
%871 = getelementptr inbounds float, float* %783, i64 %869
%872 = load float, float* %871
%873 = getelementptr inbounds float, float* %788, i64 %869
%874 = load float, float* %873
%875 = fsub float %872, %874
%876 = getelementptr inbounds float, float* %789, i64 %869
%877 = load float, float* %876
%878 = tail call float @llvm.fmuladd.f32(float %870, float %875, float %877)
store float %878, float* %876
%879 = add nsw i64 %869, 1
%880 = load float, float* %776
%881 = getelementptr inbounds float, float* %783, i64 %879
%882 = load float, float* %881
%883 = getelementptr inbounds float, float* %788, i64 %879
%884 = load float, float* %883
%885 = fsub float %882, %884
%886 = getelementptr inbounds float, float* %789, i64 %879
%887 = load float, float* %886
%888 = tail call float @llvm.fmuladd.f32(float %880, float %885, float %887)
store float %888, float* %886
%889 = add nsw i64 %869, 2
%890 = trunc i64 %889 to i32
%891 = icmp eq i32 %655, %890
br i1 %891, label %892, label %868
892: ; preds = %865, %868, %847, %771
%893 = add nuw nsw i64 %772, 1
%894 = icmp eq i64 %893, %636
br i1 %894, label %681, label %771
895: ; preds = %769, %895
%896 = phi i64 [ %917, %895 ], [ %770, %769 ]
%897 = load float, float* %684
%898 = fpext float %897 to double
%899 = getelementptr inbounds float, float* %687, i64 %896
%900 = load float, float* %899
%901 = load float, float* %689
%902 = fmul float %900, %901
%903 = fpext float %902 to double
%904 = getelementptr inbounds float, float* %692, i64 %896
%905 = load float, float* %904
%906 = getelementptr inbounds float, float* %695, i64 %896
%907 = load float, float* %906
%908 = fadd float %905, %907
%909 = fpext float %908 to double
%910 = getelementptr inbounds float, float* %696, i64 %896
%911 = load float, float* %910
%912 = fpext float %911 to double
%913 = fmul double %909, -5.000000e-01
%914 = tail call double @llvm.fmuladd.f64(double %913, double %912, double %903)
%915 = fmul double %914, %898
%916 = fptrunc double %915 to float
store float %916, float* %899
%917 = add nsw i64 %896, 1
%918 = trunc i64 %917 to i32
%919 = icmp eq i32 %655, %918
br i1 %919, label %920, label %895
920: ; preds = %895, %768, %681
%921 = add nsw i64 %675, 1
%922 = trunc i64 %921 to i32
%923 = icmp eq i32 %633, %922
br i1 %923, label %924, label %674
924: ; preds = %920, %639
%925 = phi i64 [ %640, %639 ], [ %648, %920 ]
%926 = trunc i64 %925 to i32
%927 = icmp eq i32 %635, %926
br i1 %927, label %928, label %637
928: ; preds = %924, %615
%929 = load i32, i32* %16
%930 = icmp eq i32 %929, 0
%931 = select i1 %930, i1 true, i1 %25
br i1 %931, label %1003, label %932
932: ; preds = %928
%933 = getelementptr inbounds i32, i32* %10, i64 1
%934 = load i32, i32* %933
%935 = getelementptr inbounds i32, i32* %11, i64 1
%936 = load i32, i32* %935
%937 = icmp sgt i32 %934, %936
%938 = icmp sgt i32 %18, 1
%939 = sext i32 %934 to i64
%940 = add i32 %936, 1
%941 = sext i32 %22 to i64
%942 = add i32 %24, 1
%943 = zext i32 %18 to i64
%944 = add nsw i64 %943, -1
%945 = and i64 %944, 1
%946 = icmp eq i32 %18, 2
%947 = and i64 %944, -2
%948 = icmp eq i64 %945, 0
br label %949
949: ; preds = %932, %999
%950 = phi i64 [ %941, %932 ], [ %1000, %999 ]
br i1 %937, label %999, label %951
951: ; preds = %949
%952 = getelementptr inbounds float**, float*** %4, i64 %950
br label %953
953: ; preds = %951, %995
%954 = phi i64 [ %939, %951 ], [ %996, %995 ]
br i1 %938, label %955, label %995
955: ; preds = %953
%956 = load float**, float*** %952
%957 = getelementptr inbounds float*, float** %956, i64 %954
%958 = load float*, float** %957
%959 = load i32, i32* %10
%960 = sext i32 %959 to i64
br i1 %946, label %984, label %961
961: ; preds = %955, %961
%962 = phi i64 [ %981, %961 ], [ 1, %955 ]
%963 = phi i64 [ %982, %961 ], [ 0, %955 ]
%964 = trunc i64 %962 to i32
%965 = add nsw i32 %964, -1
%966 = add i32 %965, %959
%967 = sext i32 %966 to i64
%968 = getelementptr inbounds float, float* %958, i64 %967
%969 = load float, float* %968
%970 = sub nsw i64 %960, %962
%971 = getelementptr inbounds float, float* %958, i64 %970
store float %969, float* %971
%972 = add nuw nsw i64 %962, 1
%973 = trunc i64 %972 to i32
%974 = add i32 %973, -1
%975 = add i32 %974, %959
%976 = sext i32 %975 to i64
%977 = getelementptr inbounds float, float* %958, i64 %976
%978 = load float, float* %977
%979 = sub nsw i64 %960, %972
%980 = getelementptr inbounds float, float* %958, i64 %979
store float %978, float* %980
%981 = add nuw nsw i64 %962, 2
%982 = add i64 %963, 2
%983 = icmp eq i64 %982, %947
br i1 %983, label %984, label %961
984: ; preds = %961, %955
%985 = phi i64 [ 1, %955 ], [ %981, %961 ]
br i1 %948, label %995, label %986
986: ; preds = %984
%987 = trunc i64 %985 to i32
%988 = add i32 %987, -1
%989 = add i32 %988, %959
%990 = sext i32 %989 to i64
%991 = getelementptr inbounds float, float* %958, i64 %990
%992 = load float, float* %991
%993 = sub nsw i64 %960, %985
%994 = getelementptr inbounds float, float* %958, i64 %993
store float %992, float* %994
br label %995
995: ; preds = %986, %984, %953
%996 = add nsw i64 %954, 1
%997 = trunc i64 %996 to i32
%998 = icmp eq i32 %940, %997
br i1 %998, label %999, label %953
999: ; preds = %995, %949
%1000 = add nsw i64 %950, 1
%1001 = trunc i64 %1000 to i32
%1002 = icmp eq i32 %942, %1001
br i1 %1002, label %1003, label %949
1003: ; preds = %999, %928
%1004 = load i32, i32* %17
%1005 = icmp eq i32 %1004, 0
%1006 = select i1 %1005, i1 true, i1 %25
br i1 %1006, label %1078, label %1007
1007: ; preds = %1003
%1008 = getelementptr inbounds i32, i32* %10, i64 1
%1009 = load i32, i32* %1008
%1010 = getelementptr inbounds i32, i32* %11, i64 1
%1011 = load i32, i32* %1010
%1012 = icmp sgt i32 %1009, %1011
%1013 = icmp sgt i32 %18, 1
%1014 = sext i32 %1009 to i64
%1015 = add i32 %1011, 1
%1016 = sext i32 %22 to i64
%1017 = add i32 %24, 1
%1018 = zext i32 %18 to i64
%1019 = add nsw i64 %1018, -1
%1020 = and i64 %1019, 1
%1021 = icmp eq i32 %18, 2
%1022 = and i64 %1019, -2
%1023 = icmp eq i64 %1020, 0
br label %1024
1024: ; preds = %1007, %1074
%1025 = phi i64 [ %1016, %1007 ], [ %1075, %1074 ]
br i1 %1012, label %1074, label %1026
1026: ; preds = %1024
%1027 = getelementptr inbounds float**, float*** %4, i64 %1025
br label %1028
1028: ; preds = %1026, %1070
%1029 = phi i64 [ %1014, %1026 ], [ %1071, %1070 ]
br i1 %1013, label %1030, label %1070
1030: ; preds = %1028
%1031 = load float**, float*** %1027
%1032 = getelementptr inbounds float*, float** %1031, i64 %1029
%1033 = load float*, float** %1032
%1034 = load i32, i32* %11
%1035 = sext i32 %1034 to i64
br i1 %1021, label %1059, label %1036
1036: ; preds = %1030, %1036
%1037 = phi i64 [ %1056, %1036 ], [ 1, %1030 ]
%1038 = phi i64 [ %1057, %1036 ], [ 0, %1030 ]
%1039 = trunc i64 %1037 to i32
%1040 = sub i32 1, %1039
%1041 = add i32 %1040, %1034
%1042 = sext i32 %1041 to i64
%1043 = getelementptr inbounds float, float* %1033, i64 %1042
%1044 = load float, float* %1043
%1045 = add nsw i64 %1037, %1035
%1046 = getelementptr inbounds float, float* %1033, i64 %1045
store float %1044, float* %1046
%1047 = add nuw nsw i64 %1037, 1
%1048 = trunc i64 %1047 to i32
%1049 = sub i32 1, %1048
%1050 = add i32 %1049, %1034
%1051 = sext i32 %1050 to i64
%1052 = getelementptr inbounds float, float* %1033, i64 %1051
%1053 = load float, float* %1052
%1054 = add nsw i64 %1047, %1035
%1055 = getelementptr inbounds float, float* %1033, i64 %1054
store float %1053, float* %1055
%1056 = add nuw nsw i64 %1037, 2
%1057 = add i64 %1038, 2
%1058 = icmp eq i64 %1057, %1022
br i1 %1058, label %1059, label %1036
1059: ; preds = %1036, %1030
%1060 = phi i64 [ 1, %1030 ], [ %1056, %1036 ]
br i1 %1023, label %1070, label %1061
1061: ; preds = %1059
%1062 = trunc i64 %1060 to i32
%1063 = sub i32 1, %1062
%1064 = add i32 %1063, %1034
%1065 = sext i32 %1064 to i64
%1066 = getelementptr inbounds float, float* %1033, i64 %1065
%1067 = load float, float* %1066
%1068 = add nsw i64 %1060, %1035
%1069 = getelementptr inbounds float, float* %1033, i64 %1068
store float %1067, float* %1069
br label %1070
1070: ; preds = %1061, %1059, %1028
%1071 = add nsw i64 %1029, 1
%1072 = trunc i64 %1071 to i32
%1073 = icmp eq i32 %1015, %1072
br i1 %1073, label %1074, label %1028
1074: ; preds = %1070, %1024
%1075 = add nsw i64 %1025, 1
%1076 = trunc i64 %1075 to i32
%1077 = icmp eq i32 %1017, %1076
br i1 %1077, label %1078, label %1024
1078: ; preds = %1074, %1003
%1079 = getelementptr inbounds i32, i32* %16, i64 1
%1080 = load i32, i32* %1079
%1081 = icmp eq i32 %1080, 0
%1082 = select i1 %1081, i1 true, i1 %310
br i1 %1082, label %1163, label %1083
1083: ; preds = %1078
%1084 = load i32, i32* %12
%1085 = load i32, i32* %13
%1086 = icmp sgt i32 %1084, %1085
%1087 = icmp sgt i32 %18, 1
%1088 = getelementptr inbounds i32, i32* %12, i64 1
%1089 = sext i32 %1084 to i64
%1090 = add i32 %1085, 1
%1091 = sext i32 %307 to i64
%1092 = add i32 %309, 1
%1093 = zext i32 %18 to i64
%1094 = add nsw i64 %1093, -1
%1095 = and i64 %1094, 1
%1096 = icmp eq i32 %18, 2
%1097 = and i64 %1094, -2
%1098 = icmp eq i64 %1095, 0
br label %1099
1099: ; preds = %1083, %1159
%1100 = phi i64 [ %1091, %1083 ], [ %1160, %1159 ]
br i1 %1086, label %1159, label %1101
1101: ; preds = %1099
%1102 = getelementptr inbounds float**, float*** %5, i64 %1100
br label %1103
1103: ; preds = %1101, %1155
%1104 = phi i64 [ %1089, %1101 ], [ %1156, %1155 ]
br i1 %1087, label %1105, label %1155
1105: ; preds = %1103
%1106 = load float**, float*** %1102
%1107 = load i32, i32* %1088
%1108 = sext i32 %1107 to i64
br i1 %1096, label %1140, label %1109
1109: ; preds = %1105, %1109
%1110 = phi i64 [ %1137, %1109 ], [ 1, %1105 ]
%1111 = phi i64 [ %1138, %1109 ], [ 0, %1105 ]
%1112 = trunc i64 %1110 to i32
%1113 = add nsw i32 %1112, -1
%1114 = add i32 %1113, %1107
%1115 = sext i32 %1114 to i64
%1116 = getelementptr inbounds float*, float** %1106, i64 %1115
%1117 = load float*, float** %1116
%1118 = getelementptr inbounds float, float* %1117, i64 %1104
%1119 = load float, float* %1118
%1120 = sub nsw i64 %1108, %1110
%1121 = getelementptr inbounds float*, float** %1106, i64 %1120
%1122 = load float*, float** %1121
%1123 = getelementptr inbounds float, float* %1122, i64 %1104
store float %1119, float* %1123
%1124 = add nuw nsw i64 %1110, 1
%1125 = trunc i64 %1124 to i32
%1126 = add i32 %1125, -1
%1127 = add i32 %1126, %1107
%1128 = sext i32 %1127 to i64
%1129 = getelementptr inbounds float*, float** %1106, i64 %1128
%1130 = load float*, float** %1129
%1131 = getelementptr inbounds float, float* %1130, i64 %1104
%1132 = load float, float* %1131
%1133 = sub nsw i64 %1108, %1124
%1134 = getelementptr inbounds float*, float** %1106, i64 %1133
%1135 = load float*, float** %1134
%1136 = getelementptr inbounds float, float* %1135, i64 %1104
store float %1132, float* %1136
%1137 = add nuw nsw i64 %1110, 2
%1138 = add i64 %1111, 2
%1139 = icmp eq i64 %1138, %1097
br i1 %1139, label %1140, label %1109
1140: ; preds = %1109, %1105
%1141 = phi i64 [ 1, %1105 ], [ %1137, %1109 ]
br i1 %1098, label %1155, label %1142
1142: ; preds = %1140
%1143 = trunc i64 %1141 to i32
%1144 = add i32 %1143, -1
%1145 = add i32 %1144, %1107
%1146 = sext i32 %1145 to i64
%1147 = getelementptr inbounds float*, float** %1106, i64 %1146
%1148 = load float*, float** %1147
%1149 = getelementptr inbounds float, float* %1148, i64 %1104
%1150 = load float, float* %1149
%1151 = sub nsw i64 %1108, %1141
%1152 = getelementptr inbounds float*, float** %1106, i64 %1151
%1153 = load float*, float** %1152
%1154 = getelementptr inbounds float, float* %1153, i64 %1104
store float %1150, float* %1154
br label %1155
1155: ; preds = %1142, %1140, %1103
%1156 = add nsw i64 %1104, 1
%1157 = trunc i64 %1156 to i32
%1158 = icmp eq i32 %1090, %1157
br i1 %1158, label %1159, label %1103
1159: ; preds = %1155, %1099
%1160 = add nsw i64 %1100, 1
%1161 = trunc i64 %1160 to i32
%1162 = icmp eq i32 %1092, %1161
br i1 %1162, label %1163, label %1099
1163: ; preds = %1159, %1078
%1164 = getelementptr inbounds i32, i32* %17, i64 1
%1165 = load i32, i32* %1164
%1166 = icmp eq i32 %1165, 0
%1167 = select i1 %1166, i1 true, i1 %310
br i1 %1167, label %1248, label %1168
1168: ; preds = %1163
%1169 = load i32, i32* %12
%1170 = load i32, i32* %13
%1171 = icmp sgt i32 %1169, %1170
%1172 = icmp sgt i32 %18, 1
%1173 = getelementptr inbounds i32, i32* %13, i64 1
%1174 = sext i32 %1169 to i64
%1175 = add i32 %1170, 1
%1176 = sext i32 %307 to i64
%1177 = add i32 %309, 1
%1178 = zext i32 %18 to i64
%1179 = add nsw i64 %1178, -1
%1180 = and i64 %1179, 1
%1181 = icmp eq i32 %18, 2
%1182 = and i64 %1179, -2
%1183 = icmp eq i64 %1180, 0
br label %1184
1184: ; preds = %1168, %1244
%1185 = phi i64 [ %1176, %1168 ], [ %1245, %1244 ]
br i1 %1171, label %1244, label %1186
1186: ; preds = %1184
%1187 = getelementptr inbounds float**, float*** %5, i64 %1185
br label %1188
1188: ; preds = %1186, %1240
%1189 = phi i64 [ %1174, %1186 ], [ %1241, %1240 ]
br i1 %1172, label %1190, label %1240
1190: ; preds = %1188
%1191 = load float**, float*** %1187
%1192 = load i32, i32* %1173
%1193 = sext i32 %1192 to i64
br i1 %1181, label %1225, label %1194
1194: ; preds = %1190, %1194
%1195 = phi i64 [ %1222, %1194 ], [ 1, %1190 ]
%1196 = phi i64 [ %1223, %1194 ], [ 0, %1190 ]
%1197 = trunc i64 %1195 to i32
%1198 = sub i32 1, %1197
%1199 = add i32 %1198, %1192
%1200 = sext i32 %1199 to i64
%1201 = getelementptr inbounds float*, float** %1191, i64 %1200
%1202 = load float*, float** %1201
%1203 = getelementptr inbounds float, float* %1202, i64 %1189
%1204 = load float, float* %1203
%1205 = add nsw i64 %1195, %1193
%1206 = getelementptr inbounds float*, float** %1191, i64 %1205
%1207 = load float*, float** %1206
%1208 = getelementptr inbounds float, float* %1207, i64 %1189
store float %1204, float* %1208
%1209 = add nuw nsw i64 %1195, 1
%1210 = trunc i64 %1209 to i32
%1211 = sub i32 1, %1210
%1212 = add i32 %1211, %1192
%1213 = sext i32 %1212 to i64
%1214 = getelementptr inbounds float*, float** %1191, i64 %1213
%1215 = load float*, float** %1214
%1216 = getelementptr inbounds float, float* %1215, i64 %1189
%1217 = load float, float* %1216
%1218 = add nsw i64 %1209, %1193
%1219 = getelementptr inbounds float*, float** %1191, i64 %1218
%1220 = load float*, float** %1219
%1221 = getelementptr inbounds float, float* %1220, i64 %1189
store float %1217, float* %1221
%1222 = add nuw nsw i64 %1195, 2
%1223 = add i64 %1196, 2
%1224 = icmp eq i64 %1223, %1182
br i1 %1224, label %1225, label %1194
1225: ; preds = %1194, %1190
%1226 = phi i64 [ 1, %1190 ], [ %1222, %1194 ]
br i1 %1183, label %1240, label %1227
1227: ; preds = %1225
%1228 = trunc i64 %1226 to i32
%1229 = sub i32 1, %1228
%1230 = add i32 %1229, %1192
%1231 = sext i32 %1230 to i64
%1232 = getelementptr inbounds float*, float** %1191, i64 %1231
%1233 = load float*, float** %1232
%1234 = getelementptr inbounds float, float* %1233, i64 %1189
%1235 = load float, float* %1234
%1236 = add nsw i64 %1226, %1193
%1237 = getelementptr inbounds float*, float** %1191, i64 %1236
%1238 = load float*, float** %1237
%1239 = getelementptr inbounds float, float* %1238, i64 %1189
store float %1235, float* %1239
br label %1240
1240: ; preds = %1227, %1225, %1188
%1241 = add nsw i64 %1189, 1
%1242 = trunc i64 %1241 to i32
%1243 = icmp eq i32 %1175, %1242
br i1 %1243, label %1244, label %1188
1244: ; preds = %1240, %1184
%1245 = add nsw i64 %1185, 1
%1246 = trunc i64 %1245 to i32
%1247 = icmp eq i32 %1177, %1246
br i1 %1247, label %1248, label %1184
1248: ; preds = %1244, %1163
%1249 = getelementptr inbounds i32, i32* %16, i64 2
%1250 = load i32, i32* %1249
%1251 = icmp eq i32 %1250, 0
br i1 %1251, label %1343, label %1252
1252: ; preds = %1248
%1253 = getelementptr inbounds i32, i32* %14, i64 1
%1254 = load i32, i32* %1253
%1255 = getelementptr inbounds i32, i32* %15, i64 1
%1256 = load i32, i32* %1255
%1257 = icmp sgt i32 %1254, %1256
br i1 %1257, label %1343, label %1258
1258: ; preds = %1252
%1259 = load i32, i32* %14
%1260 = load i32, i32* %15
%1261 = icmp sgt i32 %1259, %1260
%1262 = icmp sgt i32 %18, 1
%1263 = add i32 %617, -1
%1264 = sext i32 %617 to i64
%1265 = sext i32 %1259 to i64
%1266 = add i32 %1260, 1
%1267 = sext i32 %1254 to i64
%1268 = add i32 %1256, 1
%1269 = zext i32 %18 to i64
%1270 = add nsw i64 %1269, -1
%1271 = and i64 %1270, 1
%1272 = icmp eq i32 %18, 2
%1273 = and i64 %1270, -2
%1274 = icmp eq i64 %1271, 0
br label %1275
1275: ; preds = %1258, %1339
%1276 = phi i64 [ %1267, %1258 ], [ %1340, %1339 ]
br i1 %1261, label %1339, label %1277
1277: ; preds = %1275, %1335
%1278 = phi i64 [ %1336, %1335 ], [ %1265, %1275 ]
br i1 %1262, label %1279, label %1335
1279: ; preds = %1277
br i1 %1272, label %1317, label %1280
1280: ; preds = %1279, %1280
%1281 = phi i64 [ %1314, %1280 ], [ 1, %1279 ]
%1282 = phi i64 [ %1315, %1280 ], [ 0, %1279 ]
%1283 = trunc i64 %1281 to i32
%1284 = add i32 %1263, %1283
%1285 = sext i32 %1284 to i64
%1286 = getelementptr inbounds float**, float*** %6, i64 %1285
%1287 = load float**, float*** %1286
%1288 = getelementptr inbounds float*, float** %1287, i64 %1276
%1289 = load float*, float** %1288
%1290 = getelementptr inbounds float, float* %1289, i64 %1278
%1291 = load float, float* %1290
%1292 = sub nsw i64 %1264, %1281
%1293 = getelementptr inbounds float**, float*** %6, i64 %1292
%1294 = load float**, float*** %1293
%1295 = getelementptr inbounds float*, float** %1294, i64 %1276
%1296 = load float*, float** %1295
%1297 = getelementptr inbounds float, float* %1296, i64 %1278
store float %1291, float* %1297
%1298 = add nuw nsw i64 %1281, 1
%1299 = trunc i64 %1298 to i32
%1300 = add i32 %1263, %1299
%1301 = sext i32 %1300 to i64
%1302 = getelementptr inbounds float**, float*** %6, i64 %1301
%1303 = load float**, float*** %1302
%1304 = getelementptr inbounds float*, float** %1303, i64 %1276
%1305 = load float*, float** %1304
%1306 = getelementptr inbounds float, float* %1305, i64 %1278
%1307 = load float, float* %1306
%1308 = sub nsw i64 %1264, %1298
%1309 = getelementptr inbounds float**, float*** %6, i64 %1308
%1310 = load float**, float*** %1309
%1311 = getelementptr inbounds float*, float** %1310, i64 %1276
%1312 = load float*, float** %1311
%1313 = getelementptr inbounds float, float* %1312, i64 %1278
store float %1307, float* %1313
%1314 = add nuw nsw i64 %1281, 2
%1315 = add i64 %1282, 2
%1316 = icmp eq i64 %1315, %1273
br i1 %1316, label %1317, label %1280
1317: ; preds = %1280, %1279
%1318 = phi i64 [ 1, %1279 ], [ %1314, %1280 ]
br i1 %1274, label %1335, label %1319
1319: ; preds = %1317
%1320 = trunc i64 %1318 to i32
%1321 = add i32 %1263, %1320
%1322 = sext i32 %1321 to i64
%1323 = getelementptr inbounds float**, float*** %6, i64 %1322
%1324 = load float**, float*** %1323
%1325 = getelementptr inbounds float*, float** %1324, i64 %1276
%1326 = load float*, float** %1325
%1327 = getelementptr inbounds float, float* %1326, i64 %1278
%1328 = load float, float* %1327
%1329 = sub nsw i64 %1264, %1318
%1330 = getelementptr inbounds float**, float*** %6, i64 %1329
%1331 = load float**, float*** %1330
%1332 = getelementptr inbounds float*, float** %1331, i64 %1276
%1333 = load float*, float** %1332
%1334 = getelementptr inbounds float, float* %1333, i64 %1278
store float %1328, float* %1334
br label %1335
1335: ; preds = %1319, %1317, %1277
%1336 = add nsw i64 %1278, 1
%1337 = trunc i64 %1336 to i32
%1338 = icmp eq i32 %1266, %1337
br i1 %1338, label %1339, label %1277
1339: ; preds = %1335, %1275
%1340 = add nsw i64 %1276, 1
%1341 = trunc i64 %1340 to i32
%1342 = icmp eq i32 %1268, %1341
br i1 %1342, label %1343, label %1275
1343: ; preds = %1339, %1252, %1248
%1344 = getelementptr inbounds i32, i32* %17, i64 2
%1345 = load i32, i32* %1344
%1346 = icmp eq i32 %1345, 0
br i1 %1346, label %1438, label %1347
1347: ; preds = %1343
%1348 = getelementptr inbounds i32, i32* %14, i64 1
%1349 = load i32, i32* %1348
%1350 = getelementptr inbounds i32, i32* %15, i64 1
%1351 = load i32, i32* %1350
%1352 = icmp sgt i32 %1349, %1351
br i1 %1352, label %1438, label %1353
1353: ; preds = %1347
%1354 = load i32, i32* %14
%1355 = load i32, i32* %15
%1356 = icmp sgt i32 %1354, %1355
%1357 = icmp sgt i32 %18, 1
%1358 = add i32 %619, 1
%1359 = sext i32 %619 to i64
%1360 = sext i32 %1354 to i64
%1361 = add i32 %1355, 1
%1362 = sext i32 %1349 to i64
%1363 = add i32 %1351, 1
%1364 = zext i32 %18 to i64
%1365 = add nsw i64 %1364, -1
%1366 = and i64 %1365, 1
%1367 = icmp eq i32 %18, 2
%1368 = and i64 %1365, -2
%1369 = icmp eq i64 %1366, 0
br label %1370
1370: ; preds = %1353, %1434
%1371 = phi i64 [ %1362, %1353 ], [ %1435, %1434 ]
br i1 %1356, label %1434, label %1372
1372: ; preds = %1370, %1430
%1373 = phi i64 [ %1431, %1430 ], [ %1360, %1370 ]
br i1 %1357, label %1374, label %1430
1374: ; preds = %1372
br i1 %1367, label %1412, label %1375
1375: ; preds = %1374, %1375
%1376 = phi i64 [ %1409, %1375 ], [ 1, %1374 ]
%1377 = phi i64 [ %1410, %1375 ], [ 0, %1374 ]
%1378 = trunc i64 %1376 to i32
%1379 = sub i32 %1358, %1378
%1380 = sext i32 %1379 to i64
%1381 = getelementptr inbounds float**, float*** %6, i64 %1380
%1382 = load float**, float*** %1381
%1383 = getelementptr inbounds float*, float** %1382, i64 %1371
%1384 = load float*, float** %1383
%1385 = getelementptr inbounds float, float* %1384, i64 %1373
%1386 = load float, float* %1385
%1387 = add nsw i64 %1376, %1359
%1388 = getelementptr inbounds float**, float*** %6, i64 %1387
%1389 = load float**, float*** %1388
%1390 = getelementptr inbounds float*, float** %1389, i64 %1371
%1391 = load float*, float** %1390
%1392 = getelementptr inbounds float, float* %1391, i64 %1373
store float %1386, float* %1392
%1393 = add nuw nsw i64 %1376, 1
%1394 = trunc i64 %1393 to i32
%1395 = sub i32 %1358, %1394
%1396 = sext i32 %1395 to i64
%1397 = getelementptr inbounds float**, float*** %6, i64 %1396
%1398 = load float**, float*** %1397
%1399 = getelementptr inbounds float*, float** %1398, i64 %1371
%1400 = load float*, float** %1399
%1401 = getelementptr inbounds float, float* %1400, i64 %1373
%1402 = load float, float* %1401
%1403 = add nsw i64 %1393, %1359
%1404 = getelementptr inbounds float**, float*** %6, i64 %1403
%1405 = load float**, float*** %1404
%1406 = getelementptr inbounds float*, float** %1405, i64 %1371
%1407 = load float*, float** %1406
%1408 = getelementptr inbounds float, float* %1407, i64 %1373
store float %1402, float* %1408
%1409 = add nuw nsw i64 %1376, 2
%1410 = add i64 %1377, 2
%1411 = icmp eq i64 %1410, %1368
br i1 %1411, label %1412, label %1375
1412: ; preds = %1375, %1374
%1413 = phi i64 [ 1, %1374 ], [ %1409, %1375 ]
br i1 %1369, label %1430, label %1414
1414: ; preds = %1412
%1415 = trunc i64 %1413 to i32
%1416 = sub i32 %1358, %1415
%1417 = sext i32 %1416 to i64
%1418 = getelementptr inbounds float**, float*** %6, i64 %1417
%1419 = load float**, float*** %1418
%1420 = getelementptr inbounds float*, float** %1419, i64 %1371
%1421 = load float*, float** %1420
%1422 = getelementptr inbounds float, float* %1421, i64 %1373
%1423 = load float, float* %1422
%1424 = add nsw i64 %1413, %1359
%1425 = getelementptr inbounds float**, float*** %6, i64 %1424
%1426 = load float**, float*** %1425
%1427 = getelementptr inbounds float*, float** %1426, i64 %1371
%1428 = load float*, float** %1427
%1429 = getelementptr inbounds float, float* %1428, i64 %1373
store float %1423, float* %1429
br label %1430
1430: ; preds = %1414, %1412, %1372
%1431 = add nsw i64 %1373, 1
%1432 = trunc i64 %1431 to i32
%1433 = icmp eq i32 %1361, %1432
br i1 %1433, label %1434, label %1372
1434: ; preds = %1430, %1370
%1435 = add nsw i64 %1371, 1
%1436 = trunc i64 %1435 to i32
%1437 = icmp eq i32 %1363, %1436
br i1 %1437, label %1438, label %1370
1438: ; preds = %1434, %1347, %1343
ret void
}