void asg_vstep2d(float **restrict buoy, float **restrict p0,
                 float **restrict p1, float **restrict v0, float **restrict v1,
                 float **restrict ev, float **restrict evp,
                 float **restrict gradp, int *gsc_v0, int *gec_v0, int *gsc_v1,
                 int *gec_v1, int *lbc, int *rbc, int maxoff,
                 float **restrict c) {
  int i0, i1;
  int ioff;
  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[i1][i0 + ioff + 1] - p0[i1][i0 - ioff]);
    }
    for (i0 = gsc_v0[0]; i0 <= gec_v0[0]; i0++)
      v0[i1][i0] =
          evp[0][i0] * (v0[i1][i0] * ev[0][i0] -
                        0.5 * (buoy[i1][i0] + buoy[i1][i0 + 1]) * gradp[0][i0]);
  }
  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[i1 + ioff + 1][i0] - p1[i1 - ioff][i0]);
    }
    for (i0 = gsc_v1[0]; i0 <= gec_v1[0]; i0++)
      v1[i1][i0] =
          evp[1][i1] * (v1[i1][i0] * ev[1][i1] -
                        0.5 * (buoy[i1][i0] + buoy[i1 + 1][i0]) * gradp[1][i0]);
  }
  if (lbc[0]) {
    for (i1 = gsc_v0[1]; i1 <= gec_v0[1]; i1++) {
      for (ioff = 1; ioff < maxoff; ioff++) {
        v0[i1][gsc_v0[0] - ioff] = v0[i1][gsc_v0[0] + ioff - 1];
      }
    }
  }
  if (rbc[0]) {
    for (i1 = gsc_v0[1]; i1 <= gec_v0[1]; i1++) {
      for (ioff = 1; ioff < maxoff; ioff++) {
        v0[i1][gec_v0[0] + ioff] = v0[i1][gec_v0[0] - ioff + 1];
      }
    }
  }
  if (lbc[1]) {
    for (i0 = gsc_v1[0]; i0 <= gec_v1[0]; i0++) {
      for (ioff = 1; ioff < maxoff; ioff++) {
        v1[gsc_v1[1] - ioff][i0] = v1[gsc_v1[1] + ioff - 1][i0];
      }
    }
  }
  if (rbc[1]) {
    for (i0 = gsc_v1[0]; i0 <= gec_v1[0]; i0++) {
      for (ioff = 1; ioff < maxoff; ioff++) {
        v1[gec_v1[1] + ioff][i0] = v1[gec_v1[1] - ioff + 1][i0];
      }
    }
  }
}


x86 assembly (clang, -O0):
<asg_vstep2d>:
push   %rbp
mov    %rsp,%rbp
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%eax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    0x20(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x28(%rbp),%rcx
cmp    0x4(%rcx),%eax
jg     134b <asg_vstep2d+0x24b>
mov    0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x28(%rbp),%rcx
cmp    (%rcx),%eax
jg     1196 <asg_vstep2d+0x96>
mov    0x18(%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    1166 <asg_vstep2d+0x66>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x50(%rbp),%eax
jge    1246 <asg_vstep2d+0x146>
mov    0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x28(%rbp),%rcx
cmp    (%rcx),%eax
jg     1233 <asg_vstep2d+0x133>
mov    0x58(%rbp),%rax
mov    (%rax),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
sub    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
mov    0x18(%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    11b2 <asg_vstep2d+0xb2>
jmp    1238 <asg_vstep2d+0x138>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    119d <asg_vstep2d+0x9d>
mov    0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x28(%rbp),%rcx
cmp    (%rcx),%eax
jg     1338 <asg_vstep2d+0x238>
mov    0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%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  0xd2a(%rip),%xmm1
mulsd  %xmm3,%xmm1
mov    0x18(%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    -0x20(%rbp),%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    124f <asg_vstep2d+0x14f>
jmp    133d <asg_vstep2d+0x23d>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    114d <asg_vstep2d+0x4d>
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     1559 <asg_vstep2d+0x459>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x38(%rbp),%rcx
cmp    (%rcx),%eax
jg     139f <asg_vstep2d+0x29f>
mov    0x18(%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    136e <asg_vstep2d+0x26e>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x50(%rbp),%eax
jge    1451 <asg_vstep2d+0x351>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x38(%rbp),%rcx
cmp    (%rcx),%eax
jg     143e <asg_vstep2d+0x33e>
mov    0x58(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x3c(%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
mov    -0x38(%rbp),%ecx
sub    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm2
mov    0x18(%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    13bb <asg_vstep2d+0x2bb>
jmp    1443 <asg_vstep2d+0x343>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13a6 <asg_vstep2d+0x2a6>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x38(%rbp),%rcx
cmp    (%rcx),%eax
jg     1546 <asg_vstep2d+0x446>
mov    0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%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  0xb1d(%rip),%xmm1
mulsd  %xmm3,%xmm1
mov    0x18(%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    -0x28(%rbp),%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    145a <asg_vstep2d+0x35a>
jmp    154b <asg_vstep2d+0x44b>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1355 <asg_vstep2d+0x255>
mov    0x40(%rbp),%rax
cmpl   $0x0,(%rax)
je     15f6 <asg_vstep2d+0x4f6>
mov    0x20(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x28(%rbp),%rcx
cmp    0x4(%rcx),%eax
jg     15f1 <asg_vstep2d+0x4f1>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x50(%rbp),%eax
jge    15de <asg_vstep2d+0x4de>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x20(%rbp),%rcx
mov    (%rcx),%ecx
add    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x20(%rbp),%rcx
mov    (%rcx),%ecx
sub    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1587 <asg_vstep2d+0x487>
jmp    15e3 <asg_vstep2d+0x4e3>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1570 <asg_vstep2d+0x470>
jmp    15f6 <asg_vstep2d+0x4f6>
mov    0x48(%rbp),%rax
cmpl   $0x0,(%rax)
je     1693 <asg_vstep2d+0x593>
mov    0x20(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x28(%rbp),%rcx
cmp    0x4(%rcx),%eax
jg     168e <asg_vstep2d+0x58e>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x50(%rbp),%eax
jge    167b <asg_vstep2d+0x57b>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%ecx
sub    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1624 <asg_vstep2d+0x524>
jmp    1680 <asg_vstep2d+0x580>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    160d <asg_vstep2d+0x50d>
jmp    1693 <asg_vstep2d+0x593>
mov    0x40(%rbp),%rax
cmpl   $0x0,0x4(%rax)
je     1731 <asg_vstep2d+0x631>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x38(%rbp),%rcx
cmp    (%rcx),%eax
jg     172c <asg_vstep2d+0x62c>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x50(%rbp),%eax
jge    1719 <asg_vstep2d+0x619>
mov    -0x28(%rbp),%rax
mov    0x30(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    0x30(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    16c0 <asg_vstep2d+0x5c0>
jmp    171e <asg_vstep2d+0x61e>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    16aa <asg_vstep2d+0x5aa>
jmp    1731 <asg_vstep2d+0x631>
mov    0x48(%rbp),%rax
cmpl   $0x0,0x4(%rax)
je     17cf <asg_vstep2d+0x6cf>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x38(%rbp),%rcx
cmp    (%rcx),%eax
jg     17ca <asg_vstep2d+0x6ca>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x50(%rbp),%eax
jge    17b7 <asg_vstep2d+0x6b7>
mov    -0x28(%rbp),%rax
mov    0x38(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    0x38(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    175e <asg_vstep2d+0x65e>
jmp    17bc <asg_vstep2d+0x6bc>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1748 <asg_vstep2d+0x648>
jmp    17cf <asg_vstep2d+0x6cf>
pop    %rbp
ret

x86 assembly (clang, -O2):
<asg_vstep2d>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %r9,0xf8(%rsp)
mov    %r8,0xe8(%rsp)
mov    %rcx,0xe0(%rsp)
mov    %rdx,0x100(%rsp)
mov    %rsi,0xa8(%rsp)
mov    %rdi,0xf0(%rsp)
mov    0x188(%rsp),%r14
mov    0x158(%rsp),%rax
mov    0x150(%rsp),%rcx
movslq 0x4(%rcx),%rcx
mov    0x4(%rax),%edx
mov    %rcx,%rax
mov    %rcx,0x40(%rsp)
mov    %rdx,0x38(%rsp)
cmp    %edx,%ecx
jle    141a <asg_vstep2d+0x30a>
mov    0x160(%rsp),%rax
mov    0x4(%rax),%eax
mov    %eax,0xb0(%rsp)
movslq %eax,%rcx
mov    0x168(%rsp),%rax
mov    0x4(%rax),%eax
mov    %rax,0x90(%rsp)
mov    %rcx,0x68(%rsp)
cmp    %eax,%ecx
jle    1a87 <asg_vstep2d+0x977>
mov    0x178(%rsp),%r8
mov    0x170(%rsp),%rax
cmpl   $0x0,(%rax)
mov    0x180(%rsp),%r14d
mov    0xe0(%rsp),%r15
mov    0x158(%rsp),%r12
je     12bd <asg_vstep2d+0x1ad>
mov    0x38(%rsp),%rax
cmp    %eax,0x40(%rsp)
jg     12bd <asg_vstep2d+0x1ad>
mov    0x38(%rsp),%rax
lea    0x1(%rax),%r10d
mov    %r14d,%r9d
add    $0xffffffffffffffff,%r9
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
mov    0x40(%rsp),%rdi
jmp    122d <asg_vstep2d+0x11d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdi
cmp    %edi,%r10d
je     12bd <asg_vstep2d+0x1ad>
cmp    $0x2,%r14d
jl     1220 <asg_vstep2d+0x110>
mov    (%r15,%rdi,8),%rbp
mov    0x150(%rsp),%rax
mov    (%rax),%edx
movslq %edx,%r11
mov    $0x1,%eax
je     1298 <asg_vstep2d+0x188>
lea    0x0(,%r11,4),%rcx
add    %rbp,%rcx
mov    $0xffffffffffffffff,%rax
nopl   (%rax)
movslq %edx,%rdx
movss  0x0(%rbp,%rdx,4),%xmm0
movss  %xmm0,(%rcx,%rax,4)
lea    0x1(%rdx),%ebx
movslq %ebx,%rbx
movss  0x0(%rbp,%rbx,4),%xmm0
movss  %xmm0,-0x4(%rcx,%rax,4)
add    $0x2,%edx
lea    (%rsi,%rax,1),%rbx
add    $0xfffffffffffffffe,%rbx
add    $0xfffffffffffffffe,%rax
cmp    $0xffffffffffffffff,%rbx
jne    1260 <asg_vstep2d+0x150>
neg    %rax
test   $0x1,%r9b
je     1220 <asg_vstep2d+0x110>
lea    (%rax,%r11,1),%ecx
add    $0xffffffff,%ecx
movslq %ecx,%rcx
movss  0x0(%rbp,%rcx,4),%xmm0
sub    %rax,%r11
movss  %xmm0,0x0(%rbp,%r11,4)
jmp    1220 <asg_vstep2d+0x110>
cmpl   $0x0,(%r8)
mov    0xe8(%rsp),%r11
je     13a9 <asg_vstep2d+0x299>
mov    0x38(%rsp),%rax
cmp    %eax,0x40(%rsp)
jg     13a9 <asg_vstep2d+0x299>
mov    0x38(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x38(%rsp)
mov    %r14d,%r9d
add    $0xffffffffffffffff,%r9
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
jmp    131b <asg_vstep2d+0x20b>
xchg   %ax,%ax
mov    0x40(%rsp),%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x40(%rsp)
cmp    %ecx,0x38(%rsp)
je     13a9 <asg_vstep2d+0x299>
cmp    $0x2,%r14d
jl     1300 <asg_vstep2d+0x1f0>
mov    0x40(%rsp),%rax
mov    (%r15,%rax,8),%rsi
mov    (%r12),%ebp
movslq %ebp,%rax
mov    $0x1,%edi
je     1383 <asg_vstep2d+0x273>
lea    (%rsi,%rax,4),%rbx
add    $0x4,%rbx
mov    $0x1,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movslq %ebp,%rbp
movss  (%rsi,%rbp,4),%xmm0
movss  %xmm0,-0x4(%rbx,%rdi,4)
lea    -0x1(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rbx,%rdi,4)
add    $0xfffffffe,%ebp
lea    (%rdx,%rdi,1),%rcx
add    $0x2,%rcx
add    $0x2,%rdi
cmp    $0x1,%rcx
jne    1350 <asg_vstep2d+0x240>
test   $0x1,%r9b
je     1300 <asg_vstep2d+0x1f0>
mov    %eax,%ecx
sub    %edi,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rsi,%rcx,4),%xmm0
add    %rax,%rdi
movss  %xmm0,(%rsi,%rdi,4)
jmp    1300 <asg_vstep2d+0x1f0>
mov    0x170(%rsp),%rax
cmpl   $0x0,0x4(%rax)
mov    0x90(%rsp),%r15
mov    0xb0(%rsp),%r12d
je     13e4 <asg_vstep2d+0x2d4>
mov    0x160(%rsp),%rax
movslq (%rax),%rcx
mov    0x168(%rsp),%rax
mov    (%rax),%edx
cmp    %edx,%ecx
jle    2086 <asg_vstep2d+0xf76>
cmpl   $0x0,0x4(%r8)
je     1408 <asg_vstep2d+0x2f8>
mov    0x160(%rsp),%rax
movslq (%rax),%rax
mov    0x168(%rsp),%rcx
mov    (%rcx),%ecx
cmp    %ecx,%eax
jle    2156 <asg_vstep2d+0x1046>
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x150(%rsp),%rax
movslq (%rax),%r8
mov    0x158(%rsp),%rax
mov    (%rax),%ebx
mov    %ebx,%ecx
sub    %r8d,%ecx
lea    0x4(,%rcx,4),%rax
mov    %rax,0xc8(%rsp)
lea    0x1(%rbx),%r12d
mov    0x38(%rsp),%rax
add    $0x1,%eax
mov    %eax,0x70(%rsp)
lea    0x1(%r8,%rcx,1),%rax
mov    %rax,0xa0(%rsp)
lea    0x2(%r8,%rcx,1),%rax
mov    %rax,0xb8(%rsp)
mov    %rcx,0x18(%rsp)
add    $0x1,%rcx
lea    0x1(%r8),%eax
mov    %rax,0x88(%rsp)
mov    %rcx,%r13
and    $0xfffffffffffffff8,%r13
lea    (%r8,%r13,1),%rax
mov    %rax,0xd0(%rsp)
movabs $0x1fffffff8,%rdx
or     $0x4,%rdx
mov    %rcx,%rax
mov    %rcx,0x80(%rsp)
and    %rcx,%rdx
mov    %rdx,0x90(%rsp)
lea    (%rdx,%r8,1),%rax
mov    %rax,0xb0(%rsp)
movsd  0x1b41(%rip),%xmm8
movapd 0x1b28(%rip),%xmm9
lea    0x1(%r8),%rax
mov    %rax,0x98(%rsp)
lea    0x4(%r8),%rax
mov    %rax,0x78(%rsp)
movabs $0x100000000,%r15
mov    0x40(%rsp),%r11
mov    %r8,0x10(%rsp)
mov    %rbx,0x28(%rsp)
mov    %r13,0xd8(%rsp)
jmp    1529 <asg_vstep2d+0x419>
add    $0x1,%r11
cmp    %r11d,0x70(%rsp)
mov    0x10(%rsp),%r8
mov    0x28(%rsp),%rbx
je     1185 <asg_vstep2d+0x75>
cmp    %r8d,%ebx
mov    %r11,0x60(%rsp)
jl     1571 <asg_vstep2d+0x461>
lea    0x0(,%r8,4),%rdi
mov    0x148(%rsp),%rax
add    (%rax),%rdi
xor    %esi,%esi
mov    0xc8(%rsp),%rdx
call   1030 <memset@plt>
mov    0x60(%rsp),%r11
movapd 0x1a9d(%rip),%xmm9
movsd  0x1aa4(%rip),%xmm8
mov    0x10(%rsp),%r8
cmpl   $0x0,0x180(%rsp)
jle    17d0 <asg_vstep2d+0x6c0>
xor    %r10d,%r10d
jmp    15aa <asg_vstep2d+0x49a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r10
mov    %r10,%r9
mov    %r9,%r10
mov    0x180(%rsp),%eax
cmp    %rax,%r9
je     17d0 <asg_vstep2d+0x6c0>
cmp    %r8d,%ebx
jl     1590 <asg_vstep2d+0x480>
lea    0x1(%r10),%r9
mov    (%r14),%rax
lea    (%rax,%r10,4),%rcx
mov    0xa8(%rsp),%rdx
mov    (%rdx,%r11,8),%rdx
mov    0x148(%rsp),%rsi
mov    (%rsi),%rsi
mov    %r8,%rbx
cmpl   $0x7,0x18(%rsp)
jb     1770 <asg_vstep2d+0x660>
mov    0x88(%rsp),%rdi
add    %r10d,%edi
mov    0x18(%rsp),%rbx
lea    (%rdi,%rbx,1),%ebp
mov    %r8,%rbx
cmp    %edi,%ebp
jl     1770 <asg_vstep2d+0x660>
lea    (%rsi,%r8,4),%rdi
mov    0xa0(%rsp),%r13
lea    (%rsi,%r13,4),%rbx
lea    (%rax,%r10,4),%r11
add    $0x4,%r11
lea    0x0(,%r10,4),%rbp
lea    (%rdx,%r8,4),%r14
sub    %rbp,%r14
lea    (%rdx,%r13,4),%rax
mov    %rbp,0x58(%rsp)
sub    %rbp,%rax
mov    0x88(%rsp),%rbp
lea    (%r10,%rbp,1),%r13d
movslq %r13d,%r13
cmp    %r11,%rdi
setb   %r8b
cmp    %rbx,%rcx
setb   %r11b
cmp    %rax,%rdi
setb   %al
cmp    %rbx,%r14
mov    0x80(%rsp),%rbp
lea    (%rdx,%rbp,4),%rbp
lea    0x0(%rbp,%r13,4),%r14
setb   0x20(%rsp)
cmp    %r14,%rdi
mov    0x188(%rsp),%r14
lea    (%rdx,%r13,4),%rbp
setb   %dil
cmp    %rbx,%rbp
setb   %r13b
mov    0x10(%rsp),%rbx
test   %r11b,%r8b
mov    0x60(%rsp),%r11
mov    0x10(%rsp),%r8
jne    1770 <asg_vstep2d+0x660>
mov    %r8,%rbx
and    0x20(%rsp),%al
jne    1770 <asg_vstep2d+0x660>
mov    %r8,%rbx
and    %r13b,%dil
jne    1770 <asg_vstep2d+0x660>
movss  (%rcx),%xmm0
shufps $0x0,%xmm0,%xmm0
mov    0x98(%rsp),%rax
lea    (%rax,%r10,1),%ebp
shl    $0x20,%rbp
mov    0x78(%rsp),%rax
lea    (%rdx,%rax,4),%r8
sub    0x58(%rsp),%r8
lea    (%rsi,%rax,4),%rax
xor    %edi,%edi
mov    0xd8(%rsp),%r13
movabs $0x800000000,%r11
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbp,%rbx
sar    $0x1e,%rbx
movups (%rdx,%rbx,1),%xmm1
movups 0x10(%rdx,%rbx,1),%xmm2
movups -0x10(%r8,%rdi,4),%xmm3
subps  %xmm3,%xmm1
movups (%r8,%rdi,4),%xmm3
subps  %xmm3,%xmm2
movups -0x10(%rax,%rdi,4),%xmm3
movups (%rax,%rdi,4),%xmm4
mulps  %xmm0,%xmm1
addps  %xmm3,%xmm1
mulps  %xmm0,%xmm2
addps  %xmm4,%xmm2
movups %xmm1,-0x10(%rax,%rdi,4)
movups %xmm2,(%rax,%rdi,4)
add    $0x8,%rdi
add    %r11,%rbp
cmp    %rdi,%r13
jne    1700 <asg_vstep2d+0x5f0>
mov    0xd0(%rsp),%rbx
cmp    %r13,0x80(%rsp)
mov    0x10(%rsp),%r8
mov    0x60(%rsp),%r11
je     17bb <asg_vstep2d+0x6ab>
nopw   0x0(%rax,%rax,1)
lea    (%rbx,%r10,1),%ebp
add    $0x1,%ebp
shl    $0x20,%rbp
shl    $0x2,%r10
mov    %rdx,%rdi
sub    %r10,%rdi
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbp,%rax
sar    $0x1e,%rax
movss  (%rdx,%rax,1),%xmm0
subss  (%rdi,%rbx,4),%xmm0
mulss  (%rcx),%xmm0
addss  (%rsi,%rbx,4),%xmm0
movss  %xmm0,(%rsi,%rbx,4)
add    $0x1,%rbx
add    %r15,%rbp
cmp    %ebx,%r12d
jne    1790 <asg_vstep2d+0x680>
mov    0x28(%rsp),%rbx
jmp    1597 <asg_vstep2d+0x487>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %r8d,%ebx
jl     1510 <asg_vstep2d+0x400>
mov    0x140(%rsp),%rax
mov    (%rax),%rax
mov    %rax,0x58(%rsp)
mov    0xe0(%rsp),%rax
mov    (%rax,%r11,8),%rsi
mov    0xf8(%rsp),%rax
mov    (%rax),%rax
mov    %rax,0x50(%rsp)
mov    0xf0(%rsp),%rax
mov    (%rax,%r11,8),%rax
mov    %rax,0x20(%rsp)
mov    0x148(%rsp),%rax
mov    (%rax),%rax
mov    %rax,0x48(%rsp)
mov    0x10(%rsp),%rbx
cmpl   $0x3,0x18(%rsp)
jae    18d0 <asg_vstep2d+0x7c0>
mov    0x58(%rsp),%rax
lea    (%rax,%rbx,4),%rax
lea    (%rsi,%rbx,4),%rcx
mov    0x50(%rsp),%rdx
lea    (%rdx,%rbx,4),%rdx
mov    0x20(%rsp),%rsi
lea    0x4(%rsi,%rbx,4),%rsi
mov    0x48(%rsp),%rdi
lea    (%rdi,%rbx,4),%rdi
mov    %r12d,%ebp
sub    %ebx,%ebp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
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    1870 <asg_vstep2d+0x760>
jmp    1510 <asg_vstep2d+0x400>
nopl   0x0(%rax)
mov    0x10(%rsp),%rbx
lea    (%rsi,%rbx,4),%rax
mov    0xa0(%rsp),%r13
mov    %rsi,0x30(%rsp)
mov    0x30(%rsp),%rcx
lea    (%rcx,%r13,4),%rsi
mov    0x58(%rsp),%rdx
lea    (%rdx,%rbx,4),%rcx
lea    (%rdx,%r13,4),%r11
mov    0x50(%rsp),%rdi
lea    (%rdi,%rbx,4),%rdx
lea    (%rdi,%r13,4),%r9
mov    0x20(%rsp),%rbp
lea    0x0(%rbp,%rbx,4),%r10
mov    0xb8(%rsp),%rdi
lea    0x0(,%rdi,4),%r8
add    %rbp,%r8
mov    0x48(%rsp),%rbp
lea    0x0(,%rbx,4),%rdi
add    %rbp,%rdi
cmp    %r11,%rax
setb   0xf(%rsp)
cmp    %rsi,%rcx
setb   %r11b
cmp    %r9,%rax
setb   %r9b
cmp    %rsi,%rdx
setb   0x68(%rsp)
cmp    %r8,%rax
setb   %r8b
cmp    %rsi,%r10
lea    0x0(%rbp,%r13,4),%rbp
setb   %r10b
cmp    %rbp,%rax
setb   %bpl
cmp    %rsi,%rdi
mov    0x30(%rsp),%rsi
setb   0xc0(%rsp)
test   %r11b,0xf(%rsp)
mov    0x60(%rsp),%r11
jne    1836 <asg_vstep2d+0x726>
mov    0x10(%rsp),%rbx
and    0x68(%rsp),%r9b
jne    1836 <asg_vstep2d+0x726>
mov    0x10(%rsp),%rbx
and    %r10b,%r8b
jne    1836 <asg_vstep2d+0x726>
mov    0x10(%rsp),%rbx
and    0xc0(%rsp),%bpl
jne    1836 <asg_vstep2d+0x726>
mov    0x98(%rsp),%rsi
mov    0x20(%rsp),%rbp
lea    0x0(,%rsi,4),%rbx
add    %rbp,%rbx
xor    %ebp,%ebp
mov    0x90(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cvtps2pd (%rcx,%rbp,4),%xmm0
cvtps2pd 0x8(%rcx,%rbp,4),%xmm1
movups (%rax,%rbp,4),%xmm2
movups (%rdx,%rbp,4),%xmm3
mulps  %xmm2,%xmm3
cvtps2pd %xmm3,%xmm2
movhlps %xmm3,%xmm3
cvtps2pd %xmm3,%xmm3
movups -0x4(%rbx,%rbp,4),%xmm4
movups (%rbx,%rbp,4),%xmm5
addps  %xmm4,%xmm5
cvtps2pd %xmm5,%xmm4
movhlps %xmm5,%xmm5
cvtps2pd %xmm5,%xmm5
cvtps2pd 0x8(%rdi,%rbp,4),%xmm6
cvtps2pd (%rdi,%rbp,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,%rbp,4)
add    $0x4,%rbp
cmp    %rbp,%rsi
jne    19f0 <asg_vstep2d+0x8e0>
mov    0xb0(%rsp),%rbx
cmp    %rsi,0x80(%rsp)
mov    0x30(%rsp),%rsi
je     1510 <asg_vstep2d+0x400>
jmp    1836 <asg_vstep2d+0x726>
mov    0x160(%rsp),%rax
movslq (%rax),%r15
mov    0x168(%rsp),%rax
mov    (%rax),%r13d
mov    %r13d,%ecx
sub    %r15d,%ecx
lea    0x4(,%rcx,4),%rax
mov    %rax,0xd8(%rsp)
mov    0x90(%rsp),%rax
add    $0x1,%eax
mov    %eax,0x98(%rsp)
mov    0x180(%rsp),%r11d
lea    0x1(%r15,%rcx,1),%rax
mov    %rax,0x88(%rsp)
mov    %rcx,0xa8(%rsp)
lea    0x1(%rcx),%rax
lea    0x1(%r13),%r12d
mov    %rax,%rcx
and    $0xfffffffffffffff8,%rcx
lea    (%rcx,%r15,1),%rdx
mov    %rdx,0x58(%rsp)
movabs $0x1fffffff8,%rdx
or     $0x4,%rdx
mov    %rax,0x20(%rsp)
and    %rax,%rdx
lea    (%rdx,%r15,1),%rax
mov    %rax,0xb8(%rsp)
lea    0x4(%r15),%rax
mov    %rax,0xa0(%rsp)
movsd  0x14df(%rip),%xmm8
movapd 0x14c6(%rip),%xmm9
mov    0x68(%rsp),%rax
mov    %rax,0x18(%rsp)
mov    %r13,0x60(%rsp)
mov    %rcx,0x80(%rsp)
mov    %rdx,0xc0(%rsp)
jmp    1b7b <asg_vstep2d+0xa6b>
nopl   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rax
add    $0x1,%rax
mov    %rax,0x18(%rsp)
cmp    %eax,0x98(%rsp)
je     11ba <asg_vstep2d+0xaa>
cmp    %r15d,%r13d
jl     1bbd <asg_vstep2d+0xaad>
lea    0x0(,%r15,4),%rdi
mov    0x148(%rsp),%rax
add    0x8(%rax),%rdi
xor    %esi,%esi
mov    0xd8(%rsp),%rdx
call   1030 <memset@plt>
movapd 0x1454(%rip),%xmm9
movsd  0x145b(%rip),%xmm8
mov    0x180(%rsp),%r11d
cmpl   $0x0,0x180(%rsp)
jle    1de0 <asg_vstep2d+0xcd0>
mov    0x18(%rsp),%rax
add    $0x1,%rax
mov    %rax,0x28(%rsp)
xor    %r9d,%r9d
jmp    1be9 <asg_vstep2d+0xad9>
xchg   %ax,%ax
cmp    %r11,%r9
je     1de0 <asg_vstep2d+0xcd0>
mov    %r9,%rax
add    $0x1,%r9
cmp    %r15d,%r13d
jl     1be0 <asg_vstep2d+0xad0>
mov    0x28(%rsp),%rcx
lea    (%rcx,%rax,1),%edx
mov    0x18(%rsp),%rdi
sub    %rax,%rdi
mov    0x8(%r14),%rcx
lea    (%rcx,%rax,4),%r10
movslq %edx,%rax
mov    0x100(%rsp),%rdx
mov    (%rdx,%rax,8),%rsi
mov    (%rdx,%rdi,8),%rdi
mov    0x148(%rsp),%rax
mov    0x8(%rax),%rbx
mov    %r15,%rax
cmpl   $0x7,0xa8(%rsp)
07
jb     1d40 <asg_vstep2d+0xc30>
lea    (%rbx,%r15,4),%rax
mov    0x88(%rsp),%r11
lea    (%rbx,%r11,4),%rbp
lea    (%rcx,%r9,4),%rcx
lea    (%rsi,%r15,4),%r8
lea    (%rsi,%r11,4),%rdx
lea    (%rdi,%r15,4),%r13
lea    (%rdi,%r11,4),%r14
cmp    %rcx,%rax
setb   0x10(%rsp)
cmp    %rbp,%r10
setb   %r11b
cmp    %rdx,%rax
setb   %dl
cmp    %rbp,%r8
setb   %r8b
cmp    %r14,%rax
mov    0x188(%rsp),%r14
setb   %cl
cmp    %rbp,%r13
mov    0x60(%rsp),%r13
setb   %bpl
mov    %r15,%rax
test   %r11b,0x10(%rsp)
mov    0x180(%rsp),%r11d
jne    1d40 <asg_vstep2d+0xc30>
mov    %r15,%rax
and    %r8b,%dl
jne    1d40 <asg_vstep2d+0xc30>
mov    %r15,%rax
and    %bpl,%cl
jne    1d40 <asg_vstep2d+0xc30>
movss  (%r10),%xmm0
shufps $0x0,%xmm0,%xmm0
mov    0xa0(%rsp),%rcx
lea    (%rsi,%rcx,4),%rax
lea    (%rdi,%rcx,4),%rbp
lea    (%rbx,%rcx,4),%rcx
xor    %edx,%edx
mov    0x80(%rsp),%r8
nopl   0x0(%rax,%rax,1)
movups -0x10(%rax,%rdx,4),%xmm1
movups (%rax,%rdx,4),%xmm2
movups -0x10(%rbp,%rdx,4),%xmm3
subps  %xmm3,%xmm1
movups 0x0(%rbp,%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    1cf0 <asg_vstep2d+0xbe0>
mov    0x58(%rsp),%rax
cmp    %r8,0x20(%rsp)
je     1be0 <asg_vstep2d+0xad0>
mov    %r12d,%ecx
sub    %eax,%ecx
test   $0x1,%cl
jne    1d60 <asg_vstep2d+0xc50>
mov    %rax,%rbp
cmp    %eax,%r13d
jne    1d90 <asg_vstep2d+0xc80>
jmp    1be0 <asg_vstep2d+0xad0>
nopw   0x0(%rax,%rax,1)
movss  (%rsi,%rax,4),%xmm0
subss  (%rdi,%rax,4),%xmm0
mulss  (%r10),%xmm0
addss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
mov    %rax,%rbp
add    $0x1,%rbp
cmp    %eax,%r13d
je     1be0 <asg_vstep2d+0xad0>
nopl   0x0(%rax)
movss  (%rsi,%rbp,4),%xmm0
subss  (%rdi,%rbp,4),%xmm0
mulss  (%r10),%xmm0
addss  (%rbx,%rbp,4),%xmm0
movss  %xmm0,(%rbx,%rbp,4)
movss  0x4(%rsi,%rbp,4),%xmm0
subss  0x4(%rdi,%rbp,4),%xmm0
mulss  (%r10),%xmm0
addss  0x4(%rbx,%rbp,4),%xmm0
movss  %xmm0,0x4(%rbx,%rbp,4)
add    $0x2,%rbp
cmp    %ebp,%r12d
jne    1d90 <asg_vstep2d+0xc80>
jmp    1be0 <asg_vstep2d+0xad0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %r15d,%r13d
jl     1b60 <asg_vstep2d+0xa50>
mov    0x18(%rsp),%rcx
lea    0x1(%rcx),%rax
mov    %rax,0x28(%rsp)
mov    0x140(%rsp),%rax
mov    0x8(%rax),%r11
lea    (%r11,%rcx,4),%r10
mov    0xe8(%rsp),%rax
mov    (%rax,%rcx,8),%rdx
mov    0xf8(%rsp),%rax
mov    0x8(%rax),%r14
lea    (%r14,%rcx,4),%rsi
mov    0xf0(%rsp),%rax
mov    (%rax,%rcx,8),%rdi
mov    0x8(%rax,%rcx,8),%rax
mov    0x148(%rsp),%rbp
mov    0x8(%rbp),%rbx
mov    %r15,%rbp
cmpl   $0x3,0xa8(%rsp)
03
jae    1ec0 <asg_vstep2d+0xdb0>
nopl   (%rax)
movss  (%r10),%xmm0
cvtss2sd %xmm0,%xmm0
movss  (%rdx,%rbp,4),%xmm1
mulss  (%rsi),%xmm1
cvtss2sd %xmm1,%xmm1
movss  (%rdi,%rbp,4),%xmm2
addss  (%rax,%rbp,4),%xmm2
cvtss2sd %xmm2,%xmm2
movss  (%rbx,%rbp,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,%rbp,4)
add    $0x1,%rbp
cmp    %ebp,%r12d
jne    1e50 <asg_vstep2d+0xd40>
mov    0x188(%rsp),%r14
mov    0x180(%rsp),%r11d
mov    0x28(%rsp),%rax
jmp    1b69 <asg_vstep2d+0xa59>
nopl   (%rax)
lea    (%rdx,%r15,4),%r9
mov    0x88(%rsp),%r8
lea    (%rdx,%r8,4),%rbp
mov    %rbp,0x30(%rsp)
lea    (%r11,%rcx,4),%rbp
add    $0x4,%rbp
mov    %rbp,0x10(%rsp)
lea    0x4(%r14,%rcx,4),%rcx
mov    %rcx,0x70(%rsp)
lea    (%rdi,%r15,4),%rcx
mov    %rcx,0x18(%rsp)
lea    (%rdi,%r8,4),%rcx
mov    %rcx,0x48(%rsp)
lea    (%rax,%r15,4),%r11
lea    (%rax,%r8,4),%rcx
mov    %rcx,0x50(%rsp)
lea    (%rbx,%r15,4),%r14
lea    (%rbx,%r8,4),%rcx
mov    %rcx,0x78(%rsp)
cmp    0x10(%rsp),%r9
setb   0x10(%rsp)
mov    0x30(%rsp),%rcx
cmp    %rcx,%r10
setb   0xd0(%rsp)
cmp    0x70(%rsp),%r9
setb   %r8b
cmp    %rcx,%rsi
setb   0x70(%rsp)
cmp    0x48(%rsp),%r9
setb   0x48(%rsp)
cmp    %rcx,0x18(%rsp)
setb   0xc8(%rsp)
cmp    0x50(%rsp),%r9
setb   0x50(%rsp)
cmp    %rcx,%r11
setb   0xf(%rsp)
cmp    0x78(%rsp),%r9
setb   0x78(%rsp)
cmp    %rcx,%r14
setb   0x30(%rsp)
mov    %r15,%rbp
mov    0xd0(%rsp),%cl
test   %cl,0x10(%rsp)
jne    1e50 <asg_vstep2d+0xd40>
mov    %r15,%rbp
and    0x70(%rsp),%r8b
jne    1e50 <asg_vstep2d+0xd40>
mov    %r15,%rbp
mov    0xc8(%rsp),%cl
and    %cl,0x48(%rsp)
jne    1e50 <asg_vstep2d+0xd40>
mov    %r15,%rbp
mov    0xf(%rsp),%cl
and    %cl,0x50(%rsp)
jne    1e50 <asg_vstep2d+0xd40>
mov    %r15,%rbp
mov    0x30(%rsp),%cl
and    %cl,0x78(%rsp)
mov    0x18(%rsp),%rcx
jne    1e50 <asg_vstep2d+0xd40>
movss  (%r10),%xmm0
shufps $0x0,%xmm0,%xmm0
cvtps2pd %xmm0,%xmm0
movss  (%rsi),%xmm1
shufps $0x0,%xmm1,%xmm1
xor    %ebp,%ebp
mov    0xc0(%rsp),%r8
nopl   0x0(%rax)
movups (%r9,%rbp,4),%xmm2
mulps  %xmm1,%xmm2
cvtps2pd %xmm2,%xmm3
movhlps %xmm2,%xmm2
cvtps2pd %xmm2,%xmm2
movups (%rcx,%rbp,4),%xmm4
movups (%r11,%rbp,4),%xmm5
addps  %xmm4,%xmm5
cvtps2pd %xmm5,%xmm4
movhlps %xmm5,%xmm5
cvtps2pd %xmm5,%xmm5
cvtps2pd 0x8(%r14,%rbp,4),%xmm6
cvtps2pd (%r14,%rbp,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,%rbp,4)
add    $0x4,%rbp
cmp    %rbp,%r8
jne    2000 <asg_vstep2d+0xef0>
mov    0xb8(%rsp),%rbp
cmp    %r8,0x20(%rsp)
jne    1e50 <asg_vstep2d+0xd40>
jmp    1ea3 <asg_vstep2d+0xd93>
mov    0x68(%rsp),%rax
lea    -0x1(%rax),%r9d
add    $0x1,%edx
mov    %r14d,%r10d
add    $0xffffffffffffffff,%r10
mov    %r10,%rdi
and    $0xfffffffffffffffe,%rdi
lea    (%r11,%rax,8),%rbx
jmp    20bc <asg_vstep2d+0xfac>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %ecx,%edx
je     13e4 <asg_vstep2d+0x2d4>
cmp    $0x2,%r14d
jl     20b0 <asg_vstep2d+0xfa0>
mov    $0x1,%eax
je     212a <asg_vstep2d+0x101a>
mov    $0xffffffffffffffff,%rax
mov    %r12d,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %esi,%rsi
mov    (%r11,%rsi,8),%rbp
movss  0x0(%rbp,%rcx,4),%xmm0
mov    (%rbx,%rax,8),%rbp
movss  %xmm0,0x0(%rbp,%rcx,4)
lea    0x1(%rsi),%ebp
movslq %ebp,%rbp
mov    (%r11,%rbp,8),%rbp
movss  0x0(%rbp,%rcx,4),%xmm0
mov    -0x8(%rbx,%rax,8),%rbp
movss  %xmm0,0x0(%rbp,%rcx,4)
add    $0x2,%esi
lea    (%rdi,%rax,1),%rbp
add    $0xfffffffffffffffe,%rbp
add    $0xfffffffffffffffe,%rax
cmp    $0xffffffffffffffff,%rbp
jne    20e0 <asg_vstep2d+0xfd0>
neg    %rax
test   $0x1,%r10b
je     20b0 <asg_vstep2d+0xfa0>
lea    (%r9,%rax,1),%esi
movslq %esi,%rsi
mov    (%r11,%rsi,8),%rsi
movss  (%rsi,%rcx,4),%xmm0
mov    0x68(%rsp),%rsi
sub    %rax,%rsi
mov    (%r11,%rsi,8),%rax
movss  %xmm0,(%rax,%rcx,4)
jmp    20b0 <asg_vstep2d+0xfa0>
movslq %r15d,%r9
lea    0x1(%r15),%r8d
add    $0x1,%ecx
mov    %r14d,%r10d
add    $0xffffffffffffffff,%r10
lea    (%r11,%r9,8),%rbp
add    $0x8,%rbp
mov    %r10,%rdi
and    $0xfffffffffffffffe,%rdi
neg    %rdi
jmp    218c <asg_vstep2d+0x107c>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %eax,%ecx
je     1408 <asg_vstep2d+0x2f8>
cmp    $0x2,%r14d
jl     2180 <asg_vstep2d+0x1070>
mov    $0x1,%esi
je     21f4 <asg_vstep2d+0x10e4>
mov    $0x1,%esi
mov    %r15d,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %edx,%rdx
mov    (%r11,%rdx,8),%rbx
movss  (%rbx,%rax,4),%xmm0
mov    -0x8(%rbp,%rsi,8),%rbx
movss  %xmm0,(%rbx,%rax,4)
lea    -0x1(%rdx),%ebx
movslq %ebx,%rbx
mov    (%r11,%rbx,8),%rbx
movss  (%rbx,%rax,4),%xmm0
mov    0x0(%rbp,%rsi,8),%rbx
movss  %xmm0,(%rbx,%rax,4)
add    $0xfffffffe,%edx
lea    (%rdi,%rsi,1),%rbx
add    $0x2,%rbx
add    $0x2,%rsi
cmp    $0x1,%rbx
jne    21b0 <asg_vstep2d+0x10a0>
test   $0x1,%r10b
je     2180 <asg_vstep2d+0x1070>
mov    %r8d,%edx
sub    %esi,%edx
movslq %edx,%rdx
mov    (%r11,%rdx,8),%rdx
movss  (%rdx,%rax,4),%xmm0
add    %r9,%rsi
mov    (%r11,%rsi,8),%rdx
movss  %xmm0,(%rdx,%rax,4)
jmp    2180 <asg_vstep2d+0x1070>

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

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