void diamond(int **map, int width, int height, int x, int y, int length,
             float roughness) {
  int salt;
  if (y - length == 0) {
    salt = rand() % length;
    if (should_add()) {
      map[y - length][x] = average(3, map[y][x], map[y - length][x - length],
                                   map[y - length][x + length]) +
                           (salt * roughness);
    } else {
      map[y - length][x] = average(3, map[y][x], map[y - length][x - length],
                                   map[y - length][x + length]) -
                           (salt * roughness);
    }
  }
  if (y + length == height - 1) {
    salt = rand() % length;
    if (should_add()) {
      map[y + length][x] = average(3, map[y][x], map[y + length][x - length],
                                   map[y + length][x + length]) +
                           (salt * roughness);
    } else {
      map[y + length][x] = average(3, map[y][x], map[y + length][x - length],
                                   map[y + length][x + length]) -
                           (salt * roughness);
    }
  } else {
    salt = rand() % length;
    if (should_add()) {
      map[y + length][x] =
          average(4, map[y][x], map[y + length][x - length],
                  map[y + length][x + length], map[y + 2 * length][x]) +
          (salt * roughness);
    } else {
      map[y + length][x] =
          average(4, map[y][x], map[y + length][x - length],
                  map[y + length][x + length], map[y + 2 * length][x]) -
          (salt * roughness);
    }
  }
  if (x - length == 0) {
    salt = rand() % length;
    if (should_add()) {
      map[y][x - length] = average(3, map[y][x], map[y - length][x - length],
                                   map[y + length][x - length]) +
                           (salt * roughness);
    } else {
      map[y][x - length] = average(3, map[y][x], map[y - length][x - length],
                                   map[y + length][x - length]) -
                           (salt * roughness);
    }
  }
  if (x + length == width - 1) {
    salt = rand() % length;
    if (should_add()) {
      map[y][x + length] = average(3, map[y][x], map[y - length][x + length],
                                   map[y + length][x + length]) +
                           (salt * roughness);
    } else {
      map[y][x + length] = average(3, map[y][x], map[y - length][x + length],
                                   map[y + length][x + length]) -
                           (salt * roughness);
    }
  } else {
    salt = rand() % length;
    if (should_add()) {
      map[y][x + length] =
          average(4, map[y][x], map[y - length][x - length],
                  map[y + length][x + length], map[y][x + 2 * length]) +
          (salt * roughness);
    } else {
      map[y][x + length] =
          average(4, map[y][x], map[y - length][x - length],
                  map[y + length][x + length], map[y][x + 2 * length]) -
          (salt * roughness);
    }
  }
}


x86 assembly (clang, -O0):
<diamond>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%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)
movss  %xmm0,-0x20(%rbp)
mov    -0x18(%rbp),%eax
sub    -0x1c(%rbp),%eax
cmp    $0x0,%eax
jne    12ac <diamond+0x17c>
mov    $0x0,%al
call   1050 <rand@plt>
cltd
idivl  -0x1c(%rbp)
mov    %edx,-0x24(%rbp)
mov    $0x0,%al
call   1030 <should_add@plt>
cmp    $0x0,%eax
je     120f <diamond+0xdf>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    $0x3,%edi
mov    $0x0,%al
call   1040 <average@plt>
cvtsi2ss %eax,%xmm1
cvtsi2ssl -0x24(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%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)
jmp    12a7 <diamond+0x177>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    $0x3,%edi
mov    $0x0,%al
call   1040 <average@plt>
cvtsi2ss %eax,%xmm1
cvtsi2ssl -0x24(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%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)
jmp    12ac <diamond+0x17c>
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    140b <diamond+0x2db>
mov    $0x0,%al
call   1050 <rand@plt>
cltd
idivl  -0x1c(%rbp)
mov    %edx,-0x24(%rbp)
mov    $0x0,%al
call   1030 <should_add@plt>
cmp    $0x0,%eax
je     136e <diamond+0x23e>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    $0x3,%edi
mov    $0x0,%al
call   1040 <average@plt>
cvtsi2ss %eax,%xmm1
cvtsi2ssl -0x24(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%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    1406 <diamond+0x2d6>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    $0x3,%edi
mov    $0x0,%al
call   1040 <average@plt>
cvtsi2ss %eax,%xmm1
cvtsi2ssl -0x24(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%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    1598 <diamond+0x468>
mov    $0x0,%al
call   1050 <rand@plt>
cltd
idivl  -0x1c(%rbp)
mov    %edx,-0x24(%rbp)
mov    $0x0,%al
call   1030 <should_add@plt>
cmp    $0x0,%eax
je     14da <diamond+0x3aa>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%edi
mov    -0x1c(%rbp),%r8d
shl    $0x1,%r8d
add    %r8d,%edi
movslq %edi,%rdi
mov    (%rax,%rdi,8),%rax
movslq -0x14(%rbp),%rdi
mov    (%rax,%rdi,4),%r8d
mov    $0x4,%edi
mov    $0x0,%al
call   1040 <average@plt>
cvtsi2ss %eax,%xmm1
cvtsi2ssl -0x24(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%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    1593 <diamond+0x463>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%edi
mov    -0x1c(%rbp),%r8d
shl    $0x1,%r8d
add    %r8d,%edi
movslq %edi,%rdi
mov    (%rax,%rdi,8),%rax
movslq -0x14(%rbp),%rdi
mov    (%rax,%rdi,4),%r8d
mov    $0x4,%edi
mov    $0x0,%al
call   1040 <average@plt>
cvtsi2ss %eax,%xmm1
cvtsi2ssl -0x24(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%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    1598 <diamond+0x468>
mov    -0x14(%rbp),%eax
sub    -0x1c(%rbp),%eax
cmp    $0x0,%eax
jne    16f2 <diamond+0x5c2>
mov    $0x0,%al
call   1050 <rand@plt>
cltd
idivl  -0x1c(%rbp)
mov    %edx,-0x24(%rbp)
mov    $0x0,%al
call   1030 <should_add@plt>
cmp    $0x0,%eax
je     1655 <diamond+0x525>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    $0x3,%edi
mov    $0x0,%al
call   1040 <average@plt>
cvtsi2ss %eax,%xmm1
cvtsi2ssl -0x24(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%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)
jmp    16ed <diamond+0x5bd>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    $0x3,%edi
mov    $0x0,%al
call   1040 <average@plt>
cvtsi2ss %eax,%xmm1
cvtsi2ssl -0x24(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%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)
jmp    16f2 <diamond+0x5c2>
mov    -0x14(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1851 <diamond+0x721>
mov    $0x0,%al
call   1050 <rand@plt>
cltd
idivl  -0x1c(%rbp)
mov    %edx,-0x24(%rbp)
mov    $0x0,%al
call   1030 <should_add@plt>
cmp    $0x0,%eax
je     17b4 <diamond+0x684>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    $0x3,%edi
mov    $0x0,%al
call   1040 <average@plt>
cvtsi2ss %eax,%xmm1
cvtsi2ssl -0x24(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%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    184c <diamond+0x71c>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    $0x3,%edi
mov    $0x0,%al
call   1040 <average@plt>
cvtsi2ss %eax,%xmm1
cvtsi2ssl -0x24(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%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    19de <diamond+0x8ae>
mov    $0x0,%al
call   1050 <rand@plt>
cltd
idivl  -0x1c(%rbp)
mov    %edx,-0x24(%rbp)
mov    $0x0,%al
call   1030 <should_add@plt>
cmp    $0x0,%eax
je     1920 <diamond+0x7f0>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rdi
mov    (%rax,%rdi,8),%rax
mov    -0x14(%rbp),%edi
mov    -0x1c(%rbp),%r8d
shl    $0x1,%r8d
add    %r8d,%edi
movslq %edi,%rdi
mov    (%rax,%rdi,4),%r8d
mov    $0x4,%edi
mov    $0x0,%al
call   1040 <average@plt>
cvtsi2ss %eax,%xmm1
cvtsi2ssl -0x24(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%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    19d9 <diamond+0x8a9>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rdi
mov    (%rax,%rdi,8),%rax
mov    -0x14(%rbp),%edi
mov    -0x1c(%rbp),%r8d
shl    $0x1,%r8d
add    %r8d,%edi
movslq %edi,%rdi
mov    (%rax,%rdi,4),%r8d
mov    $0x4,%edi
mov    $0x0,%al
call   1040 <average@plt>
cvtsi2ss %eax,%xmm1
cvtsi2ssl -0x24(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%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    19de <diamond+0x8ae>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<diamond>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
movss  %xmm0,(%rsp)
mov    %r9d,%r13d
mov    %ecx,%r14d
mov    %esi,0x4(%rsp)
mov    %rdi,%rbx
mov    %r8d,%eax
movslq %r8d,%r12
movslq %ecx,%rbp
sub    %r9d,%eax
mov    %eax,0x3c(%rsp)
mov    %r8,0x40(%rsp)
jne    11fc <diamond+0xcc>
mov    %edx,0x8(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
cltd
idiv   %r13d
mov    %edx,0x14(%rsp)
xor    %eax,%eax
call   1030 <should_add@plt>
mov    %eax,%r15d
mov    (%rbx,%r12,8),%rax
mov    (%rax,%rbp,4),%esi
mov    (%rbx),%rax
mov    %rbp,0x30(%rsp)
mov    %ebp,%ecx
sub    %r13d,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    %r13,0x18(%rsp)
lea    (%r14,%r13,1),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    $0x3,%edi
xor    %eax,%eax
call   1040 <average@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
cvtsi2ssl 0x14(%rsp),%xmm1
test   %r15d,%r15d
jne    11d6 <diamond+0xa6>
xorps  0xe2a(%rip),%xmm1
mulss  (%rsp),%xmm1
addss  %xmm0,%xmm1
cvttss2si %xmm1,%eax
mov    (%rbx),%rcx
mov    0x30(%rsp),%rbp
mov    %eax,(%rcx,%rbp,4)
mov    0x18(%rsp),%r13
mov    0x40(%rsp),%r8
mov    0x8(%rsp),%edx
lea    (%r8,%r13,1),%r15d
add    $0xffffffff,%edx
mov    %edx,0x8(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
cltd
idiv   %r13d
mov    %edx,0x28(%rsp)
xor    %eax,%eax
call   1030 <should_add@plt>
mov    %eax,0x24(%rsp)
mov    %ebp,%edx
sub    %r13d,%edx
mov    %r14,0x50(%rsp)
lea    (%r14,%r13,1),%ecx
mov    %r12,0x18(%rsp)
mov    (%rbx,%r12,8),%rax
mov    (%rax,%rbp,4),%esi
movslq %r15d,%r12
mov    (%rbx,%r12,8),%rax
mov    %edx,0x14(%rsp)
movslq %edx,%rdx
mov    %rdx,0x48(%rsp)
mov    (%rax,%rdx,4),%edx
mov    %ecx,0x30(%rsp)
movslq %ecx,%r14
mov    (%rax,%r14,4),%ecx
cmp    0x8(%rsp),%r15d
jne    1294 <diamond+0x164>
mov    %r13,%r15
mov    $0x3,%edi
xor    %eax,%eax
call   1040 <average@plt>
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
xorps  %xmm0,%xmm0
cvtsi2ssl 0x28(%rsp),%xmm0
cmpl   $0x0,0x24(%rsp)
je     12cd <diamond+0x19d>
mulss  (%rsp),%xmm0
addss  %xmm1,%xmm0
jmp    12d9 <diamond+0x1a9>
mov    0x40(%rsp),%rax
lea    (%rax,%r13,2),%eax
cltq
mov    (%rbx,%rax,8),%rax
mov    (%rax,%rbp,4),%r8d
mov    $0x4,%edi
xor    %eax,%eax
call   1040 <average@plt>
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
xorps  %xmm0,%xmm0
cvtsi2ssl 0x28(%rsp),%xmm0
cmpl   $0x0,0x24(%rsp)
mov    %r13,%r15
jne    1289 <diamond+0x159>
mulss  (%rsp),%xmm0
subss  %xmm0,%xmm1
movaps %xmm1,%xmm0
mov    %r14,0x28(%rsp)
cvttss2si %xmm0,%eax
mov    %r12,0x8(%rsp)
mov    (%rbx,%r12,8),%rcx
mov    %eax,(%rcx,%rbp,4)
movslq 0x3c(%rsp),%r13
cmpl   $0x0,0x14(%rsp)
jne    1374 <diamond+0x244>
xor    %eax,%eax
call   1050 <rand@plt>
cltd
mov    %r15,%r14
idiv   %r15d
mov    %edx,%r15d
xor    %eax,%eax
call   1030 <should_add@plt>
mov    %eax,%r12d
mov    0x18(%rsp),%rax
mov    (%rbx,%rax,8),%rax
mov    (%rax,%rbp,4),%esi
mov    (%rbx,%r13,8),%rax
mov    (%rax),%edx
mov    0x8(%rsp),%rax
mov    (%rbx,%rax,8),%rax
mov    (%rax),%ecx
mov    $0x3,%edi
xor    %eax,%eax
call   1040 <average@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
xorps  %xmm1,%xmm1
cvtsi2ss %r15d,%xmm1
test   %r12d,%r12d
jne    1359 <diamond+0x229>
xorps  0xca7(%rip),%xmm1
mulss  (%rsp),%xmm1
addss  %xmm0,%xmm1
cvttss2si %xmm1,%eax
mov    0x18(%rsp),%rcx
mov    (%rbx,%rcx,8),%rcx
mov    %eax,(%rcx)
mov    %r14,%r15
mov    0x4(%rsp),%r12d
add    $0xffffffff,%r12d
xor    %eax,%eax
call   1050 <rand@plt>
cltd
idiv   %r15d
mov    %edx,0x4(%rsp)
xor    %eax,%eax
call   1030 <should_add@plt>
mov    %eax,%r14d
mov    0x18(%rsp),%rax
mov    (%rbx,%rax,8),%rax
mov    (%rax,%rbp,4),%esi
mov    (%rbx,%r13,8),%rcx
mov    0x30(%rsp),%edx
cmp    %r12d,%edx
jne    13cf <diamond+0x29f>
movslq %edx,%rbp
mov    (%rcx,%rbp,4),%edx
mov    0x8(%rsp),%rax
mov    (%rbx,%rax,8),%rax
mov    (%rax,%rbp,4),%ecx
mov    $0x3,%edi
xor    %eax,%eax
call   1040 <average@plt>
jmp    1404 <diamond+0x2d4>
mov    0x48(%rsp),%rdx
mov    (%rcx,%rdx,4),%edx
mov    0x8(%rsp),%rcx
mov    (%rbx,%rcx,8),%rcx
mov    0x28(%rsp),%rbp
mov    (%rcx,%rbp,4),%ecx
mov    0x50(%rsp),%rdi
lea    (%rdi,%r15,2),%edi
movslq %edi,%rdi
mov    (%rax,%rdi,4),%r8d
mov    $0x4,%edi
xor    %eax,%eax
call   1040 <average@plt>
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
xorps  %xmm0,%xmm0
cvtsi2ssl 0x4(%rsp),%xmm0
test   %r14d,%r14d
je     1424 <diamond+0x2f4>
mulss  (%rsp),%xmm0
addss  %xmm1,%xmm0
jmp    1430 <diamond+0x300>
mulss  (%rsp),%xmm0
subss  %xmm0,%xmm1
movaps %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    0x18(%rsp),%rcx
mov    (%rbx,%rcx,8),%rcx
mov    %eax,(%rcx,%rbp,4)
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @diamond(i32** %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5, float %6) {
%8 = alloca i32**
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca float
%15 = alloca i32
store i32** %0, i32*** %8
store i32 %1, i32* %9
store i32 %2, i32* %10
store i32 %3, i32* %11
store i32 %4, i32* %12
store i32 %5, i32* %13
store float %6, float* %14
%16 = load i32, i32* %12
%17 = load i32, i32* %13
%18 = sub nsw i32 %16, %17
%19 = icmp eq i32 %18, 0
br i1 %19, label %20, label %134
20: ; preds = %7
%21 = call i32 (...) @rand()
%22 = load i32, i32* %13
%23 = srem i32 %21, %22
store i32 %23, i32* %15
%24 = call i32 (...) @should_add()
%25 = icmp ne i32 %24, 0
br i1 %25, label %26, label %79
26: ; preds = %20
%27 = load i32**, i32*** %8
%28 = load i32, i32* %12
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds i32*, i32** %27, i64 %29
%31 = load i32*, i32** %30
%32 = load i32, i32* %11
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds i32, i32* %31, i64 %33
%35 = load i32, i32* %34
%36 = load i32**, i32*** %8
%37 = load i32, i32* %12
%38 = load i32, i32* %13
%39 = sub nsw i32 %37, %38
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds i32*, i32** %36, i64 %40
%42 = load i32*, i32** %41
%43 = load i32, i32* %11
%44 = load i32, i32* %13
%45 = sub nsw i32 %43, %44
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds i32, i32* %42, i64 %46
%48 = load i32, i32* %47
%49 = load i32**, i32*** %8
%50 = load i32, i32* %12
%51 = load i32, i32* %13
%52 = sub nsw i32 %50, %51
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i32*, i32** %49, i64 %53
%55 = load i32*, i32** %54
%56 = load i32, i32* %11
%57 = load i32, i32* %13
%58 = add nsw i32 %56, %57
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds i32, i32* %55, i64 %59
%61 = load i32, i32* %60
%62 = call i32 (i32, i32, i32, i32, ...) bitcast (i32 (...)* @average to i32 (i32, i32, i32, i32, ...)*)(i32 3, i32 %35, i32 %48, i32 %61)
%63 = sitofp i32 %62 to float
%64 = load i32, i32* %15
%65 = sitofp i32 %64 to float
%66 = load float, float* %14
%67 = call float @llvm.fmuladd.f32(float %65, float %66, float %63)
%68 = fptosi float %67 to i32
%69 = load i32**, i32*** %8
%70 = load i32, i32* %12
%71 = load i32, i32* %13
%72 = sub nsw i32 %70, %71
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds i32*, i32** %69, i64 %73
%75 = load i32*, i32** %74
%76 = load i32, i32* %11
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds i32, i32* %75, i64 %77
store i32 %68, i32* %78
br label %133
79: ; preds = %20
%80 = load i32**, i32*** %8
%81 = load i32, i32* %12
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds i32*, i32** %80, i64 %82
%84 = load i32*, i32** %83
%85 = load i32, i32* %11
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds i32, i32* %84, i64 %86
%88 = load i32, i32* %87
%89 = load i32**, i32*** %8
%90 = load i32, i32* %12
%91 = load i32, i32* %13
%92 = sub nsw i32 %90, %91
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds i32*, i32** %89, i64 %93
%95 = load i32*, i32** %94
%96 = load i32, i32* %11
%97 = load i32, i32* %13
%98 = sub nsw i32 %96, %97
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds i32, i32* %95, i64 %99
%101 = load i32, i32* %100
%102 = load i32**, i32*** %8
%103 = load i32, i32* %12
%104 = load i32, i32* %13
%105 = sub nsw i32 %103, %104
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds i32*, i32** %102, i64 %106
%108 = load i32*, i32** %107
%109 = load i32, i32* %11
%110 = load i32, i32* %13
%111 = add nsw i32 %109, %110
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds i32, i32* %108, i64 %112
%114 = load i32, i32* %113
%115 = call i32 (i32, i32, i32, i32, ...) bitcast (i32 (...)* @average to i32 (i32, i32, i32, i32, ...)*)(i32 3, i32 %88, i32 %101, i32 %114)
%116 = sitofp i32 %115 to float
%117 = load i32, i32* %15
%118 = sitofp i32 %117 to float
%119 = load float, float* %14
%120 = fneg float %118
%121 = call float @llvm.fmuladd.f32(float %120, float %119, float %116)
%122 = fptosi float %121 to i32
%123 = load i32**, i32*** %8
%124 = load i32, i32* %12
%125 = load i32, i32* %13
%126 = sub nsw i32 %124, %125
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds i32*, i32** %123, i64 %127
%129 = load i32*, i32** %128
%130 = load i32, i32* %11
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds i32, i32* %129, i64 %131
store i32 %122, i32* %132
br label %133
133: ; preds = %79, %26
br label %134
134: ; preds = %133, %7
%135 = load i32, i32* %12
%136 = load i32, i32* %13
%137 = add nsw i32 %135, %136
%138 = load i32, i32* %10
%139 = sub nsw i32 %138, 1
%140 = icmp eq i32 %137, %139
br i1 %140, label %141, label %255
141: ; preds = %134
%142 = call i32 (...) @rand()
%143 = load i32, i32* %13
%144 = srem i32 %142, %143
store i32 %144, i32* %15
%145 = call i32 (...) @should_add()
%146 = icmp ne i32 %145, 0
br i1 %146, label %147, label %200
147: ; preds = %141
%148 = load i32**, i32*** %8
%149 = load i32, i32* %12
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds i32*, i32** %148, i64 %150
%152 = load i32*, i32** %151
%153 = load i32, i32* %11
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds i32, i32* %152, i64 %154
%156 = load i32, i32* %155
%157 = load i32**, i32*** %8
%158 = load i32, i32* %12
%159 = load i32, i32* %13
%160 = add nsw i32 %158, %159
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds i32*, i32** %157, i64 %161
%163 = load i32*, i32** %162
%164 = load i32, i32* %11
%165 = load i32, i32* %13
%166 = sub nsw i32 %164, %165
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds i32, i32* %163, i64 %167
%169 = load i32, i32* %168
%170 = load i32**, i32*** %8
%171 = load i32, i32* %12
%172 = load i32, i32* %13
%173 = add nsw i32 %171, %172
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds i32*, i32** %170, i64 %174
%176 = load i32*, i32** %175
%177 = load i32, i32* %11
%178 = load i32, i32* %13
%179 = add nsw i32 %177, %178
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds i32, i32* %176, i64 %180
%182 = load i32, i32* %181
%183 = call i32 (i32, i32, i32, i32, ...) bitcast (i32 (...)* @average to i32 (i32, i32, i32, i32, ...)*)(i32 3, i32 %156, i32 %169, i32 %182)
%184 = sitofp i32 %183 to float
%185 = load i32, i32* %15
%186 = sitofp i32 %185 to float
%187 = load float, float* %14
%188 = call float @llvm.fmuladd.f32(float %186, float %187, float %184)
%189 = fptosi float %188 to i32
%190 = load i32**, i32*** %8
%191 = load i32, i32* %12
%192 = load i32, i32* %13
%193 = add nsw i32 %191, %192
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds i32*, i32** %190, i64 %194
%196 = load i32*, i32** %195
%197 = load i32, i32* %11
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds i32, i32* %196, i64 %198
store i32 %189, i32* %199
br label %254
200: ; preds = %141
%201 = load i32**, i32*** %8
%202 = load i32, i32* %12
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds i32*, i32** %201, i64 %203
%205 = load i32*, i32** %204
%206 = load i32, i32* %11
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds i32, i32* %205, i64 %207
%209 = load i32, i32* %208
%210 = load i32**, i32*** %8
%211 = load i32, i32* %12
%212 = load i32, i32* %13
%213 = add nsw i32 %211, %212
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds i32*, i32** %210, i64 %214
%216 = load i32*, i32** %215
%217 = load i32, i32* %11
%218 = load i32, i32* %13
%219 = sub nsw i32 %217, %218
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds i32, i32* %216, i64 %220
%222 = load i32, i32* %221
%223 = load i32**, i32*** %8
%224 = load i32, i32* %12
%225 = load i32, i32* %13
%226 = add nsw i32 %224, %225
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds i32*, i32** %223, i64 %227
%229 = load i32*, i32** %228
%230 = load i32, i32* %11
%231 = load i32, i32* %13
%232 = add nsw i32 %230, %231
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds i32, i32* %229, i64 %233
%235 = load i32, i32* %234
%236 = call i32 (i32, i32, i32, i32, ...) bitcast (i32 (...)* @average to i32 (i32, i32, i32, i32, ...)*)(i32 3, i32 %209, i32 %222, i32 %235)
%237 = sitofp i32 %236 to float
%238 = load i32, i32* %15
%239 = sitofp i32 %238 to float
%240 = load float, float* %14
%241 = fneg float %239
%242 = call float @llvm.fmuladd.f32(float %241, float %240, float %237)
%243 = fptosi float %242 to i32
%244 = load i32**, i32*** %8
%245 = load i32, i32* %12
%246 = load i32, i32* %13
%247 = add nsw i32 %245, %246
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds i32*, i32** %244, i64 %248
%250 = load i32*, i32** %249
%251 = load i32, i32* %11
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds i32, i32* %250, i64 %252
store i32 %243, i32* %253
br label %254
254: ; preds = %200, %147
br label %393
255: ; preds = %134
%256 = call i32 (...) @rand()
%257 = load i32, i32* %13
%258 = srem i32 %256, %257
store i32 %258, i32* %15
%259 = call i32 (...) @should_add()
%260 = icmp ne i32 %259, 0
br i1 %260, label %261, label %326
261: ; preds = %255
%262 = load i32**, i32*** %8
%263 = load i32, i32* %12
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds i32*, i32** %262, i64 %264
%266 = load i32*, i32** %265
%267 = load i32, i32* %11
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds i32, i32* %266, i64 %268
%270 = load i32, i32* %269
%271 = load i32**, i32*** %8
%272 = load i32, i32* %12
%273 = load i32, i32* %13
%274 = add nsw i32 %272, %273
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds i32*, i32** %271, i64 %275
%277 = load i32*, i32** %276
%278 = load i32, i32* %11
%279 = load i32, i32* %13
%280 = sub 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*** %8
%285 = load i32, i32* %12
%286 = load i32, i32* %13
%287 = add nsw i32 %285, %286
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds i32*, i32** %284, i64 %288
%290 = load i32*, i32** %289
%291 = load i32, i32* %11
%292 = load i32, i32* %13
%293 = add nsw i32 %291, %292
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds i32, i32* %290, i64 %294
%296 = load i32, i32* %295
%297 = load i32**, i32*** %8
%298 = load i32, i32* %12
%299 = load i32, i32* %13
%300 = mul nsw i32 2, %299
%301 = add nsw i32 %298, %300
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds i32*, i32** %297, i64 %302
%304 = load i32*, i32** %303
%305 = load i32, i32* %11
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds i32, i32* %304, i64 %306
%308 = load i32, i32* %307
%309 = call i32 (i32, i32, i32, i32, i32, ...) bitcast (i32 (...)* @average to i32 (i32, i32, i32, i32, i32, ...)*)(i32 4, i32 %270, i32 %283, i32 %296, i32 %308)
%310 = sitofp i32 %309 to float
%311 = load i32, i32* %15
%312 = sitofp i32 %311 to float
%313 = load float, float* %14
%314 = call float @llvm.fmuladd.f32(float %312, float %313, float %310)
%315 = fptosi float %314 to i32
%316 = load i32**, i32*** %8
%317 = load i32, i32* %12
%318 = load i32, i32* %13
%319 = add nsw i32 %317, %318
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds i32*, i32** %316, i64 %320
%322 = load i32*, i32** %321
%323 = load i32, i32* %11
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds i32, i32* %322, i64 %324
store i32 %315, i32* %325
br label %392
326: ; preds = %255
%327 = load i32**, i32*** %8
%328 = load i32, i32* %12
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds i32*, i32** %327, i64 %329
%331 = load i32*, i32** %330
%332 = load i32, i32* %11
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds i32, i32* %331, i64 %333
%335 = load i32, i32* %334
%336 = load i32**, i32*** %8
%337 = load i32, i32* %12
%338 = load i32, i32* %13
%339 = add nsw i32 %337, %338
%340 = sext i32 %339 to i64
%341 = getelementptr inbounds i32*, i32** %336, i64 %340
%342 = load i32*, i32** %341
%343 = load i32, i32* %11
%344 = load i32, i32* %13
%345 = sub nsw i32 %343, %344
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds i32, i32* %342, i64 %346
%348 = load i32, i32* %347
%349 = load i32**, i32*** %8
%350 = load i32, i32* %12
%351 = load i32, i32* %13
%352 = add nsw i32 %350, %351
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds i32*, i32** %349, i64 %353
%355 = load i32*, i32** %354
%356 = load i32, i32* %11
%357 = load i32, i32* %13
%358 = add nsw i32 %356, %357
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds i32, i32* %355, i64 %359
%361 = load i32, i32* %360
%362 = load i32**, i32*** %8
%363 = load i32, i32* %12
%364 = load i32, i32* %13
%365 = mul nsw i32 2, %364
%366 = add nsw i32 %363, %365
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds i32*, i32** %362, i64 %367
%369 = load i32*, i32** %368
%370 = load i32, i32* %11
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds i32, i32* %369, i64 %371
%373 = load i32, i32* %372
%374 = call i32 (i32, i32, i32, i32, i32, ...) bitcast (i32 (...)* @average to i32 (i32, i32, i32, i32, i32, ...)*)(i32 4, i32 %335, i32 %348, i32 %361, i32 %373)
%375 = sitofp i32 %374 to float
%376 = load i32, i32* %15
%377 = sitofp i32 %376 to float
%378 = load float, float* %14
%379 = fneg float %377
%380 = call float @llvm.fmuladd.f32(float %379, float %378, float %375)
%381 = fptosi float %380 to i32
%382 = load i32**, i32*** %8
%383 = load i32, i32* %12
%384 = load i32, i32* %13
%385 = add nsw i32 %383, %384
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds i32*, i32** %382, i64 %386
%388 = load i32*, i32** %387
%389 = load i32, i32* %11
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds i32, i32* %388, i64 %390
store i32 %381, i32* %391
br label %392
392: ; preds = %326, %261
br label %393
393: ; preds = %392, %254
%394 = load i32, i32* %11
%395 = load i32, i32* %13
%396 = sub nsw i32 %394, %395
%397 = icmp eq i32 %396, 0
br i1 %397, label %398, label %512
398: ; preds = %393
%399 = call i32 (...) @rand()
%400 = load i32, i32* %13
%401 = srem i32 %399, %400
store i32 %401, i32* %15
%402 = call i32 (...) @should_add()
%403 = icmp ne i32 %402, 0
br i1 %403, label %404, label %457
404: ; preds = %398
%405 = load i32**, i32*** %8
%406 = load i32, i32* %12
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds i32*, i32** %405, i64 %407
%409 = load i32*, i32** %408
%410 = load i32, i32* %11
%411 = sext i32 %410 to i64
%412 = getelementptr inbounds i32, i32* %409, i64 %411
%413 = load i32, i32* %412
%414 = load i32**, i32*** %8
%415 = load i32, i32* %12
%416 = load i32, i32* %13
%417 = sub nsw i32 %415, %416
%418 = sext i32 %417 to i64
%419 = getelementptr inbounds i32*, i32** %414, i64 %418
%420 = load i32*, i32** %419
%421 = load i32, i32* %11
%422 = load i32, i32* %13
%423 = sub nsw i32 %421, %422
%424 = sext i32 %423 to i64
%425 = getelementptr inbounds i32, i32* %420, i64 %424
%426 = load i32, i32* %425
%427 = load i32**, i32*** %8
%428 = load i32, i32* %12
%429 = load i32, i32* %13
%430 = add nsw i32 %428, %429
%431 = sext i32 %430 to i64
%432 = getelementptr inbounds i32*, i32** %427, i64 %431
%433 = load i32*, i32** %432
%434 = load i32, i32* %11
%435 = load i32, i32* %13
%436 = sub nsw i32 %434, %435
%437 = sext i32 %436 to i64
%438 = getelementptr inbounds i32, i32* %433, i64 %437
%439 = load i32, i32* %438
%440 = call i32 (i32, i32, i32, i32, ...) bitcast (i32 (...)* @average to i32 (i32, i32, i32, i32, ...)*)(i32 3, i32 %413, i32 %426, i32 %439)
%441 = sitofp i32 %440 to float
%442 = load i32, i32* %15
%443 = sitofp i32 %442 to float
%444 = load float, float* %14
%445 = call float @llvm.fmuladd.f32(float %443, float %444, float %441)
%446 = fptosi float %445 to i32
%447 = load i32**, i32*** %8
%448 = load i32, i32* %12
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds i32*, i32** %447, i64 %449
%451 = load i32*, i32** %450
%452 = load i32, i32* %11
%453 = load i32, i32* %13
%454 = sub nsw i32 %452, %453
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds i32, i32* %451, i64 %455
store i32 %446, i32* %456
br label %511
457: ; preds = %398
%458 = load i32**, i32*** %8
%459 = load i32, i32* %12
%460 = sext i32 %459 to i64
%461 = getelementptr inbounds i32*, i32** %458, i64 %460
%462 = load i32*, i32** %461
%463 = load i32, i32* %11
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds i32, i32* %462, i64 %464
%466 = load i32, i32* %465
%467 = load i32**, i32*** %8
%468 = load i32, i32* %12
%469 = load i32, i32* %13
%470 = sub nsw i32 %468, %469
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds i32*, i32** %467, i64 %471
%473 = load i32*, i32** %472
%474 = load i32, i32* %11
%475 = load i32, i32* %13
%476 = sub nsw i32 %474, %475
%477 = sext i32 %476 to i64
%478 = getelementptr inbounds i32, i32* %473, i64 %477
%479 = load i32, i32* %478
%480 = load i32**, i32*** %8
%481 = load i32, i32* %12
%482 = load i32, i32* %13
%483 = add nsw i32 %481, %482
%484 = sext i32 %483 to i64
%485 = getelementptr inbounds i32*, i32** %480, i64 %484
%486 = load i32*, i32** %485
%487 = load i32, i32* %11
%488 = load i32, i32* %13
%489 = sub nsw i32 %487, %488
%490 = sext i32 %489 to i64
%491 = getelementptr inbounds i32, i32* %486, i64 %490
%492 = load i32, i32* %491
%493 = call i32 (i32, i32, i32, i32, ...) bitcast (i32 (...)* @average to i32 (i32, i32, i32, i32, ...)*)(i32 3, i32 %466, i32 %479, i32 %492)
%494 = sitofp i32 %493 to float
%495 = load i32, i32* %15
%496 = sitofp i32 %495 to float
%497 = load float, float* %14
%498 = fneg float %496
%499 = call float @llvm.fmuladd.f32(float %498, float %497, float %494)
%500 = fptosi float %499 to i32
%501 = load i32**, i32*** %8
%502 = load i32, i32* %12
%503 = sext i32 %502 to i64
%504 = getelementptr inbounds i32*, i32** %501, i64 %503
%505 = load i32*, i32** %504
%506 = load i32, i32* %11
%507 = load i32, i32* %13
%508 = sub nsw i32 %506, %507
%509 = sext i32 %508 to i64
%510 = getelementptr inbounds i32, i32* %505, i64 %509
store i32 %500, i32* %510
br label %511
511: ; preds = %457, %404
br label %512
512: ; preds = %511, %393
%513 = load i32, i32* %11
%514 = load i32, i32* %13
%515 = add nsw i32 %513, %514
%516 = load i32, i32* %9
%517 = sub nsw i32 %516, 1
%518 = icmp eq i32 %515, %517
br i1 %518, label %519, label %633
519: ; preds = %512
%520 = call i32 (...) @rand()
%521 = load i32, i32* %13
%522 = srem i32 %520, %521
store i32 %522, i32* %15
%523 = call i32 (...) @should_add()
%524 = icmp ne i32 %523, 0
br i1 %524, label %525, label %578
525: ; preds = %519
%526 = load i32**, i32*** %8
%527 = load i32, i32* %12
%528 = sext i32 %527 to i64
%529 = getelementptr inbounds i32*, i32** %526, i64 %528
%530 = load i32*, i32** %529
%531 = load i32, i32* %11
%532 = sext i32 %531 to i64
%533 = getelementptr inbounds i32, i32* %530, i64 %532
%534 = load i32, i32* %533
%535 = load i32**, i32*** %8
%536 = load i32, i32* %12
%537 = load i32, i32* %13
%538 = sub nsw i32 %536, %537
%539 = sext i32 %538 to i64
%540 = getelementptr inbounds i32*, i32** %535, i64 %539
%541 = load i32*, i32** %540
%542 = load i32, i32* %11
%543 = load i32, i32* %13
%544 = add nsw i32 %542, %543
%545 = sext i32 %544 to i64
%546 = getelementptr inbounds i32, i32* %541, i64 %545
%547 = load i32, i32* %546
%548 = load i32**, i32*** %8
%549 = load i32, i32* %12
%550 = load i32, i32* %13
%551 = add nsw i32 %549, %550
%552 = sext i32 %551 to i64
%553 = getelementptr inbounds i32*, i32** %548, i64 %552
%554 = load i32*, i32** %553
%555 = load i32, i32* %11
%556 = load i32, i32* %13
%557 = add nsw i32 %555, %556
%558 = sext i32 %557 to i64
%559 = getelementptr inbounds i32, i32* %554, i64 %558
%560 = load i32, i32* %559
%561 = call i32 (i32, i32, i32, i32, ...) bitcast (i32 (...)* @average to i32 (i32, i32, i32, i32, ...)*)(i32 3, i32 %534, i32 %547, i32 %560)
%562 = sitofp i32 %561 to float
%563 = load i32, i32* %15
%564 = sitofp i32 %563 to float
%565 = load float, float* %14
%566 = call float @llvm.fmuladd.f32(float %564, float %565, float %562)
%567 = fptosi float %566 to i32
%568 = load i32**, i32*** %8
%569 = load i32, i32* %12
%570 = sext i32 %569 to i64
%571 = getelementptr inbounds i32*, i32** %568, i64 %570
%572 = load i32*, i32** %571
%573 = load i32, i32* %11
%574 = load i32, i32* %13
%575 = add nsw i32 %573, %574
%576 = sext i32 %575 to i64
%577 = getelementptr inbounds i32, i32* %572, i64 %576
store i32 %567, i32* %577
br label %632
578: ; preds = %519
%579 = load i32**, i32*** %8
%580 = load i32, i32* %12
%581 = sext i32 %580 to i64
%582 = getelementptr inbounds i32*, i32** %579, i64 %581
%583 = load i32*, i32** %582
%584 = load i32, i32* %11
%585 = sext i32 %584 to i64
%586 = getelementptr inbounds i32, i32* %583, i64 %585
%587 = load i32, i32* %586
%588 = load i32**, i32*** %8
%589 = load i32, i32* %12
%590 = load i32, i32* %13
%591 = sub nsw i32 %589, %590
%592 = sext i32 %591 to i64
%593 = getelementptr inbounds i32*, i32** %588, i64 %592
%594 = load i32*, i32** %593
%595 = load i32, i32* %11
%596 = load i32, i32* %13
%597 = add nsw i32 %595, %596
%598 = sext i32 %597 to i64
%599 = getelementptr inbounds i32, i32* %594, i64 %598
%600 = load i32, i32* %599
%601 = load i32**, i32*** %8
%602 = load i32, i32* %12
%603 = load i32, i32* %13
%604 = add nsw i32 %602, %603
%605 = sext i32 %604 to i64
%606 = getelementptr inbounds i32*, i32** %601, i64 %605
%607 = load i32*, i32** %606
%608 = load i32, i32* %11
%609 = load i32, i32* %13
%610 = add nsw i32 %608, %609
%611 = sext i32 %610 to i64
%612 = getelementptr inbounds i32, i32* %607, i64 %611
%613 = load i32, i32* %612
%614 = call i32 (i32, i32, i32, i32, ...) bitcast (i32 (...)* @average to i32 (i32, i32, i32, i32, ...)*)(i32 3, i32 %587, i32 %600, i32 %613)
%615 = sitofp i32 %614 to float
%616 = load i32, i32* %15
%617 = sitofp i32 %616 to float
%618 = load float, float* %14
%619 = fneg float %617
%620 = call float @llvm.fmuladd.f32(float %619, float %618, float %615)
%621 = fptosi float %620 to i32
%622 = load i32**, i32*** %8
%623 = load i32, i32* %12
%624 = sext i32 %623 to i64
%625 = getelementptr inbounds i32*, i32** %622, i64 %624
%626 = load i32*, i32** %625
%627 = load i32, i32* %11
%628 = load i32, i32* %13
%629 = add nsw i32 %627, %628
%630 = sext i32 %629 to i64
%631 = getelementptr inbounds i32, i32* %626, i64 %630
store i32 %621, i32* %631
br label %632
632: ; preds = %578, %525
br label %771
633: ; preds = %512
%634 = call i32 (...) @rand()
%635 = load i32, i32* %13
%636 = srem i32 %634, %635
store i32 %636, i32* %15
%637 = call i32 (...) @should_add()
%638 = icmp ne i32 %637, 0
br i1 %638, label %639, label %704
639: ; preds = %633
%640 = load i32**, i32*** %8
%641 = load i32, i32* %12
%642 = sext i32 %641 to i64
%643 = getelementptr inbounds i32*, i32** %640, i64 %642
%644 = load i32*, i32** %643
%645 = load i32, i32* %11
%646 = sext i32 %645 to i64
%647 = getelementptr inbounds i32, i32* %644, i64 %646
%648 = load i32, i32* %647
%649 = load i32**, i32*** %8
%650 = load i32, i32* %12
%651 = load i32, i32* %13
%652 = sub nsw i32 %650, %651
%653 = sext i32 %652 to i64
%654 = getelementptr inbounds i32*, i32** %649, i64 %653
%655 = load i32*, i32** %654
%656 = load i32, i32* %11
%657 = load i32, i32* %13
%658 = sub nsw i32 %656, %657
%659 = sext i32 %658 to i64
%660 = getelementptr inbounds i32, i32* %655, i64 %659
%661 = load i32, i32* %660
%662 = load i32**, i32*** %8
%663 = load i32, i32* %12
%664 = load i32, i32* %13
%665 = add nsw i32 %663, %664
%666 = sext i32 %665 to i64
%667 = getelementptr inbounds i32*, i32** %662, i64 %666
%668 = load i32*, i32** %667
%669 = load i32, i32* %11
%670 = load i32, i32* %13
%671 = add nsw i32 %669, %670
%672 = sext i32 %671 to i64
%673 = getelementptr inbounds i32, i32* %668, i64 %672
%674 = load i32, i32* %673
%675 = load i32**, i32*** %8
%676 = load i32, i32* %12
%677 = sext i32 %676 to i64
%678 = getelementptr inbounds i32*, i32** %675, i64 %677
%679 = load i32*, i32** %678
%680 = load i32, i32* %11
%681 = load i32, i32* %13
%682 = mul nsw i32 2, %681
%683 = add nsw i32 %680, %682
%684 = sext i32 %683 to i64
%685 = getelementptr inbounds i32, i32* %679, i64 %684
%686 = load i32, i32* %685
%687 = call i32 (i32, i32, i32, i32, i32, ...) bitcast (i32 (...)* @average to i32 (i32, i32, i32, i32, i32, ...)*)(i32 4, i32 %648, i32 %661, i32 %674, i32 %686)
%688 = sitofp i32 %687 to float
%689 = load i32, i32* %15
%690 = sitofp i32 %689 to float
%691 = load float, float* %14
%692 = call float @llvm.fmuladd.f32(float %690, float %691, float %688)
%693 = fptosi float %692 to i32
%694 = load i32**, i32*** %8
%695 = load i32, i32* %12
%696 = sext i32 %695 to i64
%697 = getelementptr inbounds i32*, i32** %694, i64 %696
%698 = load i32*, i32** %697
%699 = load i32, i32* %11
%700 = load i32, i32* %13
%701 = add nsw i32 %699, %700
%702 = sext i32 %701 to i64
%703 = getelementptr inbounds i32, i32* %698, i64 %702
store i32 %693, i32* %703
br label %770
704: ; preds = %633
%705 = load i32**, i32*** %8
%706 = load i32, i32* %12
%707 = sext i32 %706 to i64
%708 = getelementptr inbounds i32*, i32** %705, i64 %707
%709 = load i32*, i32** %708
%710 = load i32, i32* %11
%711 = sext i32 %710 to i64
%712 = getelementptr inbounds i32, i32* %709, i64 %711
%713 = load i32, i32* %712
%714 = load i32**, i32*** %8
%715 = load i32, i32* %12
%716 = load i32, i32* %13
%717 = sub nsw i32 %715, %716
%718 = sext i32 %717 to i64
%719 = getelementptr inbounds i32*, i32** %714, i64 %718
%720 = load i32*, i32** %719
%721 = load i32, i32* %11
%722 = load i32, i32* %13
%723 = sub nsw i32 %721, %722
%724 = sext i32 %723 to i64
%725 = getelementptr inbounds i32, i32* %720, i64 %724
%726 = load i32, i32* %725
%727 = load i32**, i32*** %8
%728 = load i32, i32* %12
%729 = load i32, i32* %13
%730 = add nsw i32 %728, %729
%731 = sext i32 %730 to i64
%732 = getelementptr inbounds i32*, i32** %727, i64 %731
%733 = load i32*, i32** %732
%734 = load i32, i32* %11
%735 = load i32, i32* %13
%736 = add nsw i32 %734, %735
%737 = sext i32 %736 to i64
%738 = getelementptr inbounds i32, i32* %733, i64 %737
%739 = load i32, i32* %738
%740 = load i32**, i32*** %8
%741 = load i32, i32* %12
%742 = sext i32 %741 to i64
%743 = getelementptr inbounds i32*, i32** %740, i64 %742
%744 = load i32*, i32** %743
%745 = load i32, i32* %11
%746 = load i32, i32* %13
%747 = mul nsw i32 2, %746
%748 = add nsw i32 %745, %747
%749 = sext i32 %748 to i64
%750 = getelementptr inbounds i32, i32* %744, i64 %749
%751 = load i32, i32* %750
%752 = call i32 (i32, i32, i32, i32, i32, ...) bitcast (i32 (...)* @average to i32 (i32, i32, i32, i32, i32, ...)*)(i32 4, i32 %713, i32 %726, i32 %739, i32 %751)
%753 = sitofp i32 %752 to float
%754 = load i32, i32* %15
%755 = sitofp i32 %754 to float
%756 = load float, float* %14
%757 = fneg float %755
%758 = call float @llvm.fmuladd.f32(float %757, float %756, float %753)
%759 = fptosi float %758 to i32
%760 = load i32**, i32*** %8
%761 = load i32, i32* %12
%762 = sext i32 %761 to i64
%763 = getelementptr inbounds i32*, i32** %760, i64 %762
%764 = load i32*, i32** %763
%765 = load i32, i32* %11
%766 = load i32, i32* %13
%767 = add nsw i32 %765, %766
%768 = sext i32 %767 to i64
%769 = getelementptr inbounds i32, i32* %764, i64 %768
store i32 %759, i32* %769
br label %770
770: ; preds = %704, %639
br label %771
771: ; preds = %770, %632
ret void
}

LLVM IR (-O2):
define void @diamond(i32** %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5, float %6) {
%8 = sub nsw i32 %4, %5
%9 = icmp eq i32 %8, 0
br i1 %9, label %10, label %39
10: ; preds = %7
%11 = tail call i32 (...) @rand()
%12 = srem i32 %11, %5
%13 = tail call i32 (...) @should_add()
%14 = icmp eq i32 %13, 0
%15 = sext i32 %4 to i64
%16 = getelementptr inbounds i32*, i32** %0, i64 %15
%17 = load i32*, i32** %16
%18 = sext i32 %3 to i64
%19 = getelementptr inbounds i32, i32* %17, i64 %18
%20 = load i32, i32* %19
%21 = load i32*, i32** %0
%22 = sub nsw i32 %3, %5
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds i32, i32* %21, i64 %23
%25 = load i32, i32* %24
%26 = add nsw i32 %5, %3
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds i32, i32* %21, i64 %27
%29 = load i32, i32* %28
%30 = tail call i32 (i32, i32, i32, i32, ...) bitcast (i32 (...)* @average to i32 (i32, i32, i32, i32, ...)*)(i32 3, i32 %20, i32 %25, i32 %29)
%31 = sitofp i32 %30 to float
%32 = sitofp i32 %12 to float
%33 = fneg float %32
%34 = select i1 %14, float %33, float %32
%35 = tail call float @llvm.fmuladd.f32(float %34, float %6, float %31)
%36 = fptosi float %35 to i32
%37 = load i32*, i32** %0
%38 = getelementptr inbounds i32, i32* %37, i64 %18
store i32 %36, i32* %38
br label %39
39: ; preds = %10, %7
%40 = add nsw i32 %5, %4
%41 = add nsw i32 %2, -1
%42 = icmp eq i32 %40, %41
%43 = tail call i32 (...) @rand()
%44 = srem i32 %43, %5
%45 = tail call i32 (...) @should_add()
%46 = icmp eq i32 %45, 0
%47 = sext i32 %4 to i64
%48 = getelementptr inbounds i32*, i32** %0, i64 %47
%49 = load i32*, i32** %48
%50 = sext i32 %3 to i64
%51 = getelementptr inbounds i32, i32* %49, i64 %50
%52 = load i32, i32* %51
%53 = sext i32 %40 to i64
%54 = getelementptr inbounds i32*, i32** %0, i64 %53
%55 = load i32*, i32** %54
%56 = sub nsw i32 %3, %5
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds i32, i32* %55, i64 %57
%59 = load i32, i32* %58
%60 = add nsw i32 %5, %3
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds i32, i32* %55, i64 %61
%63 = load i32, i32* %62
br i1 %42, label %64, label %73
64: ; preds = %39
%65 = tail call i32 (i32, i32, i32, i32, ...) bitcast (i32 (...)* @average to i32 (i32, i32, i32, i32, ...)*)(i32 3, i32 %52, i32 %59, i32 %63)
%66 = sitofp i32 %65 to float
%67 = sitofp i32 %44 to float
br i1 %46, label %70, label %68
68: ; preds = %64
%69 = tail call float @llvm.fmuladd.f32(float %67, float %6, float %66)
br label %89
70: ; preds = %64
%71 = fneg float %67
%72 = tail call float @llvm.fmuladd.f32(float %71, float %6, float %66)
br label %89
73: ; preds = %39
%74 = shl nsw i32 %5, 1
%75 = add nsw i32 %74, %4
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds i32*, i32** %0, i64 %76
%78 = load i32*, i32** %77
%79 = getelementptr inbounds i32, i32* %78, i64 %50
%80 = load i32, i32* %79
%81 = tail call i32 (i32, i32, i32, i32, i32, ...) bitcast (i32 (...)* @average to i32 (i32, i32, i32, i32, i32, ...)*)(i32 4, i32 %52, i32 %59, i32 %63, i32 %80)
%82 = sitofp i32 %81 to float
%83 = sitofp i32 %44 to float
br i1 %46, label %86, label %84
84: ; preds = %73
%85 = tail call float @llvm.fmuladd.f32(float %83, float %6, float %82)
br label %89
86: ; preds = %73
%87 = fneg float %83
%88 = tail call float @llvm.fmuladd.f32(float %87, float %6, float %82)
br label %89
89: ; preds = %84, %86, %68, %70
%90 = phi float [ %85, %84 ], [ %88, %86 ], [ %69, %68 ], [ %72, %70 ]
%91 = fptosi float %90 to i32
%92 = load i32*, i32** %54
%93 = getelementptr inbounds i32, i32* %92, i64 %50
store i32 %91, i32* %93
%94 = icmp eq i32 %56, 0
br i1 %94, label %95, label %122
95: ; preds = %89
%96 = tail call i32 (...) @rand()
%97 = srem i32 %96, %5
%98 = tail call i32 (...) @should_add()
%99 = icmp eq i32 %98, 0
%100 = sext i32 %4 to i64
%101 = getelementptr inbounds i32*, i32** %0, i64 %100
%102 = load i32*, i32** %101
%103 = sext i32 %3 to i64
%104 = getelementptr inbounds i32, i32* %102, i64 %103
%105 = load i32, i32* %104
%106 = sext i32 %8 to i64
%107 = getelementptr inbounds i32*, i32** %0, i64 %106
%108 = load i32*, i32** %107
%109 = load i32, i32* %108
%110 = sext i32 %40 to i64
%111 = getelementptr inbounds i32*, i32** %0, i64 %110
%112 = load i32*, i32** %111
%113 = load i32, i32* %112
%114 = tail call i32 (i32, i32, i32, i32, ...) bitcast (i32 (...)* @average to i32 (i32, i32, i32, i32, ...)*)(i32 3, i32 %105, i32 %109, i32 %113)
%115 = sitofp i32 %114 to float
%116 = sitofp i32 %97 to float
%117 = fneg float %116
%118 = select i1 %99, float %117, float %116
%119 = tail call float @llvm.fmuladd.f32(float %118, float %6, float %115)
%120 = fptosi float %119 to i32
%121 = load i32*, i32** %101
store i32 %120, i32* %121
br label %122
122: ; preds = %95, %89
%123 = add nsw i32 %5, %3
%124 = add nsw i32 %1, -1
%125 = icmp eq i32 %123, %124
%126 = tail call i32 (...) @rand()
%127 = srem i32 %126, %5
%128 = tail call i32 (...) @should_add()
%129 = icmp eq i32 %128, 0
%130 = sext i32 %4 to i64
%131 = getelementptr inbounds i32*, i32** %0, i64 %130
%132 = load i32*, i32** %131
%133 = sext i32 %3 to i64
%134 = getelementptr inbounds i32, i32* %132, i64 %133
%135 = load i32, i32* %134
%136 = sext i32 %8 to i64
%137 = getelementptr inbounds i32*, i32** %0, i64 %136
%138 = load i32*, i32** %137
br i1 %125, label %139, label %156
139: ; preds = %122
%140 = sext i32 %123 to i64
%141 = getelementptr inbounds i32, i32* %138, i64 %140
%142 = load i32, i32* %141
%143 = sext i32 %40 to i64
%144 = getelementptr inbounds i32*, i32** %0, i64 %143
%145 = load i32*, i32** %144
%146 = getelementptr inbounds i32, i32* %145, i64 %140
%147 = load i32, i32* %146
%148 = tail call i32 (i32, i32, i32, i32, ...) bitcast (i32 (...)* @average to i32 (i32, i32, i32, i32, ...)*)(i32 3, i32 %135, i32 %142, i32 %147)
%149 = sitofp i32 %148 to float
%150 = sitofp i32 %127 to float
br i1 %129, label %153, label %151
151: ; preds = %139
%152 = tail call float @llvm.fmuladd.f32(float %150, float %6, float %149)
br label %179
153: ; preds = %139
%154 = fneg float %150
%155 = tail call float @llvm.fmuladd.f32(float %154, float %6, float %149)
br label %179
156: ; preds = %122
%157 = sext i32 %56 to i64
%158 = getelementptr inbounds i32, i32* %138, i64 %157
%159 = load i32, i32* %158
%160 = sext i32 %40 to i64
%161 = getelementptr inbounds i32*, i32** %0, i64 %160
%162 = load i32*, i32** %161
%163 = sext i32 %123 to i64
%164 = getelementptr inbounds i32, i32* %162, i64 %163
%165 = load i32, i32* %164
%166 = shl nsw i32 %5, 1
%167 = add nsw i32 %166, %3
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds i32, i32* %132, i64 %168
%170 = load i32, i32* %169
%171 = tail call i32 (i32, i32, i32, i32, i32, ...) bitcast (i32 (...)* @average to i32 (i32, i32, i32, i32, i32, ...)*)(i32 4, i32 %135, i32 %159, i32 %165, i32 %170)
%172 = sitofp i32 %171 to float
%173 = sitofp i32 %127 to float
br i1 %129, label %176, label %174
174: ; preds = %156
%175 = tail call float @llvm.fmuladd.f32(float %173, float %6, float %172)
br label %179
176: ; preds = %156
%177 = fneg float %173
%178 = tail call float @llvm.fmuladd.f32(float %177, float %6, float %172)
br label %179
179: ; preds = %174, %176, %151, %153
%180 = phi float [ %175, %174 ], [ %178, %176 ], [ %152, %151 ], [ %155, %153 ]
%181 = phi i64 [ %163, %174 ], [ %163, %176 ], [ %140, %151 ], [ %140, %153 ]
%182 = fptosi float %180 to i32
%183 = load i32*, i32** %131
%184 = getelementptr inbounds i32, i32* %183, i64 %181
store i32 %182, i32* %184
ret void
}