#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 */
scalar_t__ gaussrand();
void diamond_square(float *heightmap, int dim, float sigma, int level) {
  if (level < 1)
    return;
  for (int i = level; i < dim; i += level) {
    for (int j = level; j < dim; j += level) {
      float a = heightmap[(i - level) * dim + j - level];
      float b = heightmap[i * dim + j - level];
      float c = heightmap[(i - level) * dim + j];
      float d = heightmap[i * dim + j];
      heightmap[(i - level / 2) * dim + j - level / 2] =
          (a + b + c + d) / 4 + (float)gaussrand() * sigma;
    }
  }
  for (int i = 2 * level; i < dim; i += level) {
    for (int j = 2 * level; j < dim; j += level) {
      float a = heightmap[(i - level) * dim + j - level];
      float b = heightmap[i * dim + j - level];
      float c = heightmap[(i - level) * dim + j];
      float e = heightmap[(i - level / 2) * dim + j - level / 2];
      heightmap[(i - level) * dim + (j - level / 2)] =
          (a + c + e + heightmap[(i - 3 * level / 2) * dim + (j - level / 2)]) /
              4 +
          (float)gaussrand() * sigma;
      heightmap[(i - level / 2) * dim + j - level] =
          (a + b + e + heightmap[(i - level / 2) * dim + (j - 3 * level / 2)]) /
              4 +
          (float)gaussrand() * sigma;
    }
  }
  diamond_square(heightmap, dim, sigma / 2, level / 2);
}


x86 assembly (clang, -O0):
<diamond_square>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movss  %xmm0,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
cmpl   $0x1,-0x14(%rbp)
jge    1149 <diamond_square+0x29>
jmp    151c <diamond_square+0x3fc>
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1283 <diamond_square+0x163>
mov    -0x14(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1270 <diamond_square+0x150>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x1c(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x1c(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
movss  0xe03(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    $0x0,%al
call   1040 <gaussrand@plt>
movss  -0x54(%rbp),%xmm1
cvtsi2ss %rax,%xmm0
movss  -0x10(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x14(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
sub    %eax,%ecx
imul   -0xc(%rbp),%ecx
add    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x50(%rbp),%rax
sub    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    1161 <diamond_square+0x41>
jmp    1275 <diamond_square+0x155>
mov    -0x14(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    114f <diamond_square+0x2f>
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14f2 <diamond_square+0x3d2>
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14df <diamond_square+0x3bf>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x34(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x34(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x30(%rbp),%ecx
mov    -0x14(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
sub    %eax,%ecx
imul   -0xc(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    -0x14(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0xa0(%rbp),%rax
sub    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x38(%rbp),%xmm0
addss  -0x40(%rbp),%xmm0
addss  -0x44(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x30(%rbp),%ecx
imul   $0x3,-0x14(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
sub    %eax,%ecx
imul   -0xc(%rbp),%ecx
mov    -0x34(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    -0x94(%rbp),%edx
mov    %eax,%esi
mov    -0x90(%rbp),%rax
sub    %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  0xc4f(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    $0x0,%al
call   1040 <gaussrand@plt>
movss  -0x88(%rbp),%xmm1
ff
cvtsi2ss %rax,%xmm0
movss  -0x10(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x30(%rbp),%ecx
sub    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x34(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    -0x84(%rbp),%edx
mov    %eax,%esi
mov    -0x80(%rbp),%rax
sub    %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x38(%rbp),%xmm0
addss  -0x3c(%rbp),%xmm0
addss  -0x44(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x30(%rbp),%ecx
mov    -0x14(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
sub    %eax,%ecx
imul   -0xc(%rbp),%ecx
mov    -0x34(%rbp),%eax
mov    %eax,-0x74(%rbp)
imul   $0x3,-0x14(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    -0x74(%rbp),%edx
mov    %eax,%esi
mov    -0x70(%rbp),%rax
sub    %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  0xb8a(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    $0x0,%al
call   1040 <gaussrand@plt>
movss  -0x64(%rbp),%xmm1
cvtsi2ss %rax,%xmm0
movss  -0x10(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x30(%rbp),%ecx
mov    -0x14(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x60(%rbp),%rax
sub    %edx,%ecx
imul   -0xc(%rbp),%ecx
add    -0x34(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    12a1 <diamond_square+0x181>
jmp    14e4 <diamond_square+0x3c4>
mov    -0x14(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    128c <diamond_square+0x16c>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
movss  -0x10(%rbp),%xmm0
movss  0xafa(%rip),%xmm1
divss  %xmm1,%xmm0
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
call   1030 <diamond_square@plt>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<diamond_square>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %esi,0x8(%rsp)
test   %edx,%edx
jle    1527 <diamond_square+0x417>
movslq 0x8(%rsp),%r8
lea    0x1(%r8),%rax
mov    %rax,0x70(%rsp)
lea    0x0(,%r8,4),%rax
mov    %rax,0x60(%rsp)
lea    0x1(%r8,%r8,1),%eax
mov    %eax,0x50(%rsp)
movss  0xea7(%rip),%xmm1
mov    %rdi,0x48(%rsp)
mov    %r8,0x68(%rsp)
jmp    118e <diamond_square+0x7e>
cs nopw 0x0(%rax,%rax,1)
nop
movss  0xc(%rsp),%xmm0
mulss  0xe86(%rip),%xmm0
cmp    $0x2,%r12d
mov    0x1c(%rsp),%eax
mov    %eax,%edx
jl     1527 <diamond_square+0x417>
movss  %xmm0,0xc(%rsp)
mov    %rdx,0x28(%rsp)
cmp    0x8(%rsp),%edx
jge    12ce <diamond_square+0x1be>
mov    0x28(%rsp),%r9
mov    %r9d,%eax
shr    $0x1f,%eax
add    %r9d,%eax
sar    %eax
movslq %r9d,%r15
mov    0x70(%rsp),%rcx
imul   %r15,%rcx
lea    (%rdi,%rcx,4),%r12
mov    0x60(%rsp),%rcx
imul   %r15,%rcx
mov    %rcx,0x38(%rsp)
mov    %r8,%rcx
imul   %r15,%rcx
lea    (%rdi,%rcx,4),%rcx
lea    (%rdi,%r15,4),%rdx
mov    %r9d,%ebp
sub    %eax,%ebp
mov    0x8(%rsp),%r8d
imul   %r8d,%ebp
add    %r9d,%ebp
sub    %eax,%ebp
imul   %r9d,%r8d
mov    %r8d,0x30(%rsp)
mov    %rdi,%rbx
mov    %r15,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rax,0x20(%rsp)
mov    %ebp,0x18(%rsp)
mov    %ebp,%r14d
xor    %r13d,%r13d
mov    %rcx,0x40(%rsp)
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rbx,%r13,4),%xmm0
addss  (%rcx,%r13,4),%xmm0
addss  (%rdx,%r13,4),%xmm0
addss  (%r12,%r13,4),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,0x10(%rsp)
xor    %eax,%eax
mov    %rdx,%rbp
call   1030 <gaussrand@plt>
mov    %rbp,%rdx
mov    0x40(%rsp),%rcx
movss  0xd94(%rip),%xmm1
mov    0x68(%rsp),%r8
mov    0x48(%rsp),%rdi
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mulss  0xc(%rsp),%xmm0
addss  0x10(%rsp),%xmm0
movslq %r14d,%r14
movss  %xmm0,(%rdi,%r14,4)
add    %r15,%r13
add    0x28(%rsp),%r14d
lea    (%r15,%r13,1),%rax
cmp    %r8,%rax
jl     1230 <diamond_square+0x120>
mov    0x20(%rsp),%rax
add    %r15,%rax
mov    0x38(%rsp),%rbp
add    %rbp,%r12
add    %rbp,%rcx
add    %rbp,%rdx
add    %rbp,%rbx
mov    0x18(%rsp),%ebp
add    0x30(%rsp),%ebp
cmp    %r8,%rax
jl     1210 <diamond_square+0x100>
mov    0x28(%rsp),%r12
lea    (%r12,%r12,1),%r15d
mov    %r12d,%ecx
shr    $0x1f,%ecx
add    %r12d,%ecx
sar    %ecx
mov    %ecx,0x1c(%rsp)
cmp    0x8(%rsp),%r15d
jge    1170 <diamond_square+0x60>
lea    (%r12,%r12,2),%ecx
mov    %ecx,%esi
shr    $0x1f,%esi
add    %ecx,%esi
sar    %esi
movslq %r15d,%r11
movslq %r12d,%r13
movslq 0x1c(%rsp),%rax
movslq %esi,%rcx
mov    %rcx,0x10(%rsp)
mov    %r11,%rbx
sub    %r13,%rbx
imul   %r8,%rbx
add    %r11,%rbx
mov    %rbx,%rsi
sub    %rax,%rsi
lea    (%rdi,%rsi,4),%r9
mov    0x60(%rsp),%rsi
imul   %r13,%rsi
mov    %rsi,0x78(%rsp)
mov    %r11,%rsi
sub    %rcx,%rsi
imul   %r8,%rsi
add    %r11,%rsi
sub    %rax,%rsi
lea    (%rdi,%rsi,4),%r14
mov    %r11,%rbp
sub    %rax,%rbp
imul   %r8,%rbp
add    %r11,%rbp
mov    %rbp,%rsi
sub    %r13,%rsi
lea    (%rdi,%rsi,4),%r10
sub    %rax,%rbp
lea    (%rdi,%rbp,4),%rdx
lea    (%rdi,%rbx,4),%rcx
sub    %r13,%rbx
lea    (%rdi,%rbx,4),%rsi
mov    %r15d,%ebp
sub    %eax,%ebp
mov    0x8(%rsp),%eax
imul   %eax,%ebp
add    %r15d,%ebp
sub    0x10(%rsp),%ebp
imul   %r12d,%eax
mov    %eax,0x54(%rsp)
mov    0x50(%rsp),%eax
imul   %r12d,%eax
mov    %r11,%rbx
mov    %r11,0x90(%rsp)
mov    %r13,0x88(%rsp)
nopl   0x0(%rax)
mov    %r9,0x20(%rsp)
mov    %rbx,0x80(%rsp)
mov    %eax,0x58(%rsp)
mov    %eax,%ebx
mov    %ebp,0x5c(%rsp)
mov    %ebp,%r15d
xor    %ebp,%ebp
mov    %r10,0x38(%rsp)
mov    %rdx,0x30(%rsp)
cs nopw 0x0(%rax,%rax,1)
movss  (%rsi,%rbp,4),%xmm0
movss  (%rdx,%rbp,4),%xmm2
movss  %xmm2,0x40(%rsp)
movss  (%rcx,%rbp,4),%xmm3
addss  %xmm0,%xmm3
addss  %xmm2,%xmm3
addss  (%r14,%rbp,4),%xmm3
movslq %ebx,%rbx
mulss  %xmm1,%xmm3
movss  %xmm3,0x18(%rsp)
addss  (%rdi,%rbx,4),%xmm0
movss  %xmm0,0x10(%rsp)
xor    %eax,%eax
mov    %rcx,%r12
mov    %rsi,%r13
call   1030 <gaussrand@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mulss  0xc(%rsp),%xmm0
addss  0x18(%rsp),%xmm0
mov    0x20(%rsp),%rax
movss  %xmm0,(%rax,%rbp,4)
movss  0x10(%rsp),%xmm0
addss  0x40(%rsp),%xmm0
movslq %r15d,%r15
mov    0x48(%rsp),%rax
addss  (%rax,%r15,4),%xmm0
mulss  0xb98(%rip),%xmm0
movss  %xmm0,0x10(%rsp)
xor    %eax,%eax
call   1030 <gaussrand@plt>
mov    %r13,%rsi
mov    %r12,%rcx
mov    0x38(%rsp),%r10
mov    0x30(%rsp),%rdx
mov    0x28(%rsp),%r12
mov    0x88(%rsp),%r13
mov    0x90(%rsp),%r11
movss  0xb5e(%rip),%xmm1
mov    0x68(%rsp),%r8
mov    0x48(%rsp),%rdi
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mulss  0xc(%rsp),%xmm0
addss  0x10(%rsp),%xmm0
movss  %xmm0,(%r10,%rbp,4)
add    %r13,%rbp
add    %r12d,%r15d
add    %r12d,%ebx
lea    (%r11,%rbp,1),%rax
cmp    %r8,%rax
jl     13e0 <diamond_square+0x2d0>
mov    0x80(%rsp),%rbx
add    %r13,%rbx
mov    0x78(%rsp),%rax
mov    0x20(%rsp),%r15
add    %rax,%r15
add    %rax,%r14
add    %rax,%r10
add    %rax,%rdx
add    %rax,%rcx
add    %rax,%rsi
mov    0x5c(%rsp),%ebp
mov    0x54(%rsp),%r9d
add    %r9d,%ebp
mov    0x58(%rsp),%eax
add    %r9d,%eax
cmp    %r8,%rbx
mov    %r15,%r9
jl     13b0 <diamond_square+0x2a0>
jmp    1170 <diamond_square+0x60>
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @diamond_square(float* %0, i32 %1, float %2, i32 %3) {
%5 = alloca float*
%6 = alloca i32
%7 = alloca float
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca i32
%16 = alloca i32
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
store float* %0, float** %5
store i32 %1, i32* %6
store float %2, float* %7
store i32 %3, i32* %8
%21 = load i32, i32* %8
%22 = icmp slt i32 %21, 1
br i1 %22, label %23, label %24
23: ; preds = %4
br label %277
24: ; preds = %4
%25 = load i32, i32* %8
store i32 %25, i32* %9
br label %26
26: ; preds = %112, %24
%27 = load i32, i32* %9
%28 = load i32, i32* %6
%29 = icmp slt i32 %27, %28
br i1 %29, label %30, label %116
30: ; preds = %26
%31 = load i32, i32* %8
store i32 %31, i32* %10
br label %32
32: ; preds = %107, %30
%33 = load i32, i32* %10
%34 = load i32, i32* %6
%35 = icmp slt i32 %33, %34
br i1 %35, label %36, label %111
36: ; preds = %32
%37 = load float*, float** %5
%38 = load i32, i32* %9
%39 = load i32, i32* %8
%40 = sub nsw i32 %38, %39
%41 = load i32, i32* %6
%42 = mul nsw i32 %40, %41
%43 = load i32, i32* %10
%44 = add nsw i32 %42, %43
%45 = load i32, i32* %8
%46 = sub nsw i32 %44, %45
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds float, float* %37, i64 %47
%49 = load float, float* %48
store float %49, float* %11
%50 = load float*, float** %5
%51 = load i32, i32* %9
%52 = load i32, i32* %6
%53 = mul nsw i32 %51, %52
%54 = load i32, i32* %10
%55 = add nsw i32 %53, %54
%56 = load i32, i32* %8
%57 = sub nsw i32 %55, %56
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds float, float* %50, i64 %58
%60 = load float, float* %59
store float %60, float* %12
%61 = load float*, float** %5
%62 = load i32, i32* %9
%63 = load i32, i32* %8
%64 = sub nsw i32 %62, %63
%65 = load i32, i32* %6
%66 = mul nsw i32 %64, %65
%67 = load i32, i32* %10
%68 = add nsw i32 %66, %67
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds float, float* %61, i64 %69
%71 = load float, float* %70
store float %71, float* %13
%72 = load float*, float** %5
%73 = load i32, i32* %9
%74 = load i32, i32* %6
%75 = mul nsw i32 %73, %74
%76 = load i32, i32* %10
%77 = add nsw i32 %75, %76
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds float, float* %72, i64 %78
%80 = load float, float* %79
store float %80, float* %14
%81 = load float, float* %11
%82 = load float, float* %12
%83 = fadd float %81, %82
%84 = load float, float* %13
%85 = fadd float %83, %84
%86 = load float, float* %14
%87 = fadd float %85, %86
%88 = fdiv float %87, 4.000000e+00
%89 = call i64 (...) @gaussrand()
%90 = sitofp i64 %89 to float
%91 = load float, float* %7
%92 = call float @llvm.fmuladd.f32(float %90, float %91, float %88)
%93 = load float*, float** %5
%94 = load i32, i32* %9
%95 = load i32, i32* %8
%96 = sdiv i32 %95, 2
%97 = sub nsw i32 %94, %96
%98 = load i32, i32* %6
%99 = mul nsw i32 %97, %98
%100 = load i32, i32* %10
%101 = add nsw i32 %99, %100
%102 = load i32, i32* %8
%103 = sdiv i32 %102, 2
%104 = sub nsw i32 %101, %103
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds float, float* %93, i64 %105
store float %92, float* %106
br label %107
107: ; preds = %36
%108 = load i32, i32* %8
%109 = load i32, i32* %10
%110 = add nsw i32 %109, %108
store i32 %110, i32* %10
br label %32
111: ; preds = %32
br label %112
112: ; preds = %111
%113 = load i32, i32* %8
%114 = load i32, i32* %9
%115 = add nsw i32 %114, %113
store i32 %115, i32* %9
br label %26
116: ; preds = %26
%117 = load i32, i32* %8
%118 = mul nsw i32 2, %117
store i32 %118, i32* %15
br label %119
119: ; preds = %266, %116
%120 = load i32, i32* %15
%121 = load i32, i32* %6
%122 = icmp slt i32 %120, %121
br i1 %122, label %123, label %270
123: ; preds = %119
%124 = load i32, i32* %8
%125 = mul nsw i32 2, %124
store i32 %125, i32* %16
br label %126
126: ; preds = %261, %123
%127 = load i32, i32* %16
%128 = load i32, i32* %6
%129 = icmp slt i32 %127, %128
br i1 %129, label %130, label %265
130: ; preds = %126
%131 = load float*, float** %5
%132 = load i32, i32* %15
%133 = load i32, i32* %8
%134 = sub nsw i32 %132, %133
%135 = load i32, i32* %6
%136 = mul nsw i32 %134, %135
%137 = load i32, i32* %16
%138 = add nsw i32 %136, %137
%139 = load i32, i32* %8
%140 = sub nsw i32 %138, %139
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds float, float* %131, i64 %141
%143 = load float, float* %142
store float %143, float* %17
%144 = load float*, float** %5
%145 = load i32, i32* %15
%146 = load i32, i32* %6
%147 = mul nsw i32 %145, %146
%148 = load i32, i32* %16
%149 = add nsw i32 %147, %148
%150 = load i32, i32* %8
%151 = sub nsw i32 %149, %150
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds float, float* %144, i64 %152
%154 = load float, float* %153
store float %154, float* %18
%155 = load float*, float** %5
%156 = load i32, i32* %15
%157 = load i32, i32* %8
%158 = sub nsw i32 %156, %157
%159 = load i32, i32* %6
%160 = mul nsw i32 %158, %159
%161 = load i32, i32* %16
%162 = add nsw i32 %160, %161
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds float, float* %155, i64 %163
%165 = load float, float* %164
store float %165, float* %19
%166 = load float*, float** %5
%167 = load i32, i32* %15
%168 = load i32, i32* %8
%169 = sdiv i32 %168, 2
%170 = sub nsw i32 %167, %169
%171 = load i32, i32* %6
%172 = mul nsw i32 %170, %171
%173 = load i32, i32* %16
%174 = add nsw i32 %172, %173
%175 = load i32, i32* %8
%176 = sdiv i32 %175, 2
%177 = sub nsw i32 %174, %176
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds float, float* %166, i64 %178
%180 = load float, float* %179
store float %180, float* %20
%181 = load float, float* %17
%182 = load float, float* %19
%183 = fadd float %181, %182
%184 = load float, float* %20
%185 = fadd float %183, %184
%186 = load float*, float** %5
%187 = load i32, i32* %15
%188 = load i32, i32* %8
%189 = mul nsw i32 3, %188
%190 = sdiv i32 %189, 2
%191 = sub nsw i32 %187, %190
%192 = load i32, i32* %6
%193 = mul nsw i32 %191, %192
%194 = load i32, i32* %16
%195 = load i32, i32* %8
%196 = sdiv i32 %195, 2
%197 = sub nsw i32 %194, %196
%198 = add nsw i32 %193, %197
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds float, float* %186, i64 %199
%201 = load float, float* %200
%202 = fadd float %185, %201
%203 = fdiv float %202, 4.000000e+00
%204 = call i64 (...) @gaussrand()
%205 = sitofp i64 %204 to float
%206 = load float, float* %7
%207 = call float @llvm.fmuladd.f32(float %205, float %206, float %203)
%208 = load float*, float** %5
%209 = load i32, i32* %15
%210 = load i32, i32* %8
%211 = sub nsw i32 %209, %210
%212 = load i32, i32* %6
%213 = mul nsw i32 %211, %212
%214 = load i32, i32* %16
%215 = load i32, i32* %8
%216 = sdiv i32 %215, 2
%217 = sub nsw i32 %214, %216
%218 = add nsw i32 %213, %217
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds float, float* %208, i64 %219
store float %207, float* %220
%221 = load float, float* %17
%222 = load float, float* %18
%223 = fadd float %221, %222
%224 = load float, float* %20
%225 = fadd float %223, %224
%226 = load float*, float** %5
%227 = load i32, i32* %15
%228 = load i32, i32* %8
%229 = sdiv i32 %228, 2
%230 = sub nsw i32 %227, %229
%231 = load i32, i32* %6
%232 = mul nsw i32 %230, %231
%233 = load i32, i32* %16
%234 = load i32, i32* %8
%235 = mul nsw i32 3, %234
%236 = sdiv i32 %235, 2
%237 = sub nsw i32 %233, %236
%238 = add nsw i32 %232, %237
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds float, float* %226, i64 %239
%241 = load float, float* %240
%242 = fadd float %225, %241
%243 = fdiv float %242, 4.000000e+00
%244 = call i64 (...) @gaussrand()
%245 = sitofp i64 %244 to float
%246 = load float, float* %7
%247 = call float @llvm.fmuladd.f32(float %245, float %246, float %243)
%248 = load float*, float** %5
%249 = load i32, i32* %15
%250 = load i32, i32* %8
%251 = sdiv i32 %250, 2
%252 = sub nsw i32 %249, %251
%253 = load i32, i32* %6
%254 = mul nsw i32 %252, %253
%255 = load i32, i32* %16
%256 = add nsw i32 %254, %255
%257 = load i32, i32* %8
%258 = sub nsw i32 %256, %257
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds float, float* %248, i64 %259
store float %247, float* %260
br label %261
261: ; preds = %130
%262 = load i32, i32* %8
%263 = load i32, i32* %16
%264 = add nsw i32 %263, %262
store i32 %264, i32* %16
br label %126
265: ; preds = %126
br label %266
266: ; preds = %265
%267 = load i32, i32* %8
%268 = load i32, i32* %15
%269 = add nsw i32 %268, %267
store i32 %269, i32* %15
br label %119
270: ; preds = %119
%271 = load float*, float** %5
%272 = load i32, i32* %6
%273 = load float, float* %7
%274 = fdiv float %273, 2.000000e+00
%275 = load i32, i32* %8
%276 = sdiv i32 %275, 2
br label %277
277: ; preds = %270, %23
ret void
}

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