void forward_gradient(const float *f, float *fx, float *fy, const int nx,
                      const int ny) {
  for (int i = 0; i < ny - 1; i++) {
    for (int j = 0; j < nx - 1; j++) {
      const int p = i * nx + j;
      const int p1 = p + 1;
      const int p2 = p + nx;
      fx[p] = f[p1] - f[p];
      fy[p] = f[p2] - f[p];
    }
  }
  for (int j = 0; j < nx - 1; j++) {
    const int p = (ny - 1) * nx + j;
    fx[p] = f[p + 1] - f[p];
    fy[p] = 0;
  }
  for (int i = 1; i < ny; i++) {
    const int p = i * nx - 1;
    fx[p] = 0;
    fy[p] = f[p + nx] - f[p];
  }
  fx[ny * nx - 1] = 0;
  fy[ny * nx - 1] = 0;
}


x86 assembly (clang, -O0):
<forward_gradient>:
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)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    11d5 <forward_gradient+0xd5>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    11c2 <forward_gradient+0xc2>
mov    -0x24(%rbp),%eax
imul   -0x1c(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1136 <forward_gradient+0x36>
jmp    11c7 <forward_gradient+0xc7>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    111e <forward_gradient+0x1e>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1247 <forward_gradient+0x147>
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
imul   -0x1c(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11dc <forward_gradient+0xdc>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    12b1 <forward_gradient+0x1b1>
mov    -0x40(%rbp),%eax
imul   -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    124e <forward_gradient+0x14e>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
pop    %rbp
ret

x86 assembly (clang, -O2):
<forward_gradient>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %ecx,%ebp
mov    %rdx,-0x70(%rsp)
mov    %rsi,-0x78(%rsp)
mov    %rdi,-0x68(%rsp)
lea    -0x1(%r8),%eax
mov    %eax,-0x40(%rsp)
lea    -0x1(%rbp),%ecx
movslq %ebp,%rax
mov    %rax,-0x48(%rsp)
mov    %ecx,-0x3c(%rsp)
mov    %ecx,%eax
mov    %r8,-0x10(%rsp)
cmp    $0x2,%r8d
mov    %rbp,-0x60(%rsp)
jl     147a <forward_gradient+0x37a>
mov    -0x40(%rsp),%r13d
mov    -0x48(%rsp),%rcx
lea    (%rcx,%rax,1),%rdx
mov    %rdx,0x18(%rsp)
lea    0x1(%rax),%rdx
mov    %rdx,0x10(%rsp)
mov    %eax,%edx
and    $0xfffffffc,%edx
mov    %rdx,0x8(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,(%rsp)
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rsi,%rdx
mov    %rsi,-0x8(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,-0x18(%rsp)
mov    -0x70(%rsp),%rdx
lea    0x10(%rdx),%r11
lea    0x0(,%rcx,4),%r12
mov    -0x78(%rsp),%rsi
lea    0x10(%rsi),%r14
mov    -0x68(%rsp),%rdi
lea    (%rdi,%rcx,4),%r8
add    $0x10,%r8
lea    (%rdi,%rcx,4),%r15
xor    %r9d,%r9d
mov    %r13,-0x58(%rsp)
jmp    11f2 <forward_gradient+0xf2>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r9
add    %r12,%r11
add    %r12,%r14
add    %r12,%rdi
add    %r12,%r8
add    %r12,%r15
add    %r12,%rsi
add    %r12,%rdx
cmp    %r13,%r9
je     147a <forward_gradient+0x37a>
cmp    $0x2,%ebp
jl     11d0 <forward_gradient+0xd0>
cmpl   $0x4,-0x3c(%rsp)
jae    1230 <forward_gradient+0x130>
xor    %ebx,%ebx
movss  0x4(%rdi,%rbx,4),%xmm0
subss  (%rdi,%rbx,4),%xmm0
movss  %xmm0,(%rsi,%rbx,4)
movss  (%r15,%rbx,4),%xmm0
subss  (%rdi,%rbx,4),%xmm0
movss  %xmm0,(%rdx,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%rax
jne    1200 <forward_gradient+0x100>
jmp    11d0 <forward_gradient+0xd0>
nopl   0x0(%rax,%rax,1)
mov    %r9,%rbp
mov    -0x48(%rsp),%rcx
imul   %rcx,%rbp
lea    (%rax,%rbp,1),%rbx
add    %rbp,%rcx
mov    %rcx,-0x50(%rsp)
mov    0x18(%rsp),%rcx
lea    (%rcx,%rbp,1),%rcx
mov    %rcx,-0x28(%rsp)
mov    0x10(%rsp),%rcx
lea    (%rcx,%rbp,1),%rcx
mov    %rcx,-0x38(%rsp)
mov    -0x78(%rsp),%rcx
lea    (%rcx,%rbp,4),%r10
lea    (%rcx,%rbx,4),%rcx
mov    %rcx,-0x30(%rsp)
mov    -0x70(%rsp),%rcx
lea    (%rcx,%rbp,4),%r13
mov    %r13,-0x20(%rsp)
lea    (%rcx,%rbx,4),%rcx
mov    %rcx,0x30(%rsp)
mov    -0x68(%rsp),%r13
mov    -0x50(%rsp),%rbx
lea    0x0(%r13,%rbx,4),%rbx
mov    %rbx,0x28(%rsp)
mov    -0x28(%rsp),%rbx
lea    0x0(%r13,%rbx,4),%rbx
mov    %rbx,-0x50(%rsp)
mov    -0x38(%rsp),%rbx
lea    0x0(,%rbx,4),%rbx
add    %r13,%rbx
mov    %rbx,-0x38(%rsp)
cmp    %rcx,%r10
setb   -0x28(%rsp)
mov    -0x30(%rsp),%rbx
cmp    %rbx,-0x20(%rsp)
setb   -0x79(%rsp)
cmp    -0x50(%rsp),%r10
setb   -0x7a(%rsp)
mov    0x28(%rsp),%rcx
cmp    %rbx,%rcx
setb   -0x7b(%rsp)
cmp    -0x38(%rsp),%r10
mov    %rbp,0x20(%rsp)
lea    0x0(%r13,%rbp,4),%rbp
setb   -0x7c(%rsp)
cmp    %rbx,%rbp
setb   -0x30(%rsp)
mov    -0x20(%rsp),%rbx
cmp    -0x50(%rsp),%rbx
setb   %r13b
mov    0x30(%rsp),%r10
cmp    %r10,%rcx
setb   -0x50(%rsp)
cmp    -0x38(%rsp),%rbx
setb   %cl
cmp    %r10,%rbp
setb   %r10b
mov    -0x79(%rsp),%bl
test   %bl,-0x28(%rsp)
jne    145d <forward_gradient+0x35d>
mov    -0x7b(%rsp),%bl
and    %bl,-0x7a(%rsp)
jne    145d <forward_gradient+0x35d>
mov    -0x30(%rsp),%bl
and    %bl,-0x7c(%rsp)
jne    145d <forward_gradient+0x35d>
and    -0x50(%rsp),%r13b
jne    145d <forward_gradient+0x35d>
mov    $0x0,%ebx
and    %r10b,%cl
mov    -0x60(%rsp),%rbp
mov    -0x58(%rsp),%r13
jne    1200 <forward_gradient+0x100>
cmpq   $0x0,(%rsp)
je     146e <forward_gradient+0x36e>
mov    -0x18(%rsp),%rcx
xor    %r10d,%r10d
nopl   0x0(%rax)
movups (%rdi,%r10,4),%xmm0
movups 0x4(%rdi,%r10,4),%xmm1
subps  %xmm0,%xmm1
movups %xmm1,-0x10(%r14,%r10,4)
movups -0x10(%r8,%r10,4),%xmm0
movups (%rdi,%r10,4),%xmm1
subps  %xmm1,%xmm0
movups %xmm0,-0x10(%r11,%r10,4)
movups 0x10(%rdi,%r10,4),%xmm0
movups 0x14(%rdi,%r10,4),%xmm1
subps  %xmm0,%xmm1
movups %xmm1,(%r14,%r10,4)
movups (%r8,%r10,4),%xmm0
movups 0x10(%rdi,%r10,4),%xmm1
subps  %xmm1,%xmm0
movups %xmm0,(%r11,%r10,4)
add    $0x8,%r10
add    $0xfffffffffffffffe,%rcx
jne    13a0 <forward_gradient+0x2a0>
testb  $0x1,-0x8(%rsp)
je     1447 <forward_gradient+0x347>
add    0x20(%rsp),%r10
mov    -0x48(%rsp),%rcx
lea    (%r10,%rcx,1),%r13
mov    -0x68(%rsp),%rcx
movups (%rcx,%r10,4),%xmm0
movups 0x4(%rcx,%r10,4),%xmm1
subps  %xmm0,%xmm1
mov    -0x78(%rsp),%rbx
movups %xmm1,(%rbx,%r10,4)
movups (%rcx,%r13,4),%xmm0
mov    -0x58(%rsp),%r13
movups (%rcx,%r10,4),%xmm1
subps  %xmm1,%xmm0
mov    -0x70(%rsp),%rcx
movups %xmm0,(%rcx,%r10,4)
mov    0x8(%rsp),%rcx
mov    %rcx,%rbx
cmp    %rax,%rcx
jne    1200 <forward_gradient+0x100>
jmp    11d0 <forward_gradient+0xd0>
xor    %ebx,%ebx
mov    -0x60(%rsp),%rbp
mov    -0x58(%rsp),%r13
jmp    1200 <forward_gradient+0x100>
xor    %r10d,%r10d
testb  $0x1,-0x8(%rsp)
jne    1400 <forward_gradient+0x300>
jmp    1447 <forward_gradient+0x347>
cmp    $0x2,%ebp
mov    -0x10(%rsp),%r12
jl     16d6 <forward_gradient+0x5d6>
mov    -0x40(%rsp),%ecx
imul   -0x60(%rsp),%ecx
movslq %ecx,%r9
cmpl   $0x8,-0x3c(%rsp)
jae    154f <forward_gradient+0x44f>
xor    %esi,%esi
mov    %rsi,%rcx
not    %rcx
test   $0x1,%al
je     14d9 <forward_gradient+0x3d9>
lea    (%rsi,%r9,1),%rdx
mov    -0x68(%rsp),%rdi
movss  0x4(%rdi,%rdx,4),%xmm0
subss  (%rdi,%rdx,4),%xmm0
mov    -0x78(%rsp),%rdi
movss  %xmm0,(%rdi,%rdx,4)
mov    -0x70(%rsp),%rdi
movl   $0x0,(%rdi,%rdx,4)
or     $0x1,%rsi
add    %rax,%rcx
je     16d6 <forward_gradient+0x5d6>
mov    -0x68(%rsp),%rcx
lea    (%rcx,%r9,4),%rcx
add    $0x8,%rcx
mov    -0x78(%rsp),%rdx
lea    (%rdx,%r9,4),%rdx
add    $0x4,%rdx
mov    -0x70(%rsp),%rdi
lea    (%rdi,%r9,4),%rdi
add    $0x4,%rdi
nopl   0x0(%rax)
movss  -0x4(%rcx,%rsi,4),%xmm0
subss  -0x8(%rcx,%rsi,4),%xmm0
movss  %xmm0,-0x4(%rdx,%rsi,4)
movl   $0x0,-0x4(%rdi,%rsi,4)
movss  (%rcx,%rsi,4),%xmm0
subss  -0x4(%rcx,%rsi,4),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
movl   $0x0,(%rdi,%rsi,4)
add    $0x2,%rsi
cmp    %rsi,%rax
jne    1510 <forward_gradient+0x410>
jmp    16d6 <forward_gradient+0x5d6>
mov    -0x78(%rsp),%rsi
lea    (%rsi,%r9,4),%rcx
lea    (%r9,%rax,1),%rdx
lea    (%rsi,%rdx,4),%rsi
mov    -0x70(%rsp),%rbp
lea    0x0(%rbp,%r9,4),%rdi
lea    0x0(%rbp,%rdx,4),%r14
mov    -0x68(%rsp),%rbp
lea    0x0(,%r9,4),%rbx
add    %rbp,%rbx
lea    0x4(,%rdx,4),%rdx
add    %rbp,%rdx
cmp    %r14,%rcx
setb   %r10b
cmp    %rsi,%rdi
setb   %r11b
cmp    %rdx,%rcx
setb   %cl
cmp    %rsi,%rbx
setb   %r8b
cmp    %rdx,%rdi
setb   %dl
cmp    %r14,%rbx
setb   %dil
xor    %esi,%esi
test   %r11b,%r10b
jne    14a1 <forward_gradient+0x3a1>
and    %r8b,%cl
jne    14a1 <forward_gradient+0x3a1>
and    %dil,%dl
jne    14a1 <forward_gradient+0x3a1>
mov    %eax,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rcx
mov    %rcx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     1817 <forward_gradient+0x717>
mov    %r8,%rbp
and    $0xfffffffffffffffe,%rbp
mov    -0x70(%rsp),%rcx
lea    (%rcx,%r9,4),%r10
add    $0x30,%r10
mov    -0x78(%rsp),%rcx
lea    (%rcx,%r9,4),%rdx
add    $0x30,%rdx
mov    -0x68(%rsp),%rcx
lea    (%rcx,%r9,4),%rbx
add    $0x34,%rbx
xor    %edi,%edi
xorps  %xmm0,%xmm0
nop
movups -0x34(%rbx,%rdi,4),%xmm1
movups -0x30(%rbx,%rdi,4),%xmm2
subps  %xmm1,%xmm2
movups -0x24(%rbx,%rdi,4),%xmm1
movups -0x20(%rbx,%rdi,4),%xmm3
subps  %xmm1,%xmm3
movups %xmm2,-0x30(%rdx,%rdi,4)
movups %xmm3,-0x20(%rdx,%rdi,4)
movups %xmm0,-0x30(%r10,%rdi,4)
movups %xmm0,-0x20(%r10,%rdi,4)
movups -0x14(%rbx,%rdi,4),%xmm1
movups -0x10(%rbx,%rdi,4),%xmm2
subps  %xmm1,%xmm2
movups -0x4(%rbx,%rdi,4),%xmm1
movups (%rbx,%rdi,4),%xmm3
subps  %xmm1,%xmm3
movups %xmm2,-0x10(%rdx,%rdi,4)
movups %xmm3,(%rdx,%rdi,4)
movups %xmm0,-0x10(%r10,%rdi,4)
movups %xmm0,(%r10,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1620 <forward_gradient+0x520>
test   $0x1,%r8b
je     16cd <forward_gradient+0x5cd>
add    %r9,%rdi
mov    -0x68(%rsp),%rcx
movups (%rcx,%rdi,4),%xmm0
movups 0x4(%rcx,%rdi,4),%xmm1
subps  %xmm0,%xmm1
movups 0x10(%rcx,%rdi,4),%xmm0
movups 0x14(%rcx,%rdi,4),%xmm2
subps  %xmm0,%xmm2
mov    -0x78(%rsp),%rcx
movups %xmm1,(%rcx,%rdi,4)
movups %xmm2,0x10(%rcx,%rdi,4)
xorps  %xmm0,%xmm0
mov    -0x70(%rsp),%rcx
movups %xmm0,(%rcx,%rdi,4)
movups %xmm0,0x10(%rcx,%rdi,4)
cmp    %rax,%rsi
jne    14a1 <forward_gradient+0x3a1>
cmp    $0x2,%r12d
jl     17e5 <forward_gradient+0x6e5>
mov    %r12d,%r8d
add    $0xffffffffffffffff,%r8
mov    $0x1,%edx
cmp    $0x2,%r12d
je     17a6 <forward_gradient+0x6a6>
mov    -0x68(%rsp),%rdx
mov    -0x48(%rsp),%rdi
lea    (%rdx,%rdi,8),%rsi
add    $0xfffffffffffffffc,%rsi
lea    0x0(,%rdi,8),%r9
mov    -0x78(%rsp),%rcx
lea    -0x4(%rcx,%rdi,4),%r10
lea    -0x4(%rdx,%rdi,4),%r11
mov    -0x70(%rsp),%rax
lea    -0x4(%rax,%rdi,4),%r14
lea    -0x4(%rax,%rdi,8),%r15
lea    (%rdi,%rdi,2),%rax
lea    (%rdx,%rax,4),%rbp
add    $0xfffffffffffffffc,%rbp
lea    (%rcx,%rdi,8),%rcx
add    $0xfffffffffffffffc,%rcx
mov    %r8,%rbx
and    $0xfffffffffffffffe,%rbx
neg    %rbx
mov    $0x1,%edx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movl   $0x0,(%r10,%rax,1)
movss  (%rsi,%rax,1),%xmm0
subss  (%r11,%rax,1),%xmm0
movss  %xmm0,(%r14,%rax,1)
movl   $0x0,(%rcx,%rax,1)
movss  0x0(%rbp,%rax,1),%xmm0
subss  (%rsi,%rax,1),%xmm0
movss  %xmm0,(%r15,%rax,1)
add    %r9,%rax
lea    (%rbx,%rdx,1),%rdi
add    $0x2,%rdi
add    $0x2,%rdx
cmp    $0x1,%rdi
jne    1760 <forward_gradient+0x660>
test   $0x1,%r8b
je     17e5 <forward_gradient+0x6e5>
mov    -0x48(%rsp),%rcx
imul   %rcx,%rdx
mov    -0x78(%rsp),%rax
movl   $0x0,-0x4(%rax,%rdx,4)
lea    (%rdx,%rcx,1),%rax
add    $0xffffffffffffffff,%rax
mov    -0x68(%rsp),%rcx
movss  (%rcx,%rax,4),%xmm0
subss  -0x4(%rcx,%rdx,4),%xmm0
mov    -0x70(%rsp),%rax
movss  %xmm0,-0x4(%rax,%rdx,4)
imul   -0x60(%rsp),%r12d
movslq %r12d,%rax
mov    -0x78(%rsp),%rcx
movl   $0x0,-0x4(%rcx,%rax,4)
mov    -0x70(%rsp),%rcx
movl   $0x0,-0x4(%rcx,%rax,4)
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edi,%edi
test   $0x1,%r8b
jne    168d <forward_gradient+0x58d>
jmp    16cd <forward_gradient+0x5cd>

LLVM IR (-O0):
define void @forward_gradient(float* %0, float* %1, float* %2, i32 %3, i32 %4) {
%6 = alloca float*
%7 = alloca float*
%8 = alloca float*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
store float* %0, float** %6
store float* %1, float** %7
store float* %2, float** %8
store i32 %3, i32* %9
store i32 %4, i32* %10
store i32 0, i32* %11
br label %20
20: ; preds = %76, %5
%21 = load i32, i32* %11
%22 = load i32, i32* %10
%23 = sub nsw i32 %22, 1
%24 = icmp slt i32 %21, %23
br i1 %24, label %25, label %79
25: ; preds = %20
store i32 0, i32* %12
br label %26
26: ; preds = %72, %25
%27 = load i32, i32* %12
%28 = load i32, i32* %9
%29 = sub nsw i32 %28, 1
%30 = icmp slt i32 %27, %29
br i1 %30, label %31, label %75
31: ; preds = %26
%32 = load i32, i32* %11
%33 = load i32, i32* %9
%34 = mul nsw i32 %32, %33
%35 = load i32, i32* %12
%36 = add nsw i32 %34, %35
store i32 %36, i32* %13
%37 = load i32, i32* %13
%38 = add nsw i32 %37, 1
store i32 %38, i32* %14
%39 = load i32, i32* %13
%40 = load i32, i32* %9
%41 = add nsw i32 %39, %40
store i32 %41, i32* %15
%42 = load float*, float** %6
%43 = load i32, i32* %14
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds float, float* %42, i64 %44
%46 = load float, float* %45
%47 = load float*, float** %6
%48 = load i32, i32* %13
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds float, float* %47, i64 %49
%51 = load float, float* %50
%52 = fsub float %46, %51
%53 = load float*, float** %7
%54 = load i32, i32* %13
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds float, float* %53, i64 %55
store float %52, float* %56
%57 = load float*, float** %6
%58 = load i32, i32* %15
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds float, float* %57, i64 %59
%61 = load float, float* %60
%62 = load float*, float** %6
%63 = load i32, i32* %13
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds float, float* %62, i64 %64
%66 = load float, float* %65
%67 = fsub float %61, %66
%68 = load float*, float** %8
%69 = load i32, i32* %13
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds float, float* %68, i64 %70
store float %67, float* %71
br label %72
72: ; preds = %31
%73 = load i32, i32* %12
%74 = add nsw i32 %73, 1
store i32 %74, i32* %12
br label %26
75: ; preds = %26
br label %76
76: ; preds = %75
%77 = load i32, i32* %11
%78 = add nsw i32 %77, 1
store i32 %78, i32* %11
br label %20
79: ; preds = %20
store i32 0, i32* %16
br label %80
80: ; preds = %112, %79
%81 = load i32, i32* %16
%82 = load i32, i32* %9
%83 = sub nsw i32 %82, 1
%84 = icmp slt i32 %81, %83
br i1 %84, label %85, label %115
85: ; preds = %80
%86 = load i32, i32* %10
%87 = sub nsw i32 %86, 1
%88 = load i32, i32* %9
%89 = mul nsw i32 %87, %88
%90 = load i32, i32* %16
%91 = add nsw i32 %89, %90
store i32 %91, i32* %17
%92 = load float*, float** %6
%93 = load i32, i32* %17
%94 = add nsw i32 %93, 1
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds float, float* %92, i64 %95
%97 = load float, float* %96
%98 = load float*, float** %6
%99 = load i32, i32* %17
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds float, float* %98, i64 %100
%102 = load float, float* %101
%103 = fsub float %97, %102
%104 = load float*, float** %7
%105 = load i32, i32* %17
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds float, float* %104, i64 %106
store float %103, float* %107
%108 = load float*, float** %8
%109 = load i32, i32* %17
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds float, float* %108, i64 %110
store float 0.000000e+00, float* %111
br label %112
112: ; preds = %85
%113 = load i32, i32* %16
%114 = add nsw i32 %113, 1
store i32 %114, i32* %16
br label %80
115: ; preds = %80
store i32 1, i32* %18
br label %116
116: ; preds = %146, %115
%117 = load i32, i32* %18
%118 = load i32, i32* %10
%119 = icmp slt i32 %117, %118
br i1 %119, label %120, label %149
120: ; preds = %116
%121 = load i32, i32* %18
%122 = load i32, i32* %9
%123 = mul nsw i32 %121, %122
%124 = sub nsw i32 %123, 1
store i32 %124, i32* %19
%125 = load float*, float** %7
%126 = load i32, i32* %19
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds float, float* %125, i64 %127
store float 0.000000e+00, float* %128
%129 = load float*, float** %6
%130 = load i32, i32* %19
%131 = load i32, i32* %9
%132 = add nsw i32 %130, %131
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds float, float* %129, i64 %133
%135 = load float, float* %134
%136 = load float*, float** %6
%137 = load i32, i32* %19
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds float, float* %136, i64 %138
%140 = load float, float* %139
%141 = fsub float %135, %140
%142 = load float*, float** %8
%143 = load i32, i32* %19
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds float, float* %142, i64 %144
store float %141, float* %145
br label %146
146: ; preds = %120
%147 = load i32, i32* %18
%148 = add nsw i32 %147, 1
store i32 %148, i32* %18
br label %116
149: ; preds = %116
%150 = load float*, float** %7
%151 = load i32, i32* %10
%152 = load i32, i32* %9
%153 = mul nsw i32 %151, %152
%154 = sub nsw i32 %153, 1
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds float, float* %150, i64 %155
store float 0.000000e+00, float* %156
%157 = load float*, float** %8
%158 = load i32, i32* %10
%159 = load i32, i32* %9
%160 = mul nsw i32 %158, %159
%161 = sub nsw i32 %160, 1
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds float, float* %157, i64 %162
store float 0.000000e+00, float* %163
ret void
}

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