void kernel_heat_3d(int tsteps, int n, double A[120 + 0][120 + 0][120 + 0],
                    double B[120 + 0][120 + 0][120 + 0]) {
  int t, i, j, k;
#pragma scop
  for (t = 1; t <= 500; t++) {
    for (i = 1; i < n - 1; i++) {
      for (j = 1; j < n - 1; j++) {
        for (k = 1; k < n - 1; k++) {
          B[i][j][k] =
              0.125 * (A[i + 1][j][k] - 2.0 * A[i][j][k] + A[i - 1][j][k]) +
              0.125 * (A[i][j + 1][k] - 2.0 * A[i][j][k] + A[i][j - 1][k]) +
              0.125 * (A[i][j][k + 1] - 2.0 * A[i][j][k] + A[i][j][k - 1]) +
              A[i][j][k];
        }
      }
    }
    for (i = 1; i < n - 1; i++) {
      for (j = 1; j < n - 1; j++) {
        for (k = 1; k < n - 1; k++) {
          A[i][j][k] =
              0.125 * (B[i + 1][j][k] - 2.0 * B[i][j][k] + B[i - 1][j][k]) +
              0.125 * (B[i][j + 1][k] - 2.0 * B[i][j][k] + B[i][j - 1][k]) +
              0.125 * (B[i][j][k + 1] - 2.0 * B[i][j][k] + B[i][j][k - 1]) +
              B[i][j][k];
        }
      }
    }
  }
#pragma endscop
}


x86 assembly (clang, -O0):
<kernel_heat_3d>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
movl   $0x1,-0x1c(%rbp)
cmpl   $0x1f4,-0x1c(%rbp)
jg     167b <kernel_heat_3d+0x57b>
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    13c7 <kernel_heat_3d+0x2c7>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    13b4 <kernel_heat_3d+0x2b4>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    13a1 <kernel_heat_3d+0x2a1>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x1c200,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x1c200,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  %xmm0,%xmm0
subsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x1c200,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x1c200,%rcx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x1c200,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  %xmm0,%xmm0
subsd  %xmm0,%xmm2
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x1c200,%rcx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
movsd  0xd70(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0xd64(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x1c200,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x1c200,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
addsd  %xmm2,%xmm2
subsd  %xmm2,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x1c200,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xcc7(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x1c200,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x1c200,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    115d <kernel_heat_3d+0x5d>
jmp    13a6 <kernel_heat_3d+0x2a6>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1145 <kernel_heat_3d+0x45>
jmp    13b9 <kernel_heat_3d+0x2b9>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    112d <kernel_heat_3d+0x2d>
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1668 <kernel_heat_3d+0x568>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1655 <kernel_heat_3d+0x555>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1642 <kernel_heat_3d+0x542>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x1c200,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x1c200,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  %xmm0,%xmm0
subsd  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x1c200,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x1c200,%rcx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x1c200,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  %xmm0,%xmm0
subsd  %xmm0,%xmm2
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x1c200,%rcx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
movsd  0xacf(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0xac3(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x1c200,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x1c200,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
addsd  %xmm2,%xmm2
subsd  %xmm2,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x1c200,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xa26(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x1c200,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x1c200,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13fe <kernel_heat_3d+0x2fe>
jmp    1647 <kernel_heat_3d+0x547>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13e6 <kernel_heat_3d+0x2e6>
jmp    165a <kernel_heat_3d+0x55a>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    13ce <kernel_heat_3d+0x2ce>
jmp    166d <kernel_heat_3d+0x56d>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1119 <kernel_heat_3d+0x19>
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_heat_3d>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rsi,%rax
mov    %rsi,-0x38(%rsp)
lea    -0x1(%rsi),%eax
lea    -0x1(%rax),%r14
mov    %r14,%r8
and    $0xfffffffffffffffe,%r8
mov    %r14,%rsi
or     $0x1,%rsi
mov    %rsi,-0x30(%rsp)
lea    0x387c8(%rdx),%rsi
mov    %rsi,0x10(%rsp)
lea    0x1c5c8(%rcx),%rsi
mov    %rsi,0x8(%rsp)
lea    0x1c5c0(%rcx),%rsi
mov    %rsi,(%rsp)
lea    0x1c5b8(%rdx),%rsi
mov    %rsi,-0x8(%rsp)
lea    0x387c8(%rcx),%rsi
mov    %rsi,-0x10(%rsp)
lea    0x1c5c8(%rdx),%rsi
mov    %rsi,-0x18(%rsp)
mov    %rdx,-0x48(%rsp)
lea    0x1c5c0(%rdx),%rdx
mov    %rdx,-0x20(%rsp)
mov    %rcx,-0x50(%rsp)
add    $0x1c5b8,%rcx
mov    %rcx,-0x28(%rsp)
movsd  0xe7f(%rip),%xmm0
movsd  0xe7f(%rip),%xmm1
movapd 0xe4e(%rip),%xmm8
movapd 0xe56(%rip),%xmm3
mov    $0x1,%ecx
jmp    11e3 <kernel_heat_3d+0xe3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0x3c(%rsp),%ecx
add    $0x1,%ecx
cmp    $0x1f5,%ecx
je     16bc <kernel_heat_3d+0x5bc>
mov    %ecx,-0x3c(%rsp)
cmpl   $0x3,-0x38(%rsp)
jl     11d0 <kernel_heat_3d+0xd0>
mov    $0x1,%r12d
mov    (%rsp),%rsi
mov    -0x8(%rsp),%rbp
mov    0x8(%rsp),%rbx
mov    0x10(%rsp),%r10
xor    %ecx,%ecx
jmp    125a <kernel_heat_3d+0x15a>
nopl   0x0(%rax,%rax,1)
mov    -0x80(%rsp),%rcx
add    $0x1,%rcx
mov    -0x70(%rsp),%r10
add    $0x1c200,%r10
mov    -0x68(%rsp),%rbx
add    $0x1c200,%rbx
mov    -0x60(%rsp),%rbp
add    $0x1c200,%rbp
mov    -0x58(%rsp),%rsi
add    $0x1c200,%rsi
mov    -0x78(%rsp),%rdx
mov    %rdx,%r12
cmp    %rax,%rdx
je     1450 <kernel_heat_3d+0x350>
mov    %rcx,-0x80(%rsp)
lea    0x2(%rcx),%r15
lea    0x1(%r12),%rcx
mov    %rcx,-0x78(%rsp)
mov    %rsi,-0x58(%rsp)
mov    %rbp,-0x60(%rsp)
mov    %rbx,-0x68(%rsp)
mov    %r10,-0x70(%rsp)
mov    $0x1,%edi
jmp    12b8 <kernel_heat_3d+0x1b8>
nopl   0x0(%rax,%rax,1)
add    $0x3c0,%r10
add    $0x3c0,%rbx
add    $0x3c0,%rbp
add    $0x3c0,%rsi
mov    %r13,%rdi
cmp    %rax,%r13
je     1210 <kernel_heat_3d+0x110>
lea    0x1(%rdi),%r13
mov    $0x1,%r9d
cmp    $0x2,%r14
jb     13d0 <kernel_heat_3d+0x2d0>
imul   $0x1c200,%r15,%rcx
add    -0x48(%rsp),%rcx
imul   $0x3c0,%rdi,%rdi
add    %rdi,%rcx
lea    (%rcx,%rax,8),%rcx
imul   $0x1c200,%r12,%r11
add    -0x50(%rsp),%r11
lea    (%rdi,%r11,1),%rdx
add    $0x8,%rdx
cmp    %rcx,%rdx
jae    1324 <kernel_heat_3d+0x224>
imul   $0x1c200,-0x80(%rsp),%rcx
add    -0x48(%rsp),%rcx
add    %rdi,%rcx
add    $0x8,%rcx
add    %rdi,%r11
lea    (%r11,%rax,8),%rdx
cmp    %rdx,%rcx
jb     13d0 <kernel_heat_3d+0x2d0>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movupd (%r10,%rdi,8),%xmm4
movupd -0x1c200(%r10,%rdi,8),%xmm5
3e fe ff
movapd %xmm5,%xmm6
mulpd  %xmm8,%xmm6
addpd  %xmm6,%xmm4
movupd -0x38400(%r10,%rdi,8),%xmm7
7c fc ff
addpd  %xmm4,%xmm7
movupd -0x1be40(%r10,%rdi,8),%xmm4
41 fe ff
addpd  %xmm6,%xmm4
movupd -0x1c5c0(%r10,%rdi,8),%xmm2
3a fe ff
addpd  %xmm4,%xmm2
mulpd  %xmm3,%xmm2
mulpd  %xmm3,%xmm7
addpd  %xmm2,%xmm7
movupd -0x1c1f8(%r10,%rdi,8),%xmm2
3e fe ff
addpd  %xmm6,%xmm2
movupd -0x1c208(%r10,%rdi,8),%xmm4
3d fe ff
addpd  %xmm2,%xmm4
mulpd  %xmm3,%xmm4
addpd  %xmm7,%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,(%rbx,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r8
jne    1330 <kernel_heat_3d+0x230>
mov    -0x30(%rsp),%r9
cmp    %r8,%r14
je     1290 <kernel_heat_3d+0x190>
nopl   0x0(%rax,%rax,1)
movsd  0x8(%rbp,%r9,8),%xmm2
movapd %xmm2,%xmm4
mulsd  %xmm0,%xmm4
movsd  0x1c208(%rbp,%r9,8),%xmm5
addsd  %xmm4,%xmm5
addsd  -0x1c1f8(%rbp,%r9,8),%xmm5
3e fe ff
movsd  0x3c8(%rbp,%r9,8),%xmm6
addsd  %xmm4,%xmm6
addsd  -0x3b8(%rbp,%r9,8),%xmm6
fc ff ff
mulsd  %xmm1,%xmm6
mulsd  %xmm1,%xmm5
addsd  %xmm6,%xmm5
addsd  0x10(%rbp,%r9,8),%xmm4
addsd  0x0(%rbp,%r9,8),%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm5,%xmm4
addsd  %xmm2,%xmm4
movsd  %xmm4,(%rsi,%r9,8)
lea    0x1(%r9),%rcx
mov    %rcx,%r9
cmp    %rcx,%rax
jne    13d0 <kernel_heat_3d+0x2d0>
jmp    1290 <kernel_heat_3d+0x190>
nopl   0x0(%rax)
cmpl   $0x3,-0x38(%rsp)
jl     11d0 <kernel_heat_3d+0xd0>
mov    $0x1,%ebx
mov    -0x20(%rsp),%rbp
mov    -0x28(%rsp),%r10
mov    -0x18(%rsp),%rsi
mov    -0x10(%rsp),%r12
xor    %ecx,%ecx
jmp    14ca <kernel_heat_3d+0x3ca>
nopl   0x0(%rax,%rax,1)
mov    -0x80(%rsp),%rcx
add    $0x1,%rcx
mov    -0x70(%rsp),%r12
add    $0x1c200,%r12
mov    -0x68(%rsp),%rsi
add    $0x1c200,%rsi
mov    -0x60(%rsp),%r10
add    $0x1c200,%r10
mov    -0x58(%rsp),%rbp
add    $0x1c200,%rbp
mov    -0x78(%rsp),%rdx
mov    %rdx,%rbx
cmp    %rax,%rdx
je     11d0 <kernel_heat_3d+0xd0>
mov    %rcx,-0x80(%rsp)
lea    0x2(%rcx),%r9
lea    0x1(%rbx),%rcx
mov    %rcx,-0x78(%rsp)
mov    %rbp,-0x58(%rsp)
mov    %r10,-0x60(%rsp)
mov    %rsi,-0x68(%rsp)
mov    %r12,-0x70(%rsp)
mov    $0x1,%edi
jmp    1528 <kernel_heat_3d+0x428>
nopw   0x0(%rax,%rax,1)
add    $0x3c0,%r12
add    $0x3c0,%rsi
add    $0x3c0,%r10
add    $0x3c0,%rbp
mov    %r13,%rdi
cmp    %rax,%r13
je     1480 <kernel_heat_3d+0x380>
lea    0x1(%rdi),%r13
mov    $0x1,%r11d
cmp    $0x2,%r14
jb     1640 <kernel_heat_3d+0x540>
imul   $0x1c200,%r9,%rcx
add    -0x50(%rsp),%rcx
imul   $0x3c0,%rdi,%rdi
add    %rdi,%rcx
lea    (%rcx,%rax,8),%rdx
imul   $0x1c200,%rbx,%rcx
add    -0x48(%rsp),%rcx
lea    (%rdi,%rcx,1),%r15
add    $0x8,%r15
cmp    %rdx,%r15
jae    1594 <kernel_heat_3d+0x494>
imul   $0x1c200,-0x80(%rsp),%rdx
add    -0x50(%rsp),%rdx
add    %rdi,%rdx
add    $0x8,%rdx
add    %rdi,%rcx
lea    (%rcx,%rax,8),%rcx
cmp    %rcx,%rdx
jb     1640 <kernel_heat_3d+0x540>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movupd (%r12,%rdi,8),%xmm2
movupd -0x1c200(%r12,%rdi,8),%xmm4
3e fe ff
movapd %xmm4,%xmm5
mulpd  %xmm8,%xmm5
addpd  %xmm5,%xmm2
movupd -0x38400(%r12,%rdi,8),%xmm6
7c fc ff
addpd  %xmm2,%xmm6
movupd -0x1be40(%r12,%rdi,8),%xmm2
41 fe ff
addpd  %xmm5,%xmm2
movupd -0x1c5c0(%r12,%rdi,8),%xmm7
3a fe ff
addpd  %xmm2,%xmm7
mulpd  %xmm3,%xmm7
mulpd  %xmm3,%xmm6
addpd  %xmm7,%xmm6
movupd -0x1c1f8(%r12,%rdi,8),%xmm2
3e fe ff
addpd  %xmm5,%xmm2
movupd -0x1c208(%r12,%rdi,8),%xmm5
3d fe ff
addpd  %xmm2,%xmm5
mulpd  %xmm3,%xmm5
addpd  %xmm6,%xmm5
addpd  %xmm4,%xmm5
movupd %xmm5,(%rsi,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r8
jne    15a0 <kernel_heat_3d+0x4a0>
mov    -0x30(%rsp),%r11
cmp    %r8,%r14
je     1500 <kernel_heat_3d+0x400>
nopl   0x0(%rax,%rax,1)
movsd  0x8(%r10,%r11,8),%xmm2
movapd %xmm2,%xmm4
mulsd  %xmm0,%xmm4
movsd  0x1c208(%r10,%r11,8),%xmm5
addsd  %xmm4,%xmm5
addsd  -0x1c1f8(%r10,%r11,8),%xmm5
3e fe ff
movsd  0x3c8(%r10,%r11,8),%xmm6
addsd  %xmm4,%xmm6
addsd  -0x3b8(%r10,%r11,8),%xmm6
fc ff ff
mulsd  %xmm1,%xmm6
mulsd  %xmm1,%xmm5
addsd  %xmm6,%xmm5
addsd  0x10(%r10,%r11,8),%xmm4
addsd  (%r10,%r11,8),%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm5,%xmm4
addsd  %xmm2,%xmm4
movsd  %xmm4,0x0(%rbp,%r11,8)
lea    0x1(%r11),%rcx
mov    %rcx,%r11
cmp    %rcx,%rax
jne    1640 <kernel_heat_3d+0x540>
jmp    1500 <kernel_heat_3d+0x400>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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