void step24_forward(float *tgt_p, float *src_p, float *v, int nz, int nx,
                    float rz, float rx, float s) {
  int iz;
  int ix;
  int ioff;
  float two = 2.0;
  float mot = -1.0 / 12.0;
  float fth = 4.0 / 3.0;
  float mfh = -5.0 / 4.0;
  float motz = rz * mot;
  float motx = rx * mot;
  float fthz = rz * fth;
  float fthx = rx * fth;
  mfh = mfh * s;
  for (ix = 2; ix < nx - 2; ix++) {
    for (iz = 2; iz < nz - 2; iz++) {
      ioff = iz + ix * nz;
      tgt_p[ioff] =
          two * src_p[ioff] - tgt_p[ioff] +
          v[ioff] * (motz * (src_p[ioff + 2] + src_p[ioff - 2]) +
                     motx * (src_p[ioff + 2 * nz] + src_p[ioff - 2 * nz]) +
                     fthz * (src_p[ioff + 1] + src_p[ioff - 1]) +
                     fthx * (src_p[ioff + nz] + src_p[ioff - nz]) +
                     mfh * src_p[ioff]);
    }
  }
  for (ix = 0; ix < nx; ix++) {
    tgt_p[ix * nz] = -tgt_p[ix * nz + 2];
    tgt_p[ix * nz + nz - 1] = -tgt_p[ix * nz + nz - 3];
  }
  for (iz = 0; iz < nz; iz++) {
    tgt_p[iz] = -tgt_p[iz + 2 * nz];
    tgt_p[iz + (nx - 1) * nz] = -tgt_p[iz + (nx - 3) * nz];
  }
}


x86 assembly (clang, -O0):
<step24_forward>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
movss  %xmm0,-0x24(%rbp)
movss  %xmm1,-0x28(%rbp)
movss  %xmm2,-0x2c(%rbp)
movss  0xede(%rip),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  0xecd(%rip),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  0xebc(%rip),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  0xeab(%rip),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x24(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x28(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x24(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x28(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x48(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movl   $0x2,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    133f <step24_forward+0x23f>
movl   $0x2,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    132c <step24_forward+0x22c>
mov    -0x30(%rbp),%eax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x38(%rbp)
movss  -0x3c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x4c(%rbp),%xmm3
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
movss  -0x50(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
sub    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
mulss  %xmm5,%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  -0x54(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  -0x58(%rbp),%xmm3
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  -0x48(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11c4 <step24_forward+0xc4>
jmp    1331 <step24_forward+0x231>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11ac <step24_forward+0xac>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    13d5 <step24_forward+0x2d5>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x1c(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1346 <step24_forward+0x246>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    146a <step24_forward+0x36a>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x20(%rbp),%edx
sub    $0x3,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13dc <step24_forward+0x2dc>
pop    %rbp
ret

x86 assembly (clang, -O2):
<step24_forward>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %ecx,%ebp
mov    %rdx,-0x40(%rsp)
mov    %rsi,-0x48(%rsp)
mov    %rdi,-0x78(%rsp)
movslq %ecx,%rdx
mov    %r8,-0x30(%rsp)
cmp    $0x5,%r8d
jl     1704 <step24_forward+0x604>
movss  0xec3(%rip),%xmm12
movaps %xmm0,%xmm14
mulss  %xmm12,%xmm14
mulss  %xmm1,%xmm12
movss  0xeb1(%rip),%xmm5
mulss  %xmm5,%xmm0
mulss  %xmm5,%xmm1
mulss  0xea5(%rip),%xmm2
mov    -0x30(%rsp),%rax
add    $0xfffffffe,%eax
mov    %rax,0xc0(%rsp)
lea    -0x2(%rdx),%ecx
lea    (%rdx,%rdx,1),%eax
cltq
lea    (%rdx,%rdx,1),%rsi
lea    0x2(%rdx,%rdx,1),%r11
lea    (%rcx,%rdx,2),%rbx
lea    0x2(%rdx),%rdi
mov    %rdi,0x70(%rsp)
lea    (%rdx,%rcx,1),%rdi
mov    %rdi,0x68(%rsp)
lea    (%rdx,%rdx,2),%r8
mov    %r11,%rdi
sub    %rax,%rdi
mov    %rbx,0x78(%rsp)
sub    %rax,%rbx
mov    %rbx,0x58(%rsp)
lea    (%rax,%rdx,2),%r9
lea    (%rax,%rdx,2),%rbx
add    $0x2,%rbx
mov    %rbx,0x50(%rsp)
lea    -0x2(%rcx),%r10
mov    %rsi,%rbx
sub    %rax,%rbx
mov    %rbx,0x8(%rsp)
mov    %r10,-0x28(%rsp)
and    $0xfffffffffffffffc,%r10
movaps %xmm12,%xmm8
shufps $0x0,%xmm12,%xmm8
movaps %xmm14,%xmm9
shufps $0x0,%xmm14,%xmm9
movaps %xmm0,%xmm15
shufps $0x0,%xmm0,%xmm15
movaps %xmm1,%xmm10
shufps $0x0,%xmm1,%xmm10
movaps %xmm2,%xmm13
shufps $0x0,%xmm2,%xmm13
lea    0x2(%rdx,%rdx,2),%rax
mov    %rax,0x48(%rsp)
lea    (%r8,%rcx,1),%rax
mov    %rax,0x40(%rsp)
lea    0x2(%rcx,%rdx,2),%rax
mov    %rax,0x38(%rsp)
mov    %rcx,0x90(%rsp)
lea    (%r9,%rcx,1),%rax
mov    %rax,0x30(%rsp)
mov    %r10,0x28(%rsp)
lea    0x2(%r10),%rax
mov    %rax,0x20(%rsp)
mov    -0x48(%rsp),%rax
lea    0x8(%rax,%rdx,4),%rcx
lea    0x0(,%rdx,4),%rbx
mov    %rbx,0xb8(%rsp)
mov    %r8,0x18(%rsp)
lea    0x8(%rax,%r8,4),%rbx
lea    (%rax,%rdx,8),%r10
mov    %rdi,0x60(%rsp)
lea    (%rax,%rdi,4),%r14
mov    %r9,0x10(%rsp)
lea    0x8(%rax,%r9,4),%r9
mov    -0x40(%rsp),%rax
lea    0x8(%rax,%rsi,4),%r8
mov    -0x78(%rsp),%rax
lea    (%rax,%rsi,4),%r15
add    $0x8,%r15
mov    $0x2,%edi
xor    %eax,%eax
mov    %rax,-0x20(%rsp)
mov    %r11,0x80(%rsp)
mov    %r11,(%rsp)
mov    %rsi,0x88(%rsp)
mov    %rsi,-0x8(%rsp)
mov    %rdx,-0x10(%rsp)
mov    %rbp,0xc8(%rsp)
mov    %rdx,-0x18(%rsp)
movaps %xmm12,0xd0(%rsp)
jmp    134e <step24_forward+0x24e>
nopw   0x0(%rax,%rax,1)
mov    -0x38(%rsp),%rdi
add    $0x1,%rdi
addq   $0x1,-0x20(%rsp)
mov    -0x68(%rsp),%rcx
mov    0xb8(%rsp),%rax
add    %rax,%rcx
mov    -0x70(%rsp),%rbx
add    %rax,%rbx
add    %rax,%r10
add    %rax,%r14
add    %rax,%r9
add    %rax,%r8
add    %rax,%r15
mov    -0x18(%rsp),%rdx
add    %rdx,-0x10(%rsp)
add    %rdx,0x18(%rsp)
add    %rdx,-0x8(%rsp)
add    %rdx,(%rsp)
add    %rdx,0x10(%rsp)
add    %rdx,0x8(%rsp)
cmp    0xc0(%rsp),%rdi
mov    0xc8(%rsp),%rbp
je     1704 <step24_forward+0x604>
mov    %rdi,-0x38(%rsp)
mov    %rbx,-0x70(%rsp)
mov    %rcx,-0x68(%rsp)
cmp    $0x5,%ebp
jl     12e0 <step24_forward+0x1e0>
mov    $0x2,%r11d
cmpq   $0x4,-0x28(%rsp)
jb     1610 <step24_forward+0x510>
mov    -0x20(%rsp),%rdx
imul   -0x18(%rsp),%rdx
mov    0x80(%rsp),%rax
lea    (%rax,%rdx,1),%rbx
mov    %rbx,0xb0(%rsp)
mov    0x78(%rsp),%rax
lea    (%rax,%rdx,1),%r12
mov    %r12,0x98(%rsp)
mov    0x70(%rsp),%rax
add    %rdx,%rax
mov    0x68(%rsp),%rcx
lea    (%rcx,%rdx,1),%rdi
mov    0x48(%rsp),%rcx
lea    (%rcx,%rdx,1),%rcx
mov    %rcx,-0x60(%rsp)
mov    0x40(%rsp),%rcx
lea    (%rcx,%rdx,1),%rcx
mov    0x88(%rsp),%rsi
lea    (%rsi,%rdx,1),%rsi
mov    %rsi,-0x58(%rsp)
mov    0x38(%rsp),%rsi
lea    (%rsi,%rdx,1),%r13
mov    0x60(%rsp),%rsi
add    %rdx,%rsi
mov    %rsi,-0x50(%rsp)
mov    0x58(%rsp),%rsi
add    %rdx,%rsi
mov    %rsi,0xa0(%rsp)
mov    0x50(%rsp),%rsi
add    %rdx,%rsi
mov    %rsi,0xa8(%rsp)
add    0x30(%rsp),%rdx
mov    -0x78(%rsp),%rbp
lea    0x0(,%rbx,4),%rsi
add    %rbp,%rsi
mov    -0x48(%rsp),%rbx
lea    (%rbx,%rdi,4),%rdi
cmp    %rdi,%rsi
lea    0x0(%rbp,%r12,4),%rdi
lea    (%rbx,%rax,4),%rax
setb   -0x79(%rsp)
cmp    %rdi,%rax
lea    (%rbx,%rcx,4),%rax
setb   -0x7a(%rsp)
cmp    %rax,%rsi
mov    -0x60(%rsp),%rax
lea    (%rbx,%rax,4),%rax
setb   %bpl
cmp    %rdi,%rax
lea    (%rbx,%r13,4),%rax
setb   -0x60(%rsp)
cmp    %rax,%rsi
mov    -0x58(%rsp),%rax
lea    (%rbx,%rax,4),%rcx
setb   %al
cmp    %rdi,%rcx
mov    0xa0(%rsp),%rcx
lea    (%rbx,%rcx,4),%rcx
setb   -0x58(%rsp)
cmp    %rcx,%rsi
mov    -0x50(%rsp),%rcx
lea    (%rbx,%rcx,4),%r13
setb   %cl
cmp    %rdi,%r13
lea    (%rbx,%rdx,4),%rdx
setb   -0x50(%rsp)
cmp    %rdx,%rsi
mov    0xa8(%rsp),%rdx
lea    (%rbx,%rdx,4),%rdx
setb   %r12b
cmp    %rdi,%rdx
mov    -0x40(%rsp),%r13
mov    0x98(%rsp),%rdx
lea    0x0(%r13,%rdx,4),%rdx
setb   %bl
cmp    %rdx,%rsi
mov    0xb0(%rsp),%rdx
lea    0x0(%r13,%rdx,4),%rdx
setb   %sil
cmp    %rdi,%rdx
setb   %dil
mov    -0x7a(%rsp),%dl
test   %dl,-0x79(%rsp)
jne    1610 <step24_forward+0x510>
and    -0x60(%rsp),%bpl
jne    1610 <step24_forward+0x510>
and    -0x58(%rsp),%al
jne    1610 <step24_forward+0x510>
and    -0x50(%rsp),%cl
jne    1610 <step24_forward+0x510>
and    %bl,%r12b
jne    1610 <step24_forward+0x510>
and    %dil,%sil
jne    1610 <step24_forward+0x510>
xor    %eax,%eax
mov    0x28(%rsp),%rcx
movaps %xmm10,%xmm12
movaps %xmm9,%xmm10
movaps %xmm8,%xmm9
mov    -0x68(%rsp),%rdx
mov    -0x70(%rsp),%rsi
xchg   %ax,%ax
movups (%r15,%rax,4),%xmm6
movups (%r10,%rax,4),%xmm3
movups 0x4(%r10,%rax,4),%xmm5
movups 0x8(%r10,%rax,4),%xmm7
movups 0xc(%r10,%rax,4),%xmm4
addps  %xmm5,%xmm4
mulps  %xmm15,%xmm4
movaps %xmm7,%xmm5
addps  %xmm7,%xmm5
subps  %xmm6,%xmm5
movaps %xmm15,%xmm11
movups (%r8,%rax,4),%xmm15
movups 0x10(%r10,%rax,4),%xmm6
addps  %xmm3,%xmm6
mulps  %xmm10,%xmm6
movups (%r9,%rax,4),%xmm3
movups (%r14,%rax,4),%xmm8
addps  %xmm3,%xmm8
mulps  %xmm9,%xmm8
addps  %xmm6,%xmm8
addps  %xmm4,%xmm8
movups (%rsi,%rax,4),%xmm3
movups (%rdx,%rax,4),%xmm4
addps  %xmm3,%xmm4
mulps  %xmm12,%xmm4
addps  %xmm8,%xmm4
mulps  %xmm13,%xmm7
addps  %xmm4,%xmm7
mulps  %xmm15,%xmm7
movaps %xmm11,%xmm15
addps  %xmm5,%xmm7
movups %xmm7,(%r15,%rax,4)
add    $0x4,%rax
cmp    %rax,%rcx
jne    1550 <step24_forward+0x450>
mov    0x20(%rsp),%r11
cmp    %rcx,-0x28(%rsp)
movaps %xmm9,%xmm8
movaps %xmm10,%xmm9
movaps %xmm12,%xmm10
movaps 0xd0(%rsp),%xmm12
je     12e0 <step24_forward+0x1e0>
nopl   0x0(%rax,%rax,1)
mov    0x90(%rsp),%rdi
sub    %r11,%rdi
mov    -0x10(%rsp),%rax
add    %r11,%rax
mov    -0x48(%rsp),%rdx
lea    (%rdx,%rax,4),%rsi
mov    0x18(%rsp),%rax
lea    (%r11,%rax,1),%rax
lea    (%rdx,%rax,4),%rbx
mov    -0x8(%rsp),%rax
lea    (%r11,%rax,1),%rax
mov    -0x78(%rsp),%rcx
lea    (%rcx,%rax,4),%r12
mov    -0x40(%rsp),%rcx
lea    (%rcx,%rax,4),%r13
mov    (%rsp),%rax
add    %r11,%rax
lea    (%rdx,%rax,4),%rcx
mov    0x10(%rsp),%rax
add    %r11,%rax
lea    (%rdx,%rax,4),%rax
add    0x8(%rsp),%r11
lea    (%rdx,%r11,4),%rbp
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movss  -0x8(%rcx,%rdx,4),%xmm7
movaps %xmm7,%xmm5
addss  %xmm7,%xmm5
subss  (%r12,%rdx,4),%xmm5
movss  (%rcx,%rdx,4),%xmm3
addss  -0x10(%rcx,%rdx,4),%xmm3
movss  -0x4(%rcx,%rdx,4),%xmm4
movss  (%rax,%rdx,4),%xmm6
addss  0x0(%rbp,%rdx,4),%xmm6
mulss  %xmm12,%xmm6
mulss  %xmm14,%xmm3
addss  -0xc(%rcx,%rdx,4),%xmm4
addss  %xmm6,%xmm3
mulss  %xmm0,%xmm4
addss  %xmm3,%xmm4
movss  (%rbx,%rdx,4),%xmm3
addss  (%rsi,%rdx,4),%xmm3
mulss  %xmm1,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm2,%xmm7
addss  %xmm3,%xmm7
mulss  0x0(%r13,%rdx,4),%xmm7
addss  %xmm5,%xmm7
movss  %xmm7,(%r12,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rdi
jne    1680 <step24_forward+0x580>
jmp    12e0 <step24_forward+0x1e0>
mov    -0x30(%rsp),%rsi
test   %esi,%esi
mov    -0x78(%rsp),%r13
jle    1754 <step24_forward+0x654>
mov    %esi,%eax
shl    $0x2,%rdx
lea    0x8(%r13),%rcx
movaps 0x8ed(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rcx),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x8(%rcx)
movss  -0x14(%rcx,%rdx,1),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0xc(%rcx,%rdx,1)
add    %rdx,%rcx
add    $0xffffffffffffffff,%rax
jne    1730 <step24_forward+0x630>
test   %ebp,%ebp
jle    19c4 <step24_forward+0x8c4>
lea    0x0(%rbp,%rbp,1),%eax
lea    -0x3(%rsi),%ecx
imul   %ebp,%ecx
add    $0xffffffff,%esi
imul   %ebp,%esi
movslq %eax,%r9
movslq %ecx,%rdx
movslq %esi,%rsi
mov    %ebp,%eax
cmp    $0x4,%ebp
jae    1783 <step24_forward+0x683>
xor    %edi,%edi
jmp    190d <step24_forward+0x80d>
lea    0x0(,%rax,4),%rdi
add    %r13,%rdi
lea    0x0(%r13,%rsi,4),%rbp
lea    (%rsi,%rax,1),%rcx
lea    0x0(%r13,%rcx,4),%rbx
lea    0x0(%r13,%r9,4),%r10
lea    (%r9,%rax,1),%rcx
lea    0x0(%r13,%rcx,4),%r8
lea    0x0(,%rdx,4),%r14
add    %r13,%r14
lea    (%rdx,%rax,1),%rcx
lea    0x0(,%rcx,4),%rcx
add    %r13,%rcx
cmp    %r13,%rbx
seta   -0x68(%rsp)
cmp    %rdi,%rbp
setb   %r12b
cmp    %r13,%r8
seta   %r15b
cmp    %rdi,%r10
setb   %r11b
cmp    %r13,%rcx
seta   %r13b
cmp    %rdi,%r14
setb   -0x70(%rsp)
cmp    %r8,%rbp
setb   %r8b
cmp    %rbx,%r10
setb   -0x38(%rsp)
cmp    %rcx,%rbp
setb   %r10b
cmp    %rbx,%r14
setb   %bl
xor    %edi,%edi
test   %r12b,-0x68(%rsp)
jne    1908 <step24_forward+0x808>
and    %r11b,%r15b
jne    1908 <step24_forward+0x808>
and    -0x70(%rsp),%r13b
jne    1908 <step24_forward+0x808>
and    -0x38(%rsp),%r8b
mov    -0x78(%rsp),%r13
jne    190d <step24_forward+0x80d>
and    %bl,%r10b
jne    190d <step24_forward+0x80d>
mov    %eax,%edi
and    $0xfffffffc,%edi
lea    -0x4(%rdi),%rcx
mov    %rcx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     18fe <step24_forward+0x7fe>
mov    %r8,%rbx
and    $0xfffffffffffffffe,%rbx
lea    0x10(%r13),%rcx
xor    %ebp,%ebp
movaps 0x799(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movups -0x10(%rcx,%r9,4),%xmm1
xorps  %xmm0,%xmm1
movups %xmm1,-0x10(%rcx)
movups -0x10(%rcx,%rdx,4),%xmm1
xorps  %xmm0,%xmm1
movups %xmm1,-0x10(%rcx,%rsi,4)
movups (%rcx,%r9,4),%xmm1
xorps  %xmm0,%xmm1
movups %xmm1,(%rcx)
movups (%rcx,%rdx,4),%xmm1
xorps  %xmm0,%xmm1
movups %xmm1,(%rcx,%rsi,4)
add    $0x8,%rbp
add    $0x20,%rcx
add    $0xfffffffffffffffe,%rbx
jne    1880 <step24_forward+0x780>
test   $0x1,%r8b
je     18f4 <step24_forward+0x7f4>
lea    (%r9,%rbp,1),%rcx
movups 0x0(%r13,%rcx,4),%xmm0
movaps 0x73b(%rip),%xmm1
xorps  %xmm1,%xmm0
movups %xmm0,0x0(%r13,%rbp,4)
lea    (%rdx,%rbp,1),%rcx
movups 0x0(%r13,%rcx,4),%xmm0
xorps  %xmm1,%xmm0
add    %rsi,%rbp
movups %xmm0,0x0(%r13,%rbp,4)
cmp    %rax,%rdi
jne    190d <step24_forward+0x80d>
jmp    19c4 <step24_forward+0x8c4>
xor    %ebp,%ebp
test   $0x1,%r8b
jne    18c4 <step24_forward+0x7c4>
jmp    18f4 <step24_forward+0x7f4>
mov    -0x78(%rsp),%r13
mov    %rdi,%rcx
not    %rcx
test   $0x1,%al
je     1950 <step24_forward+0x850>
lea    (%rdi,%r9,1),%rbp
movss  0x0(%r13,%rbp,4),%xmm0
movaps 0x6e7(%rip),%xmm1
xorps  %xmm1,%xmm0
movss  %xmm0,0x0(%r13,%rdi,4)
lea    (%rdi,%rdx,1),%rbp
movss  0x0(%r13,%rbp,4),%xmm0
xorps  %xmm1,%xmm0
lea    (%rdi,%rsi,1),%rbp
movss  %xmm0,0x0(%r13,%rbp,4)
or     $0x1,%rdi
add    %rax,%rcx
je     19c4 <step24_forward+0x8c4>
lea    0x4(,%rsi,4),%rcx
add    %r13,%rcx
lea    0x4(,%rdx,4),%rdx
add    %r13,%rdx
lea    0x4(,%r9,4),%rsi
add    %r13,%rsi
movaps 0x693(%rip),%xmm0
nopl   (%rax)
movss  -0x4(%rsi,%rdi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x0(%r13,%rdi,4)
movss  -0x4(%rdx,%rdi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x4(%rcx,%rdi,4)
movss  (%rsi,%rdi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x4(%r13,%rdi,4)
movss  (%rdx,%rdi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%rcx,%rdi,4)
add    $0x2,%rdi
cmp    %rdi,%rax
jne    1980 <step24_forward+0x880>
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @step24_forward(float* %0, float* %1, float* %2, i32 %3, i32 %4, float %5, float %6, float %7) {
%9 = alloca float*
%10 = alloca float*
%11 = alloca float*
%12 = alloca i32
%13 = alloca i32
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca float
%27 = alloca float
store float* %0, float** %9
store float* %1, float** %10
store float* %2, float** %11
store i32 %3, i32* %12
store i32 %4, i32* %13
store float %5, float* %14
store float %6, float* %15
store float %7, float* %16
store float 2.000000e+00, float* %20
store float 0xBFB5555560000000, float* %21
store float 0x3FF5555560000000, float* %22
store float -1.250000e+00, float* %23
%28 = load float, float* %14
%29 = load float, float* %21
%30 = fmul float %28, %29
store float %30, float* %24
%31 = load float, float* %15
%32 = load float, float* %21
%33 = fmul float %31, %32
store float %33, float* %25
%34 = load float, float* %14
%35 = load float, float* %22
%36 = fmul float %34, %35
store float %36, float* %26
%37 = load float, float* %15
%38 = load float, float* %22
%39 = fmul float %37, %38
store float %39, float* %27
%40 = load float, float* %23
%41 = load float, float* %16
%42 = fmul float %40, %41
store float %42, float* %23
store i32 2, i32* %18
br label %43
43: ; preds = %160, %8
%44 = load i32, i32* %18
%45 = load i32, i32* %13
%46 = sub nsw i32 %45, 2
%47 = icmp slt i32 %44, %46
br i1 %47, label %48, label %163
48: ; preds = %43
store i32 2, i32* %17
br label %49
49: ; preds = %156, %48
%50 = load i32, i32* %17
%51 = load i32, i32* %12
%52 = sub nsw i32 %51, 2
%53 = icmp slt i32 %50, %52
br i1 %53, label %54, label %159
54: ; preds = %49
%55 = load i32, i32* %17
%56 = load i32, i32* %18
%57 = load i32, i32* %12
%58 = mul nsw i32 %56, %57
%59 = add nsw i32 %55, %58
store i32 %59, i32* %19
%60 = load float, float* %20
%61 = load float*, float** %10
%62 = load i32, i32* %19
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds float, float* %61, i64 %63
%65 = load float, float* %64
%66 = load float*, float** %9
%67 = load i32, i32* %19
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds float, float* %66, i64 %68
%70 = load float, float* %69
%71 = fneg float %70
%72 = call float @llvm.fmuladd.f32(float %60, float %65, float %71)
%73 = load float*, float** %11
%74 = load i32, i32* %19
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds float, float* %73, i64 %75
%77 = load float, float* %76
%78 = load float, float* %24
%79 = load float*, float** %10
%80 = load i32, i32* %19
%81 = add nsw i32 %80, 2
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds float, float* %79, i64 %82
%84 = load float, float* %83
%85 = load float*, float** %10
%86 = load i32, i32* %19
%87 = sub nsw i32 %86, 2
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds float, float* %85, i64 %88
%90 = load float, float* %89
%91 = fadd float %84, %90
%92 = load float, float* %25
%93 = load float*, float** %10
%94 = load i32, i32* %19
%95 = load i32, i32* %12
%96 = mul nsw i32 2, %95
%97 = add nsw i32 %94, %96
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds float, float* %93, i64 %98
%100 = load float, float* %99
%101 = load float*, float** %10
%102 = load i32, i32* %19
%103 = load i32, i32* %12
%104 = mul nsw i32 2, %103
%105 = sub nsw i32 %102, %104
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds float, float* %101, i64 %106
%108 = load float, float* %107
%109 = fadd float %100, %108
%110 = fmul float %92, %109
%111 = call float @llvm.fmuladd.f32(float %78, float %91, float %110)
%112 = load float, float* %26
%113 = load float*, float** %10
%114 = load i32, i32* %19
%115 = add nsw i32 %114, 1
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds float, float* %113, i64 %116
%118 = load float, float* %117
%119 = load float*, float** %10
%120 = load i32, i32* %19
%121 = sub nsw i32 %120, 1
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds float, float* %119, i64 %122
%124 = load float, float* %123
%125 = fadd float %118, %124
%126 = call float @llvm.fmuladd.f32(float %112, float %125, float %111)
%127 = load float, float* %27
%128 = load float*, float** %10
%129 = load i32, i32* %19
%130 = load i32, i32* %12
%131 = add nsw i32 %129, %130
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds float, float* %128, i64 %132
%134 = load float, float* %133
%135 = load float*, float** %10
%136 = load i32, i32* %19
%137 = load i32, i32* %12
%138 = sub nsw i32 %136, %137
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds float, float* %135, i64 %139
%141 = load float, float* %140
%142 = fadd float %134, %141
%143 = call float @llvm.fmuladd.f32(float %127, float %142, float %126)
%144 = load float, float* %23
%145 = load float*, float** %10
%146 = load i32, i32* %19
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds float, float* %145, i64 %147
%149 = load float, float* %148
%150 = call float @llvm.fmuladd.f32(float %144, float %149, float %143)
%151 = call float @llvm.fmuladd.f32(float %77, float %150, float %72)
%152 = load float*, float** %9
%153 = load i32, i32* %19
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds float, float* %152, i64 %154
store float %151, float* %155
br label %156
156: ; preds = %54
%157 = load i32, i32* %17
%158 = add nsw i32 %157, 1
store i32 %158, i32* %17
br label %49
159: ; preds = %49
br label %160
160: ; preds = %159
%161 = load i32, i32* %18
%162 = add nsw i32 %161, 1
store i32 %162, i32* %18
br label %43
163: ; preds = %43
store i32 0, i32* %18
br label %164
164: ; preds = %204, %163
%165 = load i32, i32* %18
%166 = load i32, i32* %13
%167 = icmp slt i32 %165, %166
br i1 %167, label %168, label %207
168: ; preds = %164
%169 = load float*, float** %9
%170 = load i32, i32* %18
%171 = load i32, i32* %12
%172 = mul nsw i32 %170, %171
%173 = add nsw i32 %172, 2
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds float, float* %169, i64 %174
%176 = load float, float* %175
%177 = fneg float %176
%178 = load float*, float** %9
%179 = load i32, i32* %18
%180 = load i32, i32* %12
%181 = mul nsw i32 %179, %180
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds float, float* %178, i64 %182
store float %177, float* %183
%184 = load float*, float** %9
%185 = load i32, i32* %18
%186 = load i32, i32* %12
%187 = mul nsw i32 %185, %186
%188 = load i32, i32* %12
%189 = add nsw i32 %187, %188
%190 = sub nsw i32 %189, 3
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds float, float* %184, i64 %191
%193 = load float, float* %192
%194 = fneg float %193
%195 = load float*, float** %9
%196 = load i32, i32* %18
%197 = load i32, i32* %12
%198 = mul nsw i32 %196, %197
%199 = load i32, i32* %12
%200 = add nsw i32 %198, %199
%201 = sub nsw i32 %200, 1
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds float, float* %195, i64 %202
store float %194, float* %203
br label %204
204: ; preds = %168
%205 = load i32, i32* %18
%206 = add nsw i32 %205, 1
store i32 %206, i32* %18
br label %164
207: ; preds = %164
store i32 0, i32* %17
br label %208
208: ; preds = %246, %207
%209 = load i32, i32* %17
%210 = load i32, i32* %12
%211 = icmp slt i32 %209, %210
br i1 %211, label %212, label %249
212: ; preds = %208
%213 = load float*, float** %9
%214 = load i32, i32* %17
%215 = load i32, i32* %12
%216 = mul nsw i32 2, %215
%217 = add nsw i32 %214, %216
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds float, float* %213, i64 %218
%220 = load float, float* %219
%221 = fneg float %220
%222 = load float*, float** %9
%223 = load i32, i32* %17
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds float, float* %222, i64 %224
store float %221, float* %225
%226 = load float*, float** %9
%227 = load i32, i32* %17
%228 = load i32, i32* %13
%229 = sub nsw i32 %228, 3
%230 = load i32, i32* %12
%231 = mul nsw i32 %229, %230
%232 = add nsw i32 %227, %231
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds float, float* %226, i64 %233
%235 = load float, float* %234
%236 = fneg float %235
%237 = load float*, float** %9
%238 = load i32, i32* %17
%239 = load i32, i32* %13
%240 = sub nsw i32 %239, 1
%241 = load i32, i32* %12
%242 = mul nsw i32 %240, %241
%243 = add nsw i32 %238, %242
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds float, float* %237, i64 %244
store float %236, float* %245
br label %246
246: ; preds = %212
%247 = load i32, i32* %17
%248 = add nsw i32 %247, 1
store i32 %248, i32* %17
br label %208
249: ; preds = %208
ret void
}

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