int calculate_diffusion(long int *const paths, long int *diffusion,
                        long int *rdiff, long int nreplicas, long int ntimes,
                        long int *maxelapsed, long int *maxelapsed_cum) {
  long int p, p1, p2, r, t, i, telapsed;
  long int *positions;
  for (i = 0; i < nreplicas * nreplicas; ++i) {
    rdiff[i] = 0;
    diffusion[i] = 0;
  }
  for (t = 0; t < ntimes; ++t) {
    *maxelapsed += 1;
    *maxelapsed_cum += *maxelapsed;
    for (i = 0; i < nreplicas * nreplicas; ++i)
      rdiff[i] += 1;
    positions = &paths[t * nreplicas];
    for (r = 0; r < nreplicas; ++r) {
      p = positions[r];
      rdiff[r * nreplicas + p] = 0;
    }
    for (r = 0; r < nreplicas; ++r) {
      p1 = positions[r];
      for (p2 = 0; p2 < nreplicas; ++p2) {
        telapsed = rdiff[r * nreplicas + p2];
        diffusion[p1 * nreplicas + p2] += telapsed;
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<calculate_diffusion>:
push   %rbp
mov    %rsp,%rbp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x20(%rbp),%rcx
imul   -0x20(%rbp),%rcx
cmp    %rcx,%rax
jge    116f <calculate_diffusion+0x6f>
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1128 <calculate_diffusion+0x28>
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    12fe <calculate_diffusion+0x1fe>
mov    -0x30(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x30(%rbp),%rax
mov    (%rax),%rcx
mov    0x10(%rbp),%rax
add    (%rax),%rcx
mov    %rcx,(%rax)
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x20(%rbp),%rcx
imul   -0x20(%rbp),%rcx
cmp    %rcx,%rax
jge    11e7 <calculate_diffusion+0xe7>
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
add    $0x1,%rdx
mov    %rdx,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    11ac <calculate_diffusion+0xac>
mov    -0x8(%rbp),%rax
mov    -0x58(%rbp),%rcx
imul   -0x20(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    124f <calculate_diffusion+0x14f>
mov    -0x70(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    -0x38(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1207 <calculate_diffusion+0x107>
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    12e8 <calculate_diffusion+0x1e8>
mov    -0x70(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x40(%rbp)
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    12d2 <calculate_diffusion+0x1d2>
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rdx
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    -0x48(%rbp),%rcx
add    (%rax,%rcx,8),%rdx
mov    %rdx,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    127d <calculate_diffusion+0x17d>
jmp    12d7 <calculate_diffusion+0x1d7>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1257 <calculate_diffusion+0x157>
jmp    12ed <calculate_diffusion+0x1ed>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1177 <calculate_diffusion+0x77>
xor    %eax,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<calculate_diffusion>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %r9,-0x8(%rsp)
mov    %r8,-0x68(%rsp)
mov    %rdx,%r11
mov    %rdi,-0x78(%rsp)
mov    %rcx,%rbx
imul   %rcx,%rbx
test   %rbx,%rbx
je     12f8 <calculate_diffusion+0x1f8>
cmp    $0x4,%rbx
jb     1150 <calculate_diffusion+0x50>
lea    (%rsi,%rbx,8),%rax
cmp    %r11,%rax
jbe    11f4 <calculate_diffusion+0xf4>
lea    (%r11,%rbx,8),%rax
cmp    %rsi,%rax
jbe    11f4 <calculate_diffusion+0xf4>
xor    %edx,%edx
mov    %rdx,%rax
not    %rax
add    %rbx,%rax
mov    %rbx,%rdi
and    $0x3,%rdi
je     118a <calculate_diffusion+0x8a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movq   $0x0,(%r11,%rdx,8)
movq   $0x0,(%rsi,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1170 <calculate_diffusion+0x70>
cmp    $0x3,%rax
jb     12f8 <calculate_diffusion+0x1f8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movq   $0x0,(%r11,%rdx,8)
movq   $0x0,(%rsi,%rdx,8)
movq   $0x0,0x8(%r11,%rdx,8)
movq   $0x0,0x8(%rsi,%rdx,8)
movq   $0x0,0x10(%r11,%rdx,8)
movq   $0x0,0x10(%rsi,%rdx,8)
movq   $0x0,0x18(%r11,%rdx,8)
movq   $0x0,0x18(%rsi,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rbx
jne    11a0 <calculate_diffusion+0xa0>
jmp    12f8 <calculate_diffusion+0x1f8>
mov    %rbx,%rdx
and    $0xfffffffffffffffc,%rdx
lea    -0x4(%rdx),%rax
mov    %rax,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0xc,%rax
jae    121e <calculate_diffusion+0x11e>
xor    %ebp,%ebp
jmp    12b0 <calculate_diffusion+0x1b0>
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
add    $0xfffffffffffffffe,%rax
and    %rax,%rdi
xor    %ebp,%ebp
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movdqu %xmm0,(%r11,%rbp,8)
movdqu %xmm0,0x10(%r11,%rbp,8)
movdqu %xmm0,(%rsi,%rbp,8)
movdqu %xmm0,0x10(%rsi,%rbp,8)
movdqu %xmm0,0x20(%r11,%rbp,8)
movdqu %xmm0,0x30(%r11,%rbp,8)
movdqu %xmm0,0x20(%rsi,%rbp,8)
movdqu %xmm0,0x30(%rsi,%rbp,8)
movdqu %xmm0,0x40(%r11,%rbp,8)
movdqu %xmm0,0x50(%r11,%rbp,8)
movdqu %xmm0,0x40(%rsi,%rbp,8)
movdqu %xmm0,0x50(%rsi,%rbp,8)
movdqu %xmm0,0x60(%r11,%rbp,8)
movdqu %xmm0,0x70(%r11,%rbp,8)
movdqu %xmm0,0x60(%rsi,%rbp,8)
movdqu %xmm0,0x70(%rsi,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1240 <calculate_diffusion+0x140>
test   %r8,%r8
je     12ef <calculate_diffusion+0x1ef>
lea    (%rsi,%rbp,8),%rax
add    $0x10,%rax
lea    (%r11,%rbp,8),%rdi
add    $0x10,%rdi
shl    $0x5,%r8
xor    %ebp,%ebp
pxor   %xmm0,%xmm0
nop
movdqu %xmm0,-0x10(%rdi,%rbp,1)
movdqu %xmm0,(%rdi,%rbp,1)
movdqu %xmm0,-0x10(%rax,%rbp,1)
movdqu %xmm0,(%rax,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r8
jne    12d0 <calculate_diffusion+0x1d0>
cmp    %rdx,%rbx
jne    1152 <calculate_diffusion+0x52>
cmpq   $0x0,-0x68(%rsp)
jle    179e <calculate_diffusion+0x69e>
lea    -0x4(%rbx),%rax
mov    %rax,-0x30(%rsp)
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
lea    -0x1(%rcx),%rax
mov    %rax,-0x18(%rsp)
lea    -0x4(%rcx),%rax
mov    %rax,0x20(%rsp)
mov    %rax,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %rbx,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,-0x40(%rsp)
mov    %rdx,%rax
mov    %rdx,-0x38(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,-0x58(%rsp)
mov    %ecx,%r8d
and    $0x3,%r8d
mov    %rcx,%r14
and    $0xfffffffffffffffc,%r14
mov    %rdi,%rax
mov    %rdi,0x18(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x8(%rsp)
mov    %rcx,%rax
neg    %rax
mov    %rax,0x30(%rsp)
mov    -0x78(%rsp),%rax
lea    0x18(%rax),%r10
lea    0x0(,%rcx,8),%r15
lea    (%rcx,%rcx,1),%rdx
mov    %rdx,-0x20(%rsp)
pcmpeqd %xmm0,%xmm0
lea    0x0(,%rcx,4),%rdi
lea    (%rcx,%rcx,2),%rbp
lea    0x30(%r11),%rdx
mov    %rdx,-0x28(%rsp)
lea    0x30(%rsi),%rdx
mov    %rdx,(%rsp)
lea    0x8(%rsi),%rdx
mov    %rdx,0x28(%rsp)
xor    %edx,%edx
mov    %rdx,-0x80(%rsp)
mov    %rax,-0x60(%rsp)
mov    %r14,0x10(%rsp)
mov    %rbx,-0x10(%rsp)
mov    %r8,-0x70(%rsp)
mov    %rdi,-0x48(%rsp)
mov    %rbp,-0x50(%rsp)
jmp    1419 <calculate_diffusion+0x319>
nopw   0x0(%rax,%rax,1)
mov    -0x80(%rsp),%rdx
add    $0x1,%rdx
add    %r15,%r10
add    %r15,-0x60(%rsp)
mov    %rdx,%rax
mov    %rdx,-0x80(%rsp)
cmp    -0x68(%rsp),%rdx
mov    -0x10(%rsp),%rbx
je     179e <calculate_diffusion+0x69e>
mov    -0x8(%rsp),%rdx
mov    (%rdx),%rax
add    $0x1,%rax
mov    %rax,(%rdx)
mov    0x70(%rsp),%rdx
add    %rax,(%rdx)
test   %rbx,%rbx
je     150e <calculate_diffusion+0x40e>
cmp    $0x4,%rbx
jae    1450 <calculate_diffusion+0x350>
xor    %eax,%eax
jmp    1500 <calculate_diffusion+0x400>
cs nopw 0x0(%rax,%rax,1)
cmpq   $0x4,-0x30(%rsp)
jae    145c <calculate_diffusion+0x35c>
xor    %edx,%edx
jmp    14c0 <calculate_diffusion+0x3c0>
mov    -0x58(%rsp),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu (%r11,%rdx,8),%xmm1
movdqu 0x10(%r11,%rdx,8),%xmm2
movdqu 0x20(%r11,%rdx,8),%xmm3
movdqu 0x30(%r11,%rdx,8),%xmm4
psubq  %xmm0,%xmm1
psubq  %xmm0,%xmm2
movdqu %xmm1,(%r11,%rdx,8)
movdqu %xmm2,0x10(%r11,%rdx,8)
psubq  %xmm0,%xmm3
psubq  %xmm0,%xmm4
movdqu %xmm3,0x20(%r11,%rdx,8)
movdqu %xmm4,0x30(%r11,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rax
jne    1470 <calculate_diffusion+0x370>
testb  $0x1,-0x38(%rsp)
je     14e9 <calculate_diffusion+0x3e9>
movdqu (%r11,%rdx,8),%xmm1
movdqu 0x10(%r11,%rdx,8),%xmm2
psubq  %xmm0,%xmm1
psubq  %xmm0,%xmm2
movdqu %xmm1,(%r11,%rdx,8)
movdqu %xmm2,0x10(%r11,%rdx,8)
mov    -0x40(%rsp),%rdx
mov    %rdx,%rax
cmp    %rdx,%rbx
je     150e <calculate_diffusion+0x40e>
cs nopw 0x0(%rax,%rax,1)
addq   $0x1,(%r11,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbx
jne    1500 <calculate_diffusion+0x400>
test   %rcx,%rcx
jle    13f0 <calculate_diffusion+0x2f0>
cmpq   $0x3,-0x18(%rsp)
mov    -0x20(%rsp),%r9
jae    1530 <calculate_diffusion+0x430>
xor    %edx,%edx
mov    -0x70(%rsp),%r8
jmp    159e <calculate_diffusion+0x49e>
nopl   (%rax)
xor    %eax,%eax
xor    %edx,%edx
mov    -0x70(%rsp),%r8
mov    -0x48(%rsp),%rbx
mov    -0x50(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0x18(%r10,%rdx,8),%rdi
add    %rax,%rdi
movq   $0x0,(%r11,%rdi,8)
lea    (%rcx,%rax,1),%rdi
add    -0x10(%r10,%rdx,8),%rdi
movq   $0x0,(%r11,%rdi,8)
lea    (%r9,%rax,1),%rdi
add    -0x8(%r10,%rdx,8),%rdi
movq   $0x0,(%r11,%rdi,8)
lea    (%rax,%rbp,1),%rdi
add    (%r10,%rdx,8),%rdi
movq   $0x0,(%r11,%rdi,8)
add    $0x4,%rdx
add    %rbx,%rax
cmp    %rdx,%r14
jne    1550 <calculate_diffusion+0x450>
test   %r8,%r8
je     15db <calculate_diffusion+0x4db>
mov    %rcx,%rax
imul   %rdx,%rax
mov    -0x60(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rdx,%rdi,8),%rbp
add    %rax,%rbp
movq   $0x0,(%r11,%rbp,8)
add    $0x1,%rdi
add    %rcx,%rax
cmp    %rdi,%r8
jne    15c0 <calculate_diffusion+0x4c0>
test   %rcx,%rcx
jle    13f0 <calculate_diffusion+0x2f0>
mov    -0x80(%rsp),%rax
imul   %rcx,%rax
mov    -0x78(%rsp),%rdx
lea    (%rdx,%rax,8),%r9
mov    %r11,%rdx
mov    -0x28(%rsp),%r12
xor    %r13d,%r13d
jmp    1623 <calculate_diffusion+0x523>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r13
add    %r15,%r12
add    %r15,%rdx
cmp    %rcx,%r13
je     13f0 <calculate_diffusion+0x2f0>
mov    %r13,%r8
imul   %rcx,%r8
mov    (%r9,%r13,8),%rax
mov    %rax,%rdi
imul   %rcx,%rdi
cmp    $0x4,%rcx
jb     1664 <calculate_diffusion+0x564>
lea    (%r8,%rcx,1),%rbp
lea    (%r11,%rbp,8),%rbp
lea    (%rsi,%rdi,8),%rbx
cmp    %rbp,%rbx
jae    16c0 <calculate_diffusion+0x5c0>
lea    (%r11,%r8,8),%rbx
lea    0x8(,%rax,8),%rax
imul   %rcx,%rax
add    %rsi,%rax
cmp    %rbx,%rax
jbe    16c0 <calculate_diffusion+0x5c0>
xor    %ebp,%ebp
mov    %rbp,%rax
test   $0x1,%cl
je     1684 <calculate_diffusion+0x584>
add    %rbp,%r8
mov    (%r11,%r8,8),%rax
lea    (%rdi,%rbp,1),%rbx
add    %rax,(%rsi,%rbx,8)
mov    %rbp,%rax
or     $0x1,%rax
not    %rbp
cmp    0x30(%rsp),%rbp
je     1610 <calculate_diffusion+0x510>
mov    0x28(%rsp),%rbp
lea    0x0(,%rdi,8),%rdi
add    %rbp,%rdi
xchg   %ax,%ax
mov    (%rdx,%rax,8),%rbp
add    %rbp,-0x8(%rdi,%rax,8)
mov    0x8(%rdx,%rax,8),%rbp
add    %rbp,(%rdi,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    16a0 <calculate_diffusion+0x5a0>
jmp    1610 <calculate_diffusion+0x510>
cmpq   $0x4,0x20(%rsp)
jae    16cd <calculate_diffusion+0x5cd>
xor    %r14d,%r14d
jmp    174b <calculate_diffusion+0x64b>
mov    (%rsp),%rax
lea    (%rax,%rdi,8),%rax
mov    0x8(%rsp),%rbp
xor    %r14d,%r14d
nopl   (%rax)
movdqu -0x30(%r12,%r14,8),%xmm1
movdqu -0x20(%r12,%r14,8),%xmm2
movdqu -0x30(%rax,%r14,8),%xmm3
paddq  %xmm1,%xmm3
movdqu -0x20(%rax,%r14,8),%xmm1
paddq  %xmm2,%xmm1
movdqu -0x10(%rax,%r14,8),%xmm2
movdqu (%rax,%r14,8),%xmm4
movdqu %xmm3,-0x30(%rax,%r14,8)
movdqu %xmm1,-0x20(%rax,%r14,8)
movdqu -0x10(%r12,%r14,8),%xmm1
paddq  %xmm2,%xmm1
movdqu (%r12,%r14,8),%xmm2
paddq  %xmm4,%xmm2
movdqu %xmm1,-0x10(%rax,%r14,8)
movdqu %xmm2,(%rax,%r14,8)
add    $0x8,%r14
add    $0xfffffffffffffffe,%rbp
jne    16e0 <calculate_diffusion+0x5e0>
testb  $0x1,0x18(%rsp)
je     1788 <calculate_diffusion+0x688>
lea    (%r14,%r8,1),%rax
movdqu (%r11,%rax,8),%xmm1
movdqu 0x10(%r11,%rax,8),%xmm2
add    %rdi,%r14
movdqu (%rsi,%r14,8),%xmm3
paddq  %xmm1,%xmm3
movdqu 0x10(%rsi,%r14,8),%xmm1
paddq  %xmm2,%xmm1
movdqu %xmm3,(%rsi,%r14,8)
movdqu %xmm1,0x10(%rsi,%r14,8)
mov    0x10(%rsp),%r14
mov    %r14,%rbp
cmp    %rcx,%r14
je     1610 <calculate_diffusion+0x510>
jmp    1666 <calculate_diffusion+0x566>
xor    %eax,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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