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


x86 assembly (clang, -O0):
<asg_pstep2d>:
push   %rbp
mov    %rsp,%rbp
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%eax
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     13c1 <asg_pstep2d+0x2c1>
mov    0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x28(%rbp),%rcx
cmp    (%rcx),%eax
jg     118b <asg_pstep2d+0x8b>
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    115e <asg_pstep2d+0x5e>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    1284 <asg_pstep2d+0x184>
mov    0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x28(%rbp),%rcx
cmp    (%rcx),%eax
jg     1271 <asg_pstep2d+0x171>
mov    0x48(%rbp),%rax
mov    (%rax),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
sub    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
mov    0x48(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11a7 <asg_pstep2d+0xa7>
jmp    1276 <asg_pstep2d+0x176>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1192 <asg_pstep2d+0x92>
mov    0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x28(%rbp),%rcx
cmp    (%rcx),%eax
jg     13ae <asg_pstep2d+0x2ae>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x18(%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    128d <asg_pstep2d+0x18d>
jmp    13b3 <asg_pstep2d+0x2b3>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1145 <asg_pstep2d+0x45>
mov    0x30(%rbp),%rax
cmpl   $0x0,(%rax)
je     148e <asg_pstep2d+0x38e>
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     1489 <asg_pstep2d+0x389>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x20(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    1476 <asg_pstep2d+0x376>
mov    -0x10(%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
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x20(%rbp),%rcx
mov    (%rcx),%ecx
sub    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    140f <asg_pstep2d+0x30f>
jmp    147b <asg_pstep2d+0x37b>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13d8 <asg_pstep2d+0x2d8>
jmp    148e <asg_pstep2d+0x38e>
mov    0x38(%rbp),%rax
cmpl   $0x0,(%rax)
je     155b <asg_pstep2d+0x45b>
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     1556 <asg_pstep2d+0x456>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    1543 <asg_pstep2d+0x443>
mov    -0x10(%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
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%ecx
add    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14dc <asg_pstep2d+0x3dc>
jmp    1548 <asg_pstep2d+0x448>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    14a5 <asg_pstep2d+0x3a5>
jmp    155b <asg_pstep2d+0x45b>
mov    0x30(%rbp),%rax
cmpl   $0x0,0x4(%rax)
je     162a <asg_pstep2d+0x52a>
mov    0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x28(%rbp),%rcx
cmp    (%rcx),%eax
jg     1625 <asg_pstep2d+0x525>
mov    -0x18(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    1612 <asg_pstep2d+0x512>
mov    -0x18(%rbp),%rax
mov    0x20(%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
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    -0x3c(%rbp),%ecx
sub    $0x1,%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    15a9 <asg_pstep2d+0x4a9>
jmp    1617 <asg_pstep2d+0x517>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1572 <asg_pstep2d+0x472>
jmp    162a <asg_pstep2d+0x52a>
mov    0x38(%rbp),%rax
cmpl   $0x0,0x4(%rax)
je     16f9 <asg_pstep2d+0x5f9>
mov    0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x28(%rbp),%rcx
cmp    (%rcx),%eax
jg     16f4 <asg_pstep2d+0x5f4>
mov    -0x18(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    16e1 <asg_pstep2d+0x5e1>
mov    -0x18(%rbp),%rax
mov    0x28(%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
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    -0x3c(%rbp),%ecx
add    $0x1,%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    1678 <asg_pstep2d+0x578>
jmp    16e6 <asg_pstep2d+0x5e6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1641 <asg_pstep2d+0x541>
jmp    16f9 <asg_pstep2d+0x5f9>
pop    %rbp
ret

x86 assembly (clang, -O2):
<asg_pstep2d>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %r9,0x70(%rsp)
mov    %r8,0xb0(%rsp)
mov    %rcx,0xa8(%rsp)
mov    %rdx,%r15
mov    %rsi,0x30(%rsp)
mov    %rdi,0x68(%rsp)
mov    0x120(%rsp),%r12d
mov    0x110(%rsp),%r11
mov    0x108(%rsp),%rcx
mov    0x100(%rsp),%rax
mov    0x4(%rax),%eax
mov    0x4(%rcx),%ecx
mov    %rax,0x18(%rsp)
mov    %rcx,0x20(%rsp)
cmp    %ecx,%eax
jg     1722 <asg_pstep2d+0x612>
mov    %r15,0x50(%rsp)
mov    0xf8(%rsp),%rdx
movslq 0x18(%rsp),%rcx
mov    0x100(%rsp),%rax
movslq (%rax),%rsi
mov    0x108(%rsp),%rax
mov    (%rax),%edi
lea    (%rdx,%rsi,4),%r13
mov    %edi,%edx
sub    %esi,%edx
lea    0x4(,%rdx,4),%rax
mov    %rax,0x60(%rsp)
mov    0x20(%rsp),%rax
add    $0x1,%eax
mov    %eax,0x14(%rsp)
mov    %r12d,%eax
mov    %rax,0x38(%rsp)
mov    %rdx,0xa0(%rsp)
lea    0x1(%rdx),%rax
mov    %rax,0x98(%rsp)
and    $0xfffffffffffffffc,%rax
mov    %rdi,0x28(%rsp)
lea    0x1(%rdi),%edx
mov    %edx,0x44(%rsp)
mov    %edx,%r9d
sub    %esi,%r9d
mov    %rax,0x90(%rsp)
add    %rsi,%rax
mov    %rax,0x88(%rsp)
mov    %rsi,0x8(%rsp)
lea    -0x1(%rsi),%eax
mov    %rax,0x78(%rsp)
mov    %rcx,0x48(%rsp)
mov    %r9,0x80(%rsp)
jmp    1246 <asg_pstep2d+0x136>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rcx
cmp    %ecx,0x14(%rsp)
mov    0x120(%rsp),%r12d
je     14f5 <asg_pstep2d+0x3e5>
mov    %rcx,0x58(%rsp)
mov    0x28(%rsp),%rax
cmp    0x8(%rsp),%eax
jl     1265 <asg_pstep2d+0x155>
mov    %r13,%rdi
xor    %esi,%esi
mov    0x60(%rsp),%rdx
call   1030 <memset@plt>
test   %r12d,%r12d
jle    1430 <asg_pstep2d+0x320>
mov    $0xffffffff,%r10d
mov    0x8(%rsp),%r11
mov    0x78(%rsp),%r8
xor    %r14d,%r14d
jmp    12ab <asg_pstep2d+0x19b>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r14
add    $0xffffffffffffffff,%r8
add    $0x1,%r11
add    $0xffffffff,%r10d
cmp    0x38(%rsp),%r14
je     1430 <asg_pstep2d+0x320>
mov    0x28(%rsp),%rax
cmp    0x8(%rsp),%eax
jl     1290 <asg_pstep2d+0x180>
mov    0x58(%rsp),%rdi
lea    (%r14,%rdi,1),%rax
mov    %r14d,%ecx
not    %ecx
add    %edi,%ecx
mov    0x128(%rsp),%rsi
mov    (%rsi),%rdx
mov    0x8(%rsi),%rsi
movss  (%rdx,%r14,4),%xmm0
mov    0xa8(%rsp),%rdx
mov    (%rdx,%rdi,8),%r9
movss  (%rsi,%r14,4),%xmm1
mov    0xb0(%rsp),%rsi
mov    (%rsi,%rax,8),%r15
movslq %ecx,%rax
mov    (%rsi,%rax,8),%rbp
mov    0x8(%rsp),%rdi
cmpl   $0x3,0xa0(%rsp)
03
jb     13b5 <asg_pstep2d+0x2a5>
mov    %r14d,%eax
not    %eax
mov    0x8(%rsp),%rdi
lea    (%rdi,%rax,1),%ecx
add    0x28(%rsp),%eax
cmp    %ecx,%eax
jl     13b5 <asg_pstep2d+0x2a5>
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
movaps %xmm0,%xmm3
shufps $0x0,%xmm0,%xmm3
lea    (%r9,%r11,4),%rax
mov    0x8(%rsp),%rsi
lea    (%r15,%rsi,4),%rcx
lea    0x0(,%rsi,4),%rsi
add    %rbp,%rsi
xor    %ebx,%ebx
mov    0x90(%rsp),%rdx
nopl   0x0(%rax)
movups (%rax,%rbx,4),%xmm4
lea    (%r8,%rbx,1),%edi
movslq %edi,%rdi
movups (%r9,%rdi,4),%xmm5
subps  %xmm5,%xmm4
mulps  %xmm3,%xmm4
movups (%rcx,%rbx,4),%xmm5
movups (%rsi,%rbx,4),%xmm6
subps  %xmm6,%xmm5
mulps  %xmm2,%xmm5
addps  %xmm4,%xmm5
movups 0x0(%r13,%rbx,4),%xmm4
addps  %xmm5,%xmm4
movups %xmm4,0x0(%r13,%rbx,4)
add    $0x4,%rbx
cmp    %rbx,%rdx
jne    1360 <asg_pstep2d+0x250>
mov    0x88(%rsp),%rdi
cmp    %rdx,0x98(%rsp)
je     1290 <asg_pstep2d+0x180>
lea    (%r15,%rdi,4),%r15
lea    0x0(,%rdi,4),%rax
add    %rbp,%rax
mov    0xf8(%rsp),%rcx
lea    (%rcx,%rdi,4),%rcx
lea    (%rdi,%r14,1),%rdx
lea    (%r9,%rdx,4),%rsi
lea    (%r10,%rdi,1),%ebp
mov    0x44(%rsp),%edx
sub    %edi,%edx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rsi,%rdi,4),%xmm2
lea    (%rdi,%rbp,1),%r12d
movslq %r12d,%rbx
subss  (%r9,%rbx,4),%xmm2
movss  (%r15,%rdi,4),%xmm3
subss  (%rax,%rdi,4),%xmm3
mulss  %xmm1,%xmm3
mulss  %xmm0,%xmm2
addss  %xmm3,%xmm2
addss  (%rcx,%rdi,4),%xmm2
movss  %xmm2,(%rcx,%rdi,4)
add    $0x1,%rdi
cmp    %edi,%edx
jne    13f0 <asg_pstep2d+0x2e0>
jmp    1290 <asg_pstep2d+0x180>
mov    0x28(%rsp),%rax
cmp    0x8(%rsp),%eax
mov    0x80(%rsp),%r9
mov    0x58(%rsp),%rcx
jl     1230 <asg_pstep2d+0x120>
mov    0x70(%rsp),%rdi
mov    0x8(%rdi),%r8
mov    0xf0(%rsp),%rbp
mov    0x8(%rbp),%r10
mov    0x8(%rsp),%rax
lea    0x0(,%rax,4),%rdx
mov    0x30(%rsp),%rax
mov    (%rax,%rcx,8),%rsi
add    %rdx,%rsi
mov    (%rdi),%rdi
add    %rdx,%rdi
mov    0x68(%rsp),%rax
mov    (%rax,%rcx,8),%rbx
add    %rdx,%rbx
mov    0x0(%rbp),%rax
add    %rdx,%rax
mov    0x50(%rsp),%rbp
add    0x0(%rbp,%rcx,8),%rdx
xor    %ebp,%ebp
nop
movss  (%rsi,%rbp,4),%xmm0
movss  0x0(%r13,%rbp,4),%xmm1
movss  (%rbx,%rbp,4),%xmm2
mulss  %xmm1,%xmm2
mulss  (%rdi,%rbp,4),%xmm0
subss  %xmm2,%xmm0
mulss  (%rax,%rbp,4),%xmm0
movss  %xmm0,(%rsi,%rbp,4)
movss  (%rdx,%rbp,4),%xmm0
mulss  (%rbx,%rbp,4),%xmm1
mulss  (%r8,%rcx,4),%xmm0
subss  %xmm1,%xmm0
mulss  (%r10,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rbp,4)
add    $0x1,%rbp
cmp    %ebp,%r9d
jne    14a0 <asg_pstep2d+0x390>
jmp    1230 <asg_pstep2d+0x120>
mov    0x110(%rsp),%rax
cmpl   $0x0,(%rax)
mov    0x50(%rsp),%r15
je     1606 <asg_pstep2d+0x4f6>
mov    0x18(%rsp),%rax
cmp    0x20(%rsp),%eax
jg     1606 <asg_pstep2d+0x4f6>
mov    0x100(%rsp),%rax
mov    (%rax),%r11d
lea    -0x1(%r11),%r9d
movslq %r9d,%r14
mov    0x38(%rsp),%rax
lea    -0x1(%rax),%r10
mov    %r10,%rdi
and    $0xfffffffffffffffe,%rdi
lea    -0x3(%r11),%r8d
movaps 0xab9(%rip),%xmm0
mov    0x48(%rsp),%rbx
jmp    155e <asg_pstep2d+0x44e>
xchg   %ax,%ax
add    $0x1,%rbx
cmp    %ebx,0x14(%rsp)
je     1606 <asg_pstep2d+0x4f6>
mov    0x30(%rsp),%rax
mov    (%rax,%rbx,8),%rbp
movl   $0x0,0x0(%rbp,%r14,4)
cmp    $0x2,%r12d
jl     1550 <asg_pstep2d+0x440>
mov    $0x1,%ecx
je     15da <asg_pstep2d+0x4ca>
mov    $0xffffffffffffffff,%rcx
mov    %r11d,%eax
mov    %r8d,%esi
nopw   0x0(%rax,%rax,1)
cltq
movss  0x0(%rbp,%rax,4),%xmm1
xorps  %xmm0,%xmm1
lea    0x1(%rsi),%edx
movslq %edx,%rdx
movss  %xmm1,0x0(%rbp,%rdx,4)
lea    0x1(%rax),%edx
movslq %edx,%rdx
movss  0x0(%rbp,%rdx,4),%xmm1
xorps  %xmm0,%xmm1
movslq %esi,%rsi
movss  %xmm1,0x0(%rbp,%rsi,4)
add    $0xfffffffe,%esi
add    $0x2,%eax
lea    (%rdi,%rcx,1),%rdx
add    $0xfffffffffffffffe,%rdx
add    $0xfffffffffffffffe,%rcx
cmp    $0xffffffffffffffff,%rdx
jne    1590 <asg_pstep2d+0x480>
neg    %rcx
test   $0x1,%r10b
je     1550 <asg_pstep2d+0x440>
lea    (%r9,%rcx,1),%eax
cltq
movss  0x0(%rbp,%rax,4),%xmm1
xorps  %xmm0,%xmm1
not    %ecx
add    %r11d,%ecx
movslq %ecx,%rax
movss  %xmm1,0x0(%rbp,%rax,4)
jmp    1550 <asg_pstep2d+0x440>
mov    0x118(%rsp),%rax
cmpl   $0x0,(%rax)
mov    0x110(%rsp),%r11
mov    0x48(%rsp),%r13
je     1722 <asg_pstep2d+0x612>
mov    0x20(%rsp),%rax
cmp    %eax,0x18(%rsp)
jg     1722 <asg_pstep2d+0x612>
mov    0x108(%rsp),%rax
mov    (%rax),%r9d
lea    0x1(%r9),%r10d
movslq %r10d,%rdx
mov    0x38(%rsp),%rdi
add    $0xffffffffffffffff,%rdi
lea    0x3(%r9),%r8d
mov    %rdi,%r14
and    $0xfffffffffffffffe,%rdi
neg    %rdi
movaps 0x99d(%rip),%xmm0
jmp    167f <asg_pstep2d+0x56f>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r13
cmp    %r13d,0x14(%rsp)
je     1722 <asg_pstep2d+0x612>
mov    0x30(%rsp),%rax
mov    (%rax,%r13,8),%rbp
movl   $0x0,0x0(%rbp,%rdx,4)
cmp    $0x2,%r12d
jl     1670 <asg_pstep2d+0x560>
mov    $0x1,%ebx
je     16f7 <asg_pstep2d+0x5e7>
mov    $0x1,%ebx
mov    %r8d,%esi
mov    %r9d,%eax
nopl   0x0(%rax,%rax,1)
cltq
movss  0x0(%rbp,%rax,4),%xmm1
xorps  %xmm0,%xmm1
lea    -0x1(%rsi),%ecx
movslq %ecx,%rcx
movss  %xmm1,0x0(%rbp,%rcx,4)
lea    -0x1(%rax),%ecx
movslq %ecx,%rcx
movss  0x0(%rbp,%rcx,4),%xmm1
xorps  %xmm0,%xmm1
movslq %esi,%rsi
movss  %xmm1,0x0(%rbp,%rsi,4)
add    $0xfffffffe,%eax
add    $0x2,%esi
lea    (%rdi,%rbx,1),%rcx
add    $0x2,%rcx
add    $0x2,%rbx
cmp    $0x1,%rcx
jne    16b0 <asg_pstep2d+0x5a0>
test   $0x1,%r14b
je     1670 <asg_pstep2d+0x560>
mov    %r10d,%eax
sub    %ebx,%eax
cltq
movss  0x0(%rbp,%rax,4),%xmm1
xorps  %xmm0,%xmm1
add    %r10d,%ebx
movslq %ebx,%rax
movss  %xmm1,0x0(%rbp,%rax,4)
jmp    1670 <asg_pstep2d+0x560>
cmpl   $0x0,0x4(%r11)
je     1742 <asg_pstep2d+0x632>
mov    0x100(%rsp),%rax
movslq (%rax),%rax
mov    0x108(%rsp),%rcx
mov    (%rcx),%ecx
cmp    %ecx,%eax
jle    1784 <asg_pstep2d+0x674>
mov    0x118(%rsp),%rax
cmpl   $0x0,0x4(%rax)
mov    0x20(%rsp),%r14
je     1772 <asg_pstep2d+0x662>
mov    0x100(%rsp),%rax
movslq (%rax),%rax
mov    0x108(%rsp),%rcx
mov    (%rcx),%ecx
cmp    %ecx,%eax
jle    187b <asg_pstep2d+0x76b>
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x18(%rsp),%rsi
lea    -0x1(%rsi),%r9d
movslq %r9d,%rdx
mov    (%r15,%rdx,8),%r11
add    $0x1,%ecx
mov    %r12d,%r10d
add    $0xffffffffffffffff,%r10
mov    %r10,%rdi
and    $0xfffffffffffffffe,%rdi
lea    -0x3(%rsi),%r8d
movaps 0x850(%rip),%xmm0
jmp    17cc <asg_pstep2d+0x6bc>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rax
cmp    %eax,%ecx
je     1742 <asg_pstep2d+0x632>
movl   $0x0,(%r11,%rax,4)
cmp    $0x2,%r12d
jl     17c0 <asg_pstep2d+0x6b0>
mov    $0x1,%ebx
je     1847 <asg_pstep2d+0x737>
mov    $0xffffffffffffffff,%rbx
mov    0x18(%rsp),%rdx
mov    %r8d,%ebp
movslq %edx,%rdx
mov    (%r15,%rdx,8),%rsi
movss  (%rsi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
lea    0x1(%rbp),%esi
movslq %esi,%rsi
mov    (%r15,%rsi,8),%rsi
movss  %xmm1,(%rsi,%rax,4)
lea    0x1(%rdx),%esi
movslq %esi,%rsi
mov    (%r15,%rsi,8),%rsi
movss  (%rsi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movslq %ebp,%rbp
mov    (%r15,%rbp,8),%rsi
movss  %xmm1,(%rsi,%rax,4)
add    $0xfffffffe,%ebp
add    $0x2,%edx
lea    (%rdi,%rbx,1),%rsi
add    $0xfffffffffffffffe,%rsi
add    $0xfffffffffffffffe,%rbx
cmp    $0xffffffffffffffff,%rsi
jne    17f0 <asg_pstep2d+0x6e0>
neg    %rbx
test   $0x1,%r10b
je     17c0 <asg_pstep2d+0x6b0>
lea    (%r9,%rbx,1),%edx
movslq %edx,%rdx
mov    (%r15,%rdx,8),%rdx
movss  (%rdx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
not    %ebx
add    0x18(%rsp),%ebx
movslq %ebx,%rdx
mov    (%r15,%rdx,8),%rdx
movss  %xmm1,(%rdx,%rax,4)
jmp    17c0 <asg_pstep2d+0x6b0>
lea    0x1(%r14),%r9d
movslq %r9d,%rdx
mov    (%r15,%rdx,8),%r11
add    $0x1,%ecx
mov    %r12d,%r10d
add    $0xffffffffffffffff,%r10
lea    0x3(%r14),%r8d
mov    %r10,%rdi
and    $0xfffffffffffffffe,%rdi
neg    %rdi
movaps 0x75b(%rip),%xmm0
jmp    18bc <asg_pstep2d+0x7ac>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %eax,%ecx
je     1772 <asg_pstep2d+0x662>
movl   $0x0,(%r11,%rax,4)
cmp    $0x2,%r12d
jl     18b0 <asg_pstep2d+0x7a0>
mov    $0x1,%ebp
je     1934 <asg_pstep2d+0x824>
mov    $0x1,%ebp
mov    %r8d,%edx
mov    %r14d,%ebx
nopl   0x0(%rax)
movslq %ebx,%rbx
mov    (%r15,%rbx,8),%rsi
movss  (%rsi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
lea    -0x1(%rdx),%esi
movslq %esi,%rsi
mov    (%r15,%rsi,8),%rsi
movss  %xmm1,(%rsi,%rax,4)
lea    -0x1(%rbx),%esi
movslq %esi,%rsi
mov    (%r15,%rsi,8),%rsi
movss  (%rsi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movslq %edx,%rdx
mov    (%r15,%rdx,8),%rsi
movss  %xmm1,(%rsi,%rax,4)
add    $0xfffffffe,%ebx
add    $0x2,%edx
lea    (%rdi,%rbp,1),%rsi
add    $0x2,%rsi
add    $0x2,%rbp
cmp    $0x1,%rsi
jne    18e0 <asg_pstep2d+0x7d0>
test   $0x1,%r10b
je     18b0 <asg_pstep2d+0x7a0>
mov    %r9d,%edx
sub    %ebp,%edx
movslq %edx,%rdx
mov    (%r15,%rdx,8),%rdx
movss  (%rdx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
add    %r9d,%ebp
movslq %ebp,%rdx
mov    (%r15,%rdx,8),%rdx
movss  %xmm1,(%rdx,%rax,4)
jmp    18b0 <asg_pstep2d+0x7a0>

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

LLVM IR (-O2):
define void @asg_pstep2d(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 %12, float** noalias nocapture %13) {
%15 = getelementptr inbounds i32, i32* %8, i64 1
%16 = load i32, i32* %15
%17 = getelementptr inbounds i32, i32* %9, i64 1
%18 = load i32, i32* %17
%19 = icmp sgt i32 %16, %18
br i1 %19, label %322, label %20
20: ; preds = %14
%21 = load i32, i32* %8
%22 = load i32, i32* %9
%23 = icmp slt i32 %22, %21
%24 = icmp sgt i32 %12, 0
%25 = getelementptr inbounds float*, float** %13, i64 1
%26 = getelementptr inbounds float*, float** %5, i64 1
%27 = getelementptr inbounds float*, float** %6, i64 1
%28 = sext i32 %21 to i64
%29 = getelementptr float, float* %7, i64 %28
%30 = bitcast float* %29 to i8*
%31 = sub i32 %22, %21
%32 = zext i32 %31 to i64
%33 = shl nuw nsw i64 %32, 2
%34 = add nuw nsw i64 %33, 4
%35 = add i32 %22, 1
%36 = sext i32 %16 to i64
%37 = add i32 %18, 1
%38 = zext i32 %12 to i64
%39 = sub i32 %22, %21
%40 = zext i32 %39 to i64
%41 = add nuw nsw i64 %40, 1
%42 = icmp ult i32 %39, 3
%43 = and i64 %41, 8589934588
%44 = add nsw i64 %43, %28
%45 = icmp eq i64 %41, %43
br label %46
46: ; preds = %20, %186
%47 = phi i64 [ %36, %20 ], [ %187, %186 ]
br i1 %23, label %49, label %48
48: ; preds = %46
br label %49
49: ; preds = %48, %46
br i1 %24, label %50, label %53
50: ; preds = %49
%51 = getelementptr inbounds float*, float** %3, i64 %47
%52 = trunc i64 %47 to i32
br label %67
53: ; preds = %155, %49
br i1 %23, label %186, label %54
54: ; preds = %53
%55 = getelementptr inbounds float*, float** %1, i64 %47
%56 = load float*, float** %55
%57 = load float*, float** %5
%58 = getelementptr inbounds float*, float** %0, i64 %47
%59 = load float*, float** %58
%60 = load float*, float** %6
%61 = getelementptr inbounds float*, float** %2, i64 %47
%62 = load float*, float** %61
%63 = load float*, float** %26
%64 = getelementptr inbounds float, float* %63, i64 %47
%65 = load float*, float** %27
%66 = getelementptr inbounds float, float* %65, i64 %47
br label %158
67: ; preds = %50, %155
%68 = phi i64 [ 0, %50 ], [ %156, %155 ]
%69 = trunc i64 %68 to i32
%70 = xor i32 %69, -1
br i1 %23, label %155, label %71
71: ; preds = %67
%72 = add i32 %21, %70
%73 = load float*, float** %13
%74 = getelementptr inbounds float, float* %73, i64 %68
%75 = load float, float* %74
%76 = load float*, float** %51
%77 = load float*, float** %25
%78 = getelementptr inbounds float, float* %77, i64 %68
%79 = load float, float* %78
%80 = add nsw i64 %68, %47
%81 = getelementptr inbounds float*, float** %4, i64 %80
%82 = load float*, float** %81
%83 = trunc i64 %68 to i32
%84 = xor i32 %83, -1
%85 = add i32 %52, %84
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds float*, float** %4, i64 %86
%88 = load float*, float** %87
%89 = add i32 %22, %70
%90 = icmp slt i32 %89, %72
%91 = select i1 %42, i1 true, i1 %90
br i1 %91, label %129, label %92
92: ; preds = %71
%93 = insertelement <4 x float> poison, float %79, i64 0
%94 = shufflevector <4 x float> %93, <4 x float> poison, <4 x i32> zeroinitializer
%95 = insertelement <4 x float> poison, float %75, i64 0
%96 = shufflevector <4 x float> %95, <4 x float> poison, <4 x i32> zeroinitializer
br label %97
97: ; preds = %97, %92
%98 = phi i64 [ 0, %92 ], [ %126, %97 ]
%99 = add i64 %98, %28
%100 = trunc i64 %98 to i32
%101 = add i32 %21, %100
%102 = add nsw i64 %99, %68
%103 = getelementptr inbounds float, float* %76, i64 %102
%104 = bitcast float* %103 to <4 x float>*
%105 = load <4 x float>, <4 x float>* %104
%106 = add i32 %101, %84
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds float, float* %76, i64 %107
%109 = bitcast float* %108 to <4 x float>*
%110 = load <4 x float>, <4 x float>* %109
%111 = fsub <4 x float> %105, %110
%112 = getelementptr inbounds float, float* %82, i64 %99
%113 = bitcast float* %112 to <4 x float>*
%114 = load <4 x float>, <4 x float>* %113
%115 = getelementptr inbounds float, float* %88, i64 %99
%116 = bitcast float* %115 to <4 x float>*
%117 = load <4 x float>, <4 x float>* %116
%118 = fsub <4 x float> %114, %117
%119 = fmul <4 x float> %94, %118
%120 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %96, <4 x float> %111, <4 x float> %119)
%121 = getelementptr inbounds float, float* %7, i64 %99
%122 = bitcast float* %121 to <4 x float>*
%123 = load <4 x float>, <4 x float>* %122
%124 = fadd <4 x float> %123, %120
%125 = bitcast float* %121 to <4 x float>*
store <4 x float> %124, <4 x float>* %125
%126 = add nuw i64 %98, 4
%127 = icmp eq i64 %126, %43
br i1 %127, label %128, label %97
128: ; preds = %97
br i1 %45, label %155, label %129
129: ; preds = %71, %128
%130 = phi i64 [ %28, %71 ], [ %44, %128 ]
br label %131
131: ; preds = %129, %131
%132 = phi i64 [ %152, %131 ], [ %130, %129 ]
%133 = add nsw i64 %132, %68
%134 = getelementptr inbounds float, float* %76, i64 %133
%135 = load float, float* %134
%136 = trunc i64 %132 to i32
%137 = add i32 %136, %84
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds float, float* %76, i64 %138
%140 = load float, float* %139
%141 = fsub float %135, %140
%142 = getelementptr inbounds float, float* %82, i64 %132
%143 = load float, float* %142
%144 = getelementptr inbounds float, float* %88, i64 %132
%145 = load float, float* %144
%146 = fsub float %143, %145
%147 = fmul float %79, %146
%148 = tail call float @llvm.fmuladd.f32(float %75, float %141, float %147)
%149 = getelementptr inbounds float, float* %7, i64 %132
%150 = load float, float* %149
%151 = fadd float %150, %148
store float %151, float* %149
%152 = add nsw i64 %132, 1
%153 = trunc i64 %152 to i32
%154 = icmp eq i32 %35, %153
br i1 %154, label %155, label %131
155: ; preds = %131, %128, %67
%156 = add nuw nsw i64 %68, 1
%157 = icmp eq i64 %156, %38
br i1 %157, label %53, label %67
158: ; preds = %54, %158
%159 = phi i64 [ %28, %54 ], [ %183, %158 ]
%160 = getelementptr inbounds float, float* %56, i64 %159
%161 = load float, float* %160
%162 = getelementptr inbounds float, float* %57, i64 %159
%163 = load float, float* %162
%164 = getelementptr inbounds float, float* %59, i64 %159
%165 = load float, float* %164
%166 = getelementptr inbounds float, float* %7, i64 %159
%167 = load float, float* %166
%168 = fneg float %165
%169 = fmul float %167, %168
%170 = tail call float @llvm.fmuladd.f32(float %161, float %163, float %169)
%171 = getelementptr inbounds float, float* %60, i64 %159
%172 = load float, float* %171
%173 = fmul float %170, %172
store float %173, float* %160
%174 = getelementptr inbounds float, float* %62, i64 %159
%175 = load float, float* %174
%176 = load float, float* %64
%177 = load float, float* %164
%178 = fneg float %177
%179 = fmul float %167, %178
%180 = tail call float @llvm.fmuladd.f32(float %175, float %176, float %179)
%181 = load float, float* %66
%182 = fmul float %180, %181
store float %182, float* %174
%183 = add nsw i64 %159, 1
%184 = trunc i64 %183 to i32
%185 = icmp eq i32 %35, %184
br i1 %185, label %186, label %158
186: ; preds = %158, %53
%187 = add nsw i64 %47, 1
%188 = trunc i64 %187 to i32
%189 = icmp eq i32 %37, %188
br i1 %189, label %190, label %46
190: ; preds = %186
%191 = load i32, i32* %10
%192 = icmp eq i32 %191, 0
%193 = select i1 %192, i1 true, i1 %19
br i1 %193, label %259, label %194
194: ; preds = %190
%195 = load i32, i32* %8
%196 = add i32 %195, -1
%197 = sext i32 %196 to i64
%198 = icmp sgt i32 %12, 1
%199 = sext i32 %16 to i64
%200 = add i32 %18, 1
%201 = add nsw i64 %38, -1
%202 = and i64 %201, 1
%203 = icmp eq i32 %12, 2
%204 = and i64 %201, -2
%205 = icmp eq i64 %202, 0
br label %206
206: ; preds = %194, %255
%207 = phi i64 [ %199, %194 ], [ %256, %255 ]
%208 = getelementptr inbounds float*, float** %1, i64 %207
%209 = load float*, float** %208
%210 = getelementptr inbounds float, float* %209, i64 %197
store float 0.000000e+00, float* %210
br i1 %198, label %211, label %255
211: ; preds = %206
br i1 %203, label %241, label %212
212: ; preds = %211, %212
%213 = phi i64 [ %238, %212 ], [ 1, %211 ]
%214 = phi i64 [ %239, %212 ], [ 0, %211 ]
%215 = trunc i64 %213 to i32
%216 = add i32 %196, %215
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds float, float* %209, i64 %217
%219 = load float, float* %218
%220 = fneg float %219
%221 = trunc i64 %213 to i32
%222 = xor i32 %221, -1
%223 = add i32 %195, %222
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds float, float* %209, i64 %224
store float %220, float* %225
%226 = add nuw nsw i64 %213, 1
%227 = trunc i64 %226 to i32
%228 = add i32 %196, %227
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds float, float* %209, i64 %229
%231 = load float, float* %230
%232 = fneg float %231
%233 = trunc i64 %226 to i32
%234 = xor i32 %233, -1
%235 = add i32 %195, %234
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds float, float* %209, i64 %236
store float %232, float* %237
%238 = add nuw nsw i64 %213, 2
%239 = add i64 %214, 2
%240 = icmp eq i64 %239, %204
br i1 %240, label %241, label %212
241: ; preds = %212, %211
%242 = phi i64 [ 1, %211 ], [ %238, %212 ]
br i1 %205, label %255, label %243
243: ; preds = %241
%244 = trunc i64 %242 to i32
%245 = add i32 %196, %244
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds float, float* %209, i64 %246
%248 = load float, float* %247
%249 = fneg float %248
%250 = trunc i64 %242 to i32
%251 = xor i32 %250, -1
%252 = add i32 %195, %251
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds float, float* %209, i64 %253
store float %249, float* %254
br label %255
255: ; preds = %243, %241, %206
%256 = add nsw i64 %207, 1
%257 = trunc i64 %256 to i32
%258 = icmp eq i32 %200, %257
br i1 %258, label %259, label %206
259: ; preds = %255, %190
%260 = load i32, i32* %11
%261 = icmp eq i32 %260, 0
%262 = select i1 %261, i1 true, i1 %19
br i1 %262, label %322, label %263
263: ; preds = %259
%264 = load i32, i32* %9
%265 = add i32 %264, 1
%266 = sext i32 %265 to i64
%267 = icmp sgt i32 %12, 1
%268 = sext i32 %16 to i64
%269 = add i32 %18, 1
%270 = add nsw i64 %38, -1
%271 = and i64 %270, 1
%272 = icmp eq i32 %12, 2
%273 = and i64 %270, -2
%274 = icmp eq i64 %271, 0
br label %275
275: ; preds = %263, %318
%276 = phi i64 [ %268, %263 ], [ %319, %318 ]
%277 = getelementptr inbounds float*, float** %1, i64 %276
%278 = load float*, float** %277
%279 = getelementptr inbounds float, float* %278, i64 %266
store float 0.000000e+00, float* %279
br i1 %267, label %280, label %318
280: ; preds = %275
br i1 %272, label %306, label %281
281: ; preds = %280, %281
%282 = phi i64 [ %303, %281 ], [ 1, %280 ]
%283 = phi i64 [ %304, %281 ], [ 0, %280 ]
%284 = trunc i64 %282 to i32
%285 = sub i32 %265, %284
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds float, float* %278, i64 %286
%288 = load float, float* %287
%289 = fneg float %288
%290 = add i32 %265, %284
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds float, float* %278, i64 %291
store float %289, float* %292
%293 = trunc i64 %282 to i32
%294 = add i32 %293, 1
%295 = sub i32 %265, %294
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds float, float* %278, i64 %296
%298 = load float, float* %297
%299 = fneg float %298
%300 = add i32 %265, %294
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds float, float* %278, i64 %301
store float %299, float* %302
%303 = add nuw nsw i64 %282, 2
%304 = add i64 %283, 2
%305 = icmp eq i64 %304, %273
br i1 %305, label %306, label %281
306: ; preds = %281, %280
%307 = phi i64 [ 1, %280 ], [ %303, %281 ]
br i1 %274, label %318, label %308
308: ; preds = %306
%309 = trunc i64 %307 to i32
%310 = sub i32 %265, %309
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds float, float* %278, i64 %311
%313 = load float, float* %312
%314 = fneg float %313
%315 = add i32 %265, %309
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds float, float* %278, i64 %316
store float %314, float* %317
br label %318
318: ; preds = %308, %306, %275
%319 = add nsw i64 %276, 1
%320 = trunc i64 %319 to i32
%321 = icmp eq i32 %269, %320
br i1 %321, label %322, label %275
322: ; preds = %318, %14, %259
%323 = getelementptr inbounds i32, i32* %10, i64 1
%324 = load i32, i32* %323
%325 = icmp eq i32 %324, 0
br i1 %325, label %407, label %326
326: ; preds = %322
%327 = load i32, i32* %8
%328 = load i32, i32* %9
%329 = icmp sgt i32 %327, %328
br i1 %329, label %407, label %330
330: ; preds = %326
%331 = add i32 %16, -1
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds float*, float** %2, i64 %332
%334 = load float*, float** %333
%335 = icmp sgt i32 %12, 1
%336 = sext i32 %327 to i64
%337 = add i32 %328, 1
%338 = zext i32 %12 to i64
%339 = add nsw i64 %338, -1
%340 = and i64 %339, 1
%341 = icmp eq i32 %12, 2
%342 = and i64 %339, -2
%343 = icmp eq i64 %340, 0
br label %344
344: ; preds = %330, %403
%345 = phi i64 [ %336, %330 ], [ %404, %403 ]
%346 = getelementptr inbounds float, float* %334, i64 %345
store float 0.000000e+00, float* %346
br i1 %335, label %347, label %403
347: ; preds = %344
br i1 %341, label %385, label %348
348: ; preds = %347, %348
%349 = phi i64 [ %382, %348 ], [ 1, %347 ]
%350 = phi i64 [ %383, %348 ], [ 0, %347 ]
%351 = trunc i64 %349 to i32
%352 = add i32 %331, %351
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds float*, float** %2, i64 %353
%355 = load float*, float** %354
%356 = getelementptr inbounds float, float* %355, i64 %345
%357 = load float, float* %356
%358 = fneg float %357
%359 = trunc i64 %349 to i32
%360 = xor i32 %359, -1
%361 = add i32 %16, %360
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds float*, float** %2, i64 %362
%364 = load float*, float** %363
%365 = getelementptr inbounds float, float* %364, i64 %345
store float %358, float* %365
%366 = add nuw nsw i64 %349, 1
%367 = trunc i64 %366 to i32
%368 = add i32 %331, %367
%369 = sext i32 %368 to i64
%370 = getelementptr inbounds float*, float** %2, i64 %369
%371 = load float*, float** %370
%372 = getelementptr inbounds float, float* %371, i64 %345
%373 = load float, float* %372
%374 = fneg float %373
%375 = trunc i64 %366 to i32
%376 = xor i32 %375, -1
%377 = add i32 %16, %376
%378 = sext i32 %377 to i64
%379 = getelementptr inbounds float*, float** %2, i64 %378
%380 = load float*, float** %379
%381 = getelementptr inbounds float, float* %380, i64 %345
store float %374, float* %381
%382 = add nuw nsw i64 %349, 2
%383 = add i64 %350, 2
%384 = icmp eq i64 %383, %342
br i1 %384, label %385, label %348
385: ; preds = %348, %347
%386 = phi i64 [ 1, %347 ], [ %382, %348 ]
br i1 %343, label %403, label %387
387: ; preds = %385
%388 = trunc i64 %386 to i32
%389 = add i32 %331, %388
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds float*, float** %2, i64 %390
%392 = load float*, float** %391
%393 = getelementptr inbounds float, float* %392, i64 %345
%394 = load float, float* %393
%395 = fneg float %394
%396 = trunc i64 %386 to i32
%397 = xor i32 %396, -1
%398 = add i32 %16, %397
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds float*, float** %2, i64 %399
%401 = load float*, float** %400
%402 = getelementptr inbounds float, float* %401, i64 %345
store float %395, float* %402
br label %403
403: ; preds = %387, %385, %344
%404 = add nsw i64 %345, 1
%405 = trunc i64 %404 to i32
%406 = icmp eq i32 %337, %405
br i1 %406, label %407, label %344
407: ; preds = %403, %326, %322
%408 = getelementptr inbounds i32, i32* %11, i64 1
%409 = load i32, i32* %408
%410 = icmp eq i32 %409, 0
br i1 %410, label %486, label %411
411: ; preds = %407
%412 = load i32, i32* %8
%413 = load i32, i32* %9
%414 = icmp sgt i32 %412, %413
br i1 %414, label %486, label %415
415: ; preds = %411
%416 = add i32 %18, 1
%417 = sext i32 %416 to i64
%418 = getelementptr inbounds float*, float** %2, i64 %417
%419 = load float*, float** %418
%420 = icmp sgt i32 %12, 1
%421 = sext i32 %412 to i64
%422 = add i32 %413, 1
%423 = zext i32 %12 to i64
%424 = add nsw i64 %423, -1
%425 = and i64 %424, 1
%426 = icmp eq i32 %12, 2
%427 = and i64 %424, -2
%428 = icmp eq i64 %425, 0
br label %429
429: ; preds = %415, %482
%430 = phi i64 [ %421, %415 ], [ %483, %482 ]
%431 = getelementptr inbounds float, float* %419, i64 %430
store float 0.000000e+00, float* %431
br i1 %420, label %432, label %482
432: ; preds = %429
br i1 %426, label %466, label %433
433: ; preds = %432, %433
%434 = phi i64 [ %463, %433 ], [ 1, %432 ]
%435 = phi i64 [ %464, %433 ], [ 0, %432 ]
%436 = trunc i64 %434 to i32
%437 = sub i32 %416, %436
%438 = sext i32 %437 to i64
%439 = getelementptr inbounds float*, float** %2, i64 %438
%440 = load float*, float** %439
%441 = getelementptr inbounds float, float* %440, i64 %430
%442 = load float, float* %441
%443 = fneg float %442
%444 = add i32 %416, %436
%445 = sext i32 %444 to i64
%446 = getelementptr inbounds float*, float** %2, i64 %445
%447 = load float*, float** %446
%448 = getelementptr inbounds float, float* %447, i64 %430
store float %443, float* %448
%449 = trunc i64 %434 to i32
%450 = add i32 %449, 1
%451 = sub i32 %416, %450
%452 = sext i32 %451 to i64
%453 = getelementptr inbounds float*, float** %2, i64 %452
%454 = load float*, float** %453
%455 = getelementptr inbounds float, float* %454, i64 %430
%456 = load float, float* %455
%457 = fneg float %456
%458 = add i32 %416, %450
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds float*, float** %2, i64 %459
%461 = load float*, float** %460
%462 = getelementptr inbounds float, float* %461, i64 %430
store float %457, float* %462
%463 = add nuw nsw i64 %434, 2
%464 = add i64 %435, 2
%465 = icmp eq i64 %464, %427
br i1 %465, label %466, label %433
466: ; preds = %433, %432
%467 = phi i64 [ 1, %432 ], [ %463, %433 ]
br i1 %428, label %482, label %468
468: ; preds = %466
%469 = trunc i64 %467 to i32
%470 = sub i32 %416, %469
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds float*, float** %2, i64 %471
%473 = load float*, float** %472
%474 = getelementptr inbounds float, float* %473, i64 %430
%475 = load float, float* %474
%476 = fneg float %475
%477 = add i32 %416, %469
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds float*, float** %2, i64 %478
%480 = load float*, float** %479
%481 = getelementptr inbounds float, float* %480, i64 %430
store float %476, float* %481
br label %482
482: ; preds = %468, %466, %429
%483 = add nsw i64 %430, 1
%484 = trunc i64 %483 to i32
%485 = icmp eq i32 %422, %484
br i1 %485, label %486, label %429
486: ; preds = %482, %411, %407
ret void
}