#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int salt();
void diamond_step(int **map, int width, int height, int x, int y, int length) {
  if (y - length == 0) {
    map[y - length][x] = (map[y][x] + map[y - length][x - length] +
                          map[y - length][x + length]) /
                             3 +
                         salt();
  }
  if (y + length == width - 1) {
    map[y + length][x] = (map[y][x] + map[y + length][x - length] +
                          map[y + length][x + length]) /
                             3 +
                         salt();
  } else {
    map[y + length][x] =
        (map[y][x] + map[y + length][x - length] + map[y + length][x + length] +
         map[y + 2 * length][x]) /
            4 +
        salt();
  }
  if (x - length == 0) {
    map[y][x - length] = (map[y][x] + map[y - length][x - length] +
                          map[y + length][x - length]) /
                             3 +
                         salt();
  }
  if (x + length == height - 1) {
    map[y][x + length] = (map[y][x] + map[y - length][x + length] +
                          map[y + length][x + length]) /
                             3 +
                         salt();
  } else {
    map[y][x + length] =
        (map[y][x] + map[y - length][x - length] + map[y + length][x + length] +
         map[y][x + 2 * length]) /
            4 +
        salt();
  }
}


x86 assembly (clang, -O0):
<diamond_step>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9d,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
sub    -0x1c(%rbp),%eax
cmp    $0x0,%eax
jne    11b8 <diamond_step+0xa8>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
sub    -0x1c(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x14(%rbp),%edx
sub    -0x1c(%rbp),%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
sub    -0x1c(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x14(%rbp),%edx
add    -0x1c(%rbp),%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x20(%rbp)
mov    $0x0,%al
call   1030 <salt@plt>
mov    -0x20(%rbp),%edx
add    %eax,%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    124d <diamond_step+0x13d>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
add    -0x1c(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x14(%rbp),%edx
sub    -0x1c(%rbp),%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
add    -0x1c(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x14(%rbp),%edx
add    -0x1c(%rbp),%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x24(%rbp)
mov    $0x0,%al
call   1030 <salt@plt>
mov    -0x24(%rbp),%edx
add    %eax,%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    12e6 <diamond_step+0x1d6>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
add    -0x1c(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x14(%rbp),%edx
sub    -0x1c(%rbp),%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
add    -0x1c(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x14(%rbp),%edx
add    -0x1c(%rbp),%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
mov    -0x1c(%rbp),%esi
shl    $0x1,%esi
add    %esi,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x14(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,-0x28(%rbp)
mov    $0x0,%al
call   1030 <salt@plt>
mov    -0x28(%rbp),%edx
add    %eax,%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
sub    -0x1c(%rbp),%eax
cmp    $0x0,%eax
jne    1371 <diamond_step+0x261>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
sub    -0x1c(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x14(%rbp),%edx
sub    -0x1c(%rbp),%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
add    -0x1c(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x14(%rbp),%edx
sub    -0x1c(%rbp),%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x2c(%rbp)
mov    $0x0,%al
call   1030 <salt@plt>
mov    -0x2c(%rbp),%edx
add    %eax,%edx
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1406 <diamond_step+0x2f6>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
sub    -0x1c(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x14(%rbp),%edx
add    -0x1c(%rbp),%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
add    -0x1c(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x14(%rbp),%edx
add    -0x1c(%rbp),%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x30(%rbp)
mov    $0x0,%al
call   1030 <salt@plt>
mov    -0x30(%rbp),%edx
add    %eax,%edx
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    149f <diamond_step+0x38f>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
sub    -0x1c(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x14(%rbp),%edx
sub    -0x1c(%rbp),%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
add    -0x1c(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x14(%rbp),%edx
add    -0x1c(%rbp),%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    -0x8(%rbp),%rcx
movslq -0x18(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x14(%rbp),%edx
mov    -0x1c(%rbp),%esi
shl    $0x1,%esi
add    %esi,%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,-0x34(%rbp)
mov    $0x0,%al
call   1030 <salt@plt>
mov    -0x34(%rbp),%edx
add    %eax,%edx
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<diamond_step>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %r8d,%r15d
mov    %edx,0x14(%rsp)
mov    %esi,%r13d
mov    %rdi,%r12
mov    %r8d,%eax
movslq %r8d,%rbx
movslq %ecx,%r8
sub    %r9d,%eax
mov    %eax,0x4(%rsp)
mov    %r9,0x20(%rsp)
mov    %rcx,0x18(%rsp)
jne    11a0 <diamond_step+0x90>
mov    (%r12,%rbx,8),%rax
mov    (%r12),%rsi
mov    %r8d,%edx
sub    %r9d,%edx
movslq %edx,%rdx
mov    (%rsi,%rdx,4),%edx
add    (%rax,%r8,4),%edx
lea    (%r9,%rcx,1),%eax
cltq
add    (%rsi,%rax,4),%edx
movslq %edx,%rax
imul   $0x55555556,%rax,%rbp
mov    %rbp,%rax
shr    $0x3f,%rax
shr    $0x20,%rbp
add    %eax,%ebp
xor    %eax,%eax
mov    %r8,%r14
call   1030 <salt@plt>
mov    %r14,%r8
mov    0x18(%rsp),%rcx
add    %ebp,%eax
mov    0x20(%rsp),%r9
mov    (%r12),%rdx
mov    %eax,(%rdx,%r14,4)
lea    (%r9,%r15,1),%eax
add    $0xffffffff,%r13d
mov    %rbx,0x30(%rsp)
mov    (%r12,%rbx,8),%rsi
movslq %eax,%rbx
mov    (%r12,%rbx,8),%rdx
mov    %r8d,%r14d
sub    %r9d,%r14d
movslq %r14d,%rbp
mov    (%rdx,%rbp,4),%eax
add    (%rsi,%r8,4),%eax
lea    (%r9,%rcx,1),%edi
movslq %edi,%rsi
mov    %rsi,0x8(%rsp)
add    (%rdx,%rsi,4),%eax
cmp    %r13d,%ebx
mov    %rbp,0x28(%rsp)
mov    %edi,0x10(%rsp)
jne    11fd <diamond_step+0xed>
cltq
imul   $0x55555556,%rax,%rbp
mov    %rbp,%rax
shr    $0x3f,%rax
shr    $0x20,%rbp
add    %eax,%ebp
jmp    121a <diamond_step+0x10a>
lea    (%r15,%r9,2),%ecx
movslq %ecx,%rcx
mov    (%r12,%rcx,8),%rcx
mov    (%rcx,%r8,4),%ecx
mov    %eax,%edx
add    %ecx,%edx
lea    0x3(%rax,%rcx,1),%ebp
cmovns %edx,%ebp
sar    $0x2,%ebp
mov    %r8,%r13
mov    0x4(%rsp),%r15d
xor    %eax,%eax
call   1030 <salt@plt>
add    %ebp,%eax
mov    (%r12,%rbx,8),%rcx
mov    %eax,(%rcx,%r13,4)
movslq %r15d,%r15
test   %r14d,%r14d
mov    0x30(%rsp),%r14
jne    1276 <diamond_step+0x166>
mov    (%r12,%r14,8),%rax
mov    (%r12,%r15,8),%rdx
mov    (%rdx),%edx
add    (%rax,%r13,4),%edx
add    (%rcx),%edx
movslq %edx,%rax
imul   $0x55555556,%rax,%rbp
mov    %rbp,%rax
shr    $0x3f,%rax
shr    $0x20,%rbp
add    %eax,%ebp
xor    %eax,%eax
call   1030 <salt@plt>
add    %ebp,%eax
mov    (%r12,%r14,8),%rcx
mov    %eax,(%rcx)
mov    0x14(%rsp),%esi
add    $0xffffffff,%esi
mov    (%r12,%r14,8),%rcx
mov    (%rcx,%r13,4),%eax
mov    (%r12,%r15,8),%rdx
mov    0x10(%rsp),%edi
cmp    %esi,%edi
jne    12af <diamond_step+0x19f>
movslq %edi,%rcx
add    (%rdx,%rcx,4),%eax
mov    %rcx,0x8(%rsp)
lea    0x0(,%rcx,4),%rcx
add    (%r12,%rbx,8),%rcx
mov    $0x3,%esi
jmp    12dc <diamond_step+0x1cc>
mov    0x28(%rsp),%rsi
add    (%rdx,%rsi,4),%eax
mov    (%r12,%rbx,8),%rdx
mov    0x8(%rsp),%rsi
add    (%rdx,%rsi,4),%eax
mov    0x18(%rsp),%rdx
mov    0x20(%rsp),%rsi
lea    (%rdx,%rsi,2),%edx
movslq %edx,%rdx
lea    (%rcx,%rdx,4),%rcx
mov    $0x4,%esi
add    (%rcx),%eax
cltd
idiv   %esi
mov    %eax,%ebp
xor    %eax,%eax
call   1030 <salt@plt>
add    %ebp,%eax
mov    (%r12,%r14,8),%rcx
mov    0x8(%rsp),%rdx
mov    %eax,(%rcx,%rdx,4)
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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