void diffusion_baseline(float *f1, float *f2, int nx, int ny, int nz, float ce,
                        float cw, float cn, float cs, float ct, float cb,
                        float cc, float dt, float **f_ret, float *time_ret,
                        int *count_ret) {
  float time = 0.0;
  int count = 0;
  do {
    int z;
    for (z = 0; z < nz; z++) {
      int y;
      for (y = 0; y < ny; y++) {
        int x;
        for (x = 0; x < nx; x++) {
          int c, w, e, n, s, b, t;
          c = x + y * nx + z * nx * ny;
          w = (x == 0) ? c : c - 1;
          e = (x == nx - 1) ? c : c + 1;
          n = (y == 0) ? c : c - nx;
          s = (y == ny - 1) ? c : c + nx;
          b = (z == 0) ? c : c - nx * ny;
          t = (z == nz - 1) ? c : c + nx * ny;
          f2[c] = cc * f1[c] + cw * f1[w] + ce * f1[e] + cs * f1[s] +
                  cn * f1[n] + cb * f1[b] + ct * f1[t];
        }
      }
    }
    float *t = f1;
    f1 = f2;
    f2 = t;
    time += dt;
    count++;
  } while (time + 0.5 * dt < 0.1);
  *time_ret = time;
  *f_ret = f1;
  *count_ret = count;
  return;
}


x86 assembly (clang, -O0):
<diffusion_baseline>:
push   %rbp
mov    %rsp,%rbp
sub    $0x18,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
movss  %xmm0,-0x20(%rbp)
movss  %xmm1,-0x24(%rbp)
movss  %xmm2,-0x28(%rbp)
movss  %xmm3,-0x2c(%rbp)
movss  %xmm4,-0x30(%rbp)
movss  %xmm5,-0x34(%rbp)
movss  %xmm6,-0x38(%rbp)
movss  %xmm7,-0x3c(%rbp)
mov    %r9,-0x48(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13d0 <diffusion_baseline+0x2d0>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    13bd <diffusion_baseline+0x2bd>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13aa <diffusion_baseline+0x2aa>
mov    -0x5c(%rbp),%eax
mov    -0x58(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
mov    -0x54(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x60(%rbp)
cmpl   $0x0,-0x5c(%rbp)
jne    11ca <diffusion_baseline+0xca>
mov    -0x60(%rbp),%eax
mov    %eax,-0x84(%rbp)
jmp    11d6 <diffusion_baseline+0xd6>
mov    -0x60(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    11fe <diffusion_baseline+0xfe>
mov    -0x60(%rbp),%eax
mov    %eax,-0x88(%rbp)
jmp    120a <diffusion_baseline+0x10a>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    %eax,-0x68(%rbp)
cmpl   $0x0,-0x58(%rbp)
jne    122b <diffusion_baseline+0x12b>
mov    -0x60(%rbp),%eax
mov    %eax,-0x8c(%rbp)
jmp    1237 <diffusion_baseline+0x137>
mov    -0x60(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    125f <diffusion_baseline+0x15f>
mov    -0x60(%rbp),%eax
mov    %eax,-0x90(%rbp)
jmp    126b <diffusion_baseline+0x16b>
mov    -0x60(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
mov    %eax,-0x70(%rbp)
cmpl   $0x0,-0x54(%rbp)
jne    128c <diffusion_baseline+0x18c>
mov    -0x60(%rbp),%eax
mov    %eax,-0x94(%rbp)
jmp    129e <diffusion_baseline+0x19e>
mov    -0x60(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    12c6 <diffusion_baseline+0x1c6>
mov    -0x60(%rbp),%eax
mov    %eax,-0x98(%rbp)
jmp    12d8 <diffusion_baseline+0x1d8>
mov    -0x60(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    %eax,-0x78(%rbp)
movss  -0x38(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x2c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x34(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x74(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    118a <diffusion_baseline+0x8a>
jmp    13af <diffusion_baseline+0x2af>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1177 <diffusion_baseline+0x77>
jmp    13c2 <diffusion_baseline+0x2c2>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1164 <diffusion_baseline+0x64>
mov    -0x8(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0x10(%rbp)
movss  -0x3c(%rbp),%xmm0
addss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x3c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xbee(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xbd6(%rip),%xmm0
ucomisd %xmm1,%xmm0
ja     115d <diffusion_baseline+0x5d>
movss  -0x4c(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rcx
mov    -0x48(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x50(%rbp),%ecx
mov    0x18(%rbp),%rax
mov    %ecx,(%rax)
add    $0x18,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<diffusion_baseline>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r9,-0x10(%rsp)
mov    %rsi,%r10
movss  %xmm7,-0x38(%rsp)
cvtss2sd %xmm7,%xmm7
lea    -0x1(%rdx),%r13d
lea    -0x1(%rcx),%esi
mov    %esi,-0x2c(%rsp)
mov    %rcx,%rax
mov    %rcx,-0x18(%rsp)
mov    %ecx,%esi
imul   %edx,%esi
mov    %rsi,-0x20(%rsp)
mov    %r8,%rsi
mov    %r8,-0x28(%rsp)
lea    -0x1(%r8),%esi
mov    %esi,-0x30(%rsp)
mov    %edx,%ebp
xorps  %xmm9,%xmm9
mulsd  0xea9(%rip),%xmm7
movsd  %xmm7,-0x8(%rsp)
xor    %ecx,%ecx
jmp    11a6 <diffusion_baseline+0xa6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addss  -0x38(%rsp),%xmm9
mov    -0x34(%rsp),%ecx
add    $0x1,%ecx
xorps  %xmm7,%xmm7
cvtss2sd %xmm9,%xmm7
addsd  -0x8(%rsp),%xmm7
movsd  0xe73(%rip),%xmm8
ucomisd %xmm7,%xmm8
mov    %rdi,%r10
mov    %rsi,%rdi
jbe    1331 <diffusion_baseline+0x231>
mov    %ecx,-0x34(%rsp)
mov    %r10,%rsi
cmpl   $0x0,-0x28(%rsp)
jle    1170 <diffusion_baseline+0x70>
xor    %eax,%eax
mov    %rax,-0x40(%rsp)
movl   $0x0,-0x44(%rsp)
jmp    11f0 <diffusion_baseline+0xf0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x44(%rsp),%ecx
add    $0x1,%ecx
mov    -0x40(%rsp),%rax
add    -0x20(%rsp),%rax
mov    %rax,-0x40(%rsp)
mov    %ecx,-0x44(%rsp)
cmp    -0x28(%rsp),%ecx
je     1170 <diffusion_baseline+0x70>
cmpl   $0x0,-0x18(%rsp)
jle    11d0 <diffusion_baseline+0xd0>
mov    -0x44(%rsp),%eax
test   %eax,%eax
mov    -0x20(%rsp),%r14
mov    %r14d,%ebx
cmove  %eax,%ebx
xor    %ecx,%ecx
cmp    -0x30(%rsp),%eax
cmove  %ecx,%r14d
mov    -0x40(%rsp),%r15
add    %r15d,%r14d
mov    %r15d,%r10d
sub    %ebx,%r10d
jmp    1242 <diffusion_baseline+0x142>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%ecx
add    %rbp,%r14
add    %rbp,%r10
add    %rbp,%r15
cmp    -0x18(%rsp),%ecx
je     11d0 <diffusion_baseline+0xd0>
test   %edx,%edx
jle    1230 <diffusion_baseline+0x130>
test   %ecx,%ecx
mov    %edx,%r9d
cmove  %ecx,%r9d
movslq %r15d,%r8
cmp    -0x2c(%rsp),%ecx
mov    %edx,%ebx
mov    $0x0,%eax
cmove  %eax,%ebx
movslq %ebx,%r12
add    %r8,%r12
sub    %r9d,%r8d
xor    %r9d,%r9d
nopl   0x0(%rax)
lea    (%r15,%r9,1),%r11
cmp    $0x1,%r9
mov    %r11d,%ebx
adc    $0xffffffff,%ebx
movslq %ebx,%rbx
movss  (%rdi,%rbx,4),%xmm11
xor    %ebx,%ebx
cmp    %r9,%r13
setne  %bl
add    %r11d,%ebx
movslq %ebx,%rbx
movss  (%rdi,%rbx,4),%xmm12
lea    (%r12,%r9,1),%ebx
movslq %ebx,%rbx
movss  (%rdi,%rbx,4),%xmm13
lea    (%r8,%r9,1),%ebx
movslq %ebx,%rbx
movss  (%rdi,%rbx,4),%xmm14
lea    (%r10,%r9,1),%ebx
movslq %ebx,%rbx
movss  (%rdi,%rbx,4),%xmm15
lea    (%r14,%r9,1),%ebx
movslq %ebx,%rbx
movss  (%rdi,%rbx,4),%xmm10
movslq %r11d,%rbx
mulss  %xmm1,%xmm11
movss  (%rdi,%rbx,4),%xmm8
mulss  %xmm6,%xmm8
addss  %xmm11,%xmm8
mulss  %xmm0,%xmm12
addss  %xmm8,%xmm12
mulss  %xmm3,%xmm13
addss  %xmm12,%xmm13
mulss  %xmm2,%xmm14
addss  %xmm13,%xmm14
mulss  %xmm5,%xmm15
addss  %xmm14,%xmm15
mulss  %xmm4,%xmm10
addss  %xmm15,%xmm10
movss  %xmm10,(%rsi,%rbx,4)
add    $0x1,%r9
cmp    %r9,%rbp
jne    1270 <diffusion_baseline+0x170>
jmp    1230 <diffusion_baseline+0x130>
mov    0x38(%rsp),%rax
movss  %xmm9,(%rax)
mov    -0x10(%rsp),%rax
mov    %rsi,(%rax)
mov    0x40(%rsp),%rax
mov    %ecx,(%rax)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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