void fwd(float *next, float *curr, float *vsq, float *c_coeff, int nx, int ny,
         int nz, int dimx, int dimy, int dimz, int radius) {
#pragma omp parallel for collapse(3)
  for (int z = 0; z < nz; z++) {
    for (int y = 0; y < ny; y++) {
      for (int x = 0; x < nx; x++) {
        int this_offset = (((radius) + (z)) * (dimy) * (dimx) +
                           ((radius) + (y)) * (dimx) + ((radius) + (x)));
        float temp = 2.0f * curr[this_offset] - next[this_offset];
        float div = c_coeff[0] * curr[this_offset];
        for (int d = 1; d <= radius; d++) {
          int z_pos_offset = (((radius) + (z + d)) * (dimy) * (dimx) +
                              ((radius) + (y)) * (dimx) + ((radius) + (x)));
          int z_neg_offset = (((radius) + (z - d)) * (dimy) * (dimx) +
                              ((radius) + (y)) * (dimx) + ((radius) + (x)));
          int y_pos_offset = (((radius) + (z)) * (dimy) * (dimx) +
                              ((radius) + (y + d)) * (dimx) + ((radius) + (x)));
          int y_neg_offset = (((radius) + (z)) * (dimy) * (dimx) +
                              ((radius) + (y - d)) * (dimx) + ((radius) + (x)));
          int x_pos_offset = (((radius) + (z)) * (dimy) * (dimx) +
                              ((radius) + (y)) * (dimx) + ((radius) + (x + d)));
          int x_neg_offset = (((radius) + (z)) * (dimy) * (dimx) +
                              ((radius) + (y)) * (dimx) + ((radius) + (x - d)));
          div += c_coeff[d] *
                 (curr[z_pos_offset] + curr[z_neg_offset] + curr[y_pos_offset] +
                  curr[y_neg_offset] + curr[x_pos_offset] + curr[x_neg_offset]);
        }
        next[this_offset] = temp + div * vsq[this_offset];
      }
    }
  }
}


x86 assembly (clang, -O0):
<fwd>:
push   %rbp
mov    %rsp,%rbp
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    13c1 <fwd+0x2c1>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    13ae <fwd+0x2ae>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    139b <fwd+0x29b>
mov    0x30(%rbp),%eax
add    -0x2c(%rbp),%eax
imul   0x20(%rbp),%eax
imul   0x18(%rbp),%eax
mov    0x30(%rbp),%ecx
add    -0x30(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    %ecx,%eax
mov    0x30(%rbp),%ecx
add    -0x34(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x30(%rbp),%eax
jg     1361 <fwd+0x261>
mov    0x30(%rbp),%eax
mov    -0x2c(%rbp),%ecx
add    -0x44(%rbp),%ecx
add    %ecx,%eax
imul   0x20(%rbp),%eax
imul   0x18(%rbp),%eax
mov    0x30(%rbp),%ecx
add    -0x30(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    %ecx,%eax
mov    0x30(%rbp),%ecx
add    -0x34(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    0x30(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    -0x44(%rbp),%ecx
add    %ecx,%eax
imul   0x20(%rbp),%eax
imul   0x18(%rbp),%eax
mov    0x30(%rbp),%ecx
add    -0x30(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    %ecx,%eax
mov    0x30(%rbp),%ecx
add    -0x34(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    0x30(%rbp),%eax
add    -0x2c(%rbp),%eax
imul   0x20(%rbp),%eax
imul   0x18(%rbp),%eax
mov    0x30(%rbp),%ecx
mov    -0x30(%rbp),%edx
add    -0x44(%rbp),%edx
add    %edx,%ecx
imul   0x18(%rbp),%ecx
add    %ecx,%eax
mov    0x30(%rbp),%ecx
add    -0x34(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    0x30(%rbp),%eax
add    -0x2c(%rbp),%eax
imul   0x20(%rbp),%eax
imul   0x18(%rbp),%eax
mov    0x30(%rbp),%ecx
mov    -0x30(%rbp),%edx
sub    -0x44(%rbp),%edx
add    %edx,%ecx
imul   0x18(%rbp),%ecx
add    %ecx,%eax
mov    0x30(%rbp),%ecx
add    -0x34(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    0x30(%rbp),%eax
add    -0x2c(%rbp),%eax
imul   0x20(%rbp),%eax
imul   0x18(%rbp),%eax
mov    0x30(%rbp),%ecx
add    -0x30(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    %ecx,%eax
mov    0x30(%rbp),%ecx
mov    -0x34(%rbp),%edx
add    -0x44(%rbp),%edx
add    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    0x30(%rbp),%eax
add    -0x2c(%rbp),%eax
imul   0x20(%rbp),%eax
imul   0x18(%rbp),%eax
mov    0x30(%rbp),%ecx
add    -0x30(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    %ecx,%eax
mov    0x30(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    -0x44(%rbp),%edx
add    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11de <fwd+0xde>
movss  -0x3c(%rbp),%xmm1
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1158 <fwd+0x58>
jmp    13a0 <fwd+0x2a0>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1145 <fwd+0x45>
jmp    13b3 <fwd+0x2b3>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1132 <fwd+0x32>
pop    %rbp
ret

x86 assembly (clang, -O2):
<fwd>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x50,%rsp
mov    %r9d,-0x80(%rsp)
mov    %r8d,-0x70(%rsp)
mov    %rdx,0x30(%rsp)
mov    %rdi,0x28(%rsp)
mov    0x88(%rsp),%edx
test   %edx,%edx
jle    1462 <fwd+0x362>
mov    0xa8(%rsp),%ebp
mov    0x98(%rsp),%edi
mov    0x90(%rsp),%eax
mov    %edi,%r14d
imul   %eax,%r14d
lea    0x1(%rbp),%r8d
movslq %ebp,%r11
movslq %eax,%r10
mov    %edx,%edx
mov    %rdx,-0x8(%rsp)
mov    -0x80(%rsp),%edx
mov    %rdx,0x18(%rsp)
mov    -0x70(%rsp),%edx
mov    %rdx,0x20(%rsp)
add    $0x1,%edi
mov    %eax,%ebp
imul   %edi,%ebp
add    $0x1,%ebp
imul   %r11d,%ebp
lea    0x1(%rbp),%edx
mov    %rdx,-0x18(%rsp)
imul   %r11d,%edi
lea    -0x1(%r8),%r9
mov    %r8d,%edx
imul   %r14d,%edx
lea    0x1(%r10),%r8d
imul   %r11d,%r8d
add    %r8d,%edx
mov    %edx,-0x74(%rsp)
lea    -0x1(%r11),%edx
imul   %r14d,%edx
add    %r8d,%edx
mov    %edx,-0x78(%rsp)
lea    0x1(%rdi),%edx
imul   %eax,%edx
add    %r11d,%edx
mov    %edx,-0x7c(%rsp)
add    $0xffffffff,%ebp
mov    %rbp,-0x50(%rsp)
add    $0xffffffff,%edi
imul   %eax,%edi
mov    %r11,%rdx
mov    %r11,-0x10(%rsp)
add    %r11d,%edi
mov    %rdi,-0x48(%rsp)
mov    %r10,(%rsp)
mov    %r10d,%edx
mov    %rdx,0x10(%rsp)
xor    %edx,%edx
mov    %rdx,-0x58(%rsp)
jmp    124a <fwd+0x14a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x58(%rsp),%rdi
add    $0x1,%rdi
add    %r14,-0x18(%rsp)
add    %r14d,-0x7c(%rsp)
add    %r14d,-0x74(%rsp)
mov    -0x50(%rsp),%rdx
add    %r14d,%edx
mov    %rdx,-0x50(%rsp)
mov    -0x48(%rsp),%rdx
add    %r14d,%edx
mov    %rdx,-0x48(%rsp)
add    %r14d,-0x78(%rsp)
mov    %rdi,%rdx
mov    %rdi,-0x58(%rsp)
cmp    -0x8(%rsp),%rdi
je     1462 <fwd+0x362>
cmpl   $0x0,-0x80(%rsp)
jle    1200 <fwd+0x100>
mov    0xa8(%rsp),%edx
mov    -0x58(%rsp),%rdi
add    %edi,%edx
imul   %r14d,%edx
movslq %edx,%rdx
mov    %rdx,0x8(%rsp)
mov    -0x78(%rsp),%edx
mov    %edx,-0x5c(%rsp)
mov    -0x48(%rsp),%rdx
mov    %edx,-0x60(%rsp)
mov    -0x50(%rsp),%rdx
mov    %edx,-0x64(%rsp)
mov    -0x74(%rsp),%edx
mov    %edx,-0x68(%rsp)
mov    -0x7c(%rsp),%edx
mov    %edx,-0x6c(%rsp)
mov    -0x18(%rsp),%rdx
mov    %rdx,-0x38(%rsp)
xor    %edx,%edx
mov    %rdx,-0x40(%rsp)
jmp    12f6 <fwd+0x1f6>
nopl   0x0(%rax,%rax,1)
mov    -0x40(%rsp),%rdi
add    $0x1,%rdi
mov    -0x38(%rsp),%rdx
add    0x10(%rsp),%rdx
mov    %rdx,-0x38(%rsp)
mov    0x90(%rsp),%eax
add    %eax,-0x6c(%rsp)
add    %eax,-0x68(%rsp)
add    %eax,-0x64(%rsp)
add    %eax,-0x60(%rsp)
add    %eax,-0x5c(%rsp)
mov    %rdi,%rdx
mov    %rdi,-0x40(%rsp)
cmp    0x18(%rsp),%rdi
je     1200 <fwd+0x100>
cmpl   $0x0,-0x70(%rsp)
jle    12b0 <fwd+0x1b0>
mov    -0x10(%rsp),%rdx
mov    -0x40(%rsp),%rdi
add    %rdi,%rdx
imul   (%rsp),%rdx
add    0x8(%rsp),%rdx
mov    %rdx,0x38(%rsp)
mov    -0x5c(%rsp),%edi
mov    -0x60(%rsp),%eax
mov    -0x64(%rsp),%edx
mov    -0x68(%rsp),%r12d
mov    -0x6c(%rsp),%r11d
mov    -0x38(%rsp),%rbp
xor    %ebx,%ebx
jmp    13a5 <fwd+0x2a5>
nopl   0x0(%rax,%rax,1)
addss  %xmm0,%xmm0
mov    0x28(%rsp),%rdi
mov    0x40(%rsp),%rax
subss  (%rdi,%rax,4),%xmm0
mov    0x30(%rsp),%rdx
mulss  (%rdx,%rax,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%rax,4)
mov    0x48(%rsp),%rbx
add    $0x1,%rbx
add    $0x1,%rbp
mov    -0x2c(%rsp),%r11d
add    $0x1,%r11d
mov    -0x28(%rsp),%r12d
add    $0x1,%r12d
mov    -0x24(%rsp),%edx
add    $0x1,%edx
mov    -0x20(%rsp),%eax
add    $0x1,%eax
mov    -0x1c(%rsp),%edi
add    $0x1,%edi
cmp    0x20(%rsp),%rbx
je     12b0 <fwd+0x1b0>
mov    -0x10(%rsp),%r8
lea    (%rbx,%r8,1),%r10
add    0x38(%rsp),%r10
movss  (%rsi,%r10,4),%xmm0
movss  (%rcx),%xmm1
mulss  %xmm0,%xmm1
test   %r8d,%r8d
mov    %edi,-0x1c(%rsp)
mov    %eax,-0x20(%rsp)
mov    %edx,-0x24(%rsp)
mov    %r12d,-0x28(%rsp)
mov    %r11d,-0x2c(%rsp)
mov    %rbx,0x48(%rsp)
mov    %r10,0x40(%rsp)
jle    1340 <fwd+0x240>
mov    %eax,%r15d
mov    %edx,%r10d
mov    %r12d,%r8d
mov    %r11d,%r13d
xor    %r11d,%r11d
mov    0x90(%rsp),%eax
movslq %r8d,%r8
movss  (%rsi,%r8,4),%xmm2
movslq %edi,%rdi
addss  (%rsi,%rdi,4),%xmm2
movslq %r13d,%r13
addss  (%rsi,%r13,4),%xmm2
lea    0x0(%rbp,%r11,1),%r12d
movslq %r15d,%r15
addss  (%rsi,%r15,4),%xmm2
movslq %r12d,%rdx
addss  (%rsi,%rdx,4),%xmm2
movslq %r10d,%r10
addss  (%rsi,%r10,4),%xmm2
mulss  0x4(%rcx,%r11,4),%xmm2
addss  %xmm2,%xmm1
add    $0x1,%r11
add    %eax,%r13d
add    %r14d,%r8d
add    $0xffffffff,%r10d
sub    %eax,%r15d
sub    %r14d,%edi
cmp    %r11,%r9
jne    1400 <fwd+0x300>
jmp    1340 <fwd+0x240>
add    $0x50,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @fwd(float* nocapture %0, float* nocapture %1, float* nocapture %2, float* nocapture %3, i32 %4, i32 %5, i32 %6, i32 %7, i32 %8, i32 %9, i32 %10) {
%12 = icmp sgt i32 %6, 0
br i1 %12, label %13, label %34
13: ; preds = %11
%14 = icmp sgt i32 %5, 0
%15 = icmp sgt i32 %4, 0
%16 = mul i32 %8, %7
%17 = icmp slt i32 %10, 1
%18 = add i32 %10, 1
%19 = sext i32 %10 to i64
%20 = sext i32 %7 to i64
%21 = zext i32 %6 to i64
%22 = zext i32 %5 to i64
%23 = zext i32 %4 to i64
%24 = zext i32 %18 to i64
br label %25
25: ; preds = %13, %46
%26 = phi i64 [ 0, %13 ], [ %47, %46 ]
br i1 %14, label %27, label %46
27: ; preds = %25
%28 = trunc i64 %26 to i32
%29 = add i32 %28, %10
%30 = mul i32 %16, %29
%31 = trunc i64 %26 to i32
%32 = add i32 %31, %10
%33 = sext i32 %30 to i64
br label %35
34: ; preds = %46, %11
ret void
35: ; preds = %27, %49
%36 = phi i64 [ 0, %27 ], [ %50, %49 ]
br i1 %15, label %37, label %49
37: ; preds = %35
%38 = add nsw i64 %36, %19
%39 = mul nsw i64 %38, %20
%40 = add nsw i64 %39, %33
%41 = trunc i64 %36 to i32
%42 = add i32 %41, %10
%43 = trunc i64 %40 to i32
%44 = add i32 %43, %10
%45 = trunc i64 %39 to i32
br label %52
46: ; preds = %49, %25
%47 = add nuw nsw i64 %26, 1
%48 = icmp eq i64 %47, %21
br i1 %48, label %34, label %25
49: ; preds = %70, %35
%50 = add nuw nsw i64 %36, 1
%51 = icmp eq i64 %50, %22
br i1 %51, label %46, label %35
52: ; preds = %37, %70
%53 = phi i64 [ 0, %37 ], [ %75, %70 ]
%54 = add nsw i64 %53, %19
%55 = add nsw i64 %54, %40
%56 = getelementptr inbounds float, float* %1, i64 %55
%57 = load float, float* %56
%58 = getelementptr inbounds float, float* %0, i64 %55
%59 = load float, float* %58
%60 = fneg float %59
%61 = tail call float @llvm.fmuladd.f32(float %57, float 2.000000e+00, float %60)
%62 = load float, float* %3
%63 = fmul float %57, %62
br i1 %17, label %70, label %64
64: ; preds = %52
%65 = trunc i64 %54 to i32
%66 = add i32 %65, %45
%67 = add i32 %30, %65
%68 = trunc i64 %53 to i32
%69 = add i32 %44, %68
br label %77
70: ; preds = %77, %52
%71 = phi float [ %63, %52 ], [ %124, %77 ]
%72 = getelementptr inbounds float, float* %2, i64 %55
%73 = load float, float* %72
%74 = tail call float @llvm.fmuladd.f32(float %71, float %73, float %61)
store float %74, float* %58
%75 = add nuw nsw i64 %53, 1
%76 = icmp eq i64 %75, %23
br i1 %76, label %49, label %52
77: ; preds = %64, %77
%78 = phi i64 [ 1, %64 ], [ %125, %77 ]
%79 = phi i64 [ -1, %64 ], [ %126, %77 ]
%80 = phi float [ %63, %64 ], [ %124, %77 ]
%81 = trunc i64 %78 to i32
%82 = add i32 %81, %10
%83 = add i32 %82, %31
%84 = mul i32 %16, %83
%85 = add i32 %66, %84
%86 = trunc i64 %79 to i32
%87 = add i32 %32, %86
%88 = mul i32 %16, %87
%89 = add i32 %66, %88
%90 = add i32 %82, %41
%91 = mul nsw i32 %90, %7
%92 = add i32 %67, %91
%93 = add i32 %42, %86
%94 = mul nsw i32 %93, %7
%95 = add i32 %67, %94
%96 = add i32 %82, %43
%97 = add i32 %96, %68
%98 = add i32 %69, %86
%99 = getelementptr inbounds float, float* %3, i64 %78
%100 = load float, float* %99
%101 = sext i32 %85 to i64
%102 = getelementptr inbounds float, float* %1, i64 %101
%103 = load float, float* %102
%104 = sext i32 %89 to i64
%105 = getelementptr inbounds float, float* %1, i64 %104
%106 = load float, float* %105
%107 = fadd float %103, %106
%108 = sext i32 %92 to i64
%109 = getelementptr inbounds float, float* %1, i64 %108
%110 = load float, float* %109
%111 = fadd float %107, %110
%112 = sext i32 %95 to i64
%113 = getelementptr inbounds float, float* %1, i64 %112
%114 = load float, float* %113
%115 = fadd float %111, %114
%116 = sext i32 %97 to i64
%117 = getelementptr inbounds float, float* %1, i64 %116
%118 = load float, float* %117
%119 = fadd float %115, %118
%120 = sext i32 %98 to i64
%121 = getelementptr inbounds float, float* %1, i64 %120
%122 = load float, float* %121
%123 = fadd float %119, %122
%124 = tail call float @llvm.fmuladd.f32(float %100, float %123, float %80)
%125 = add nuw nsw i64 %78, 1
%126 = add nsw i64 %79, -1
%127 = icmp eq i64 %125, %24
br i1 %127, label %70, label %77
}