#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 */
float pow(float, double);
void iteration(float **u, float **v, float **u_past, float **v_past,
               int puntos_x, int puntos_y, float dx, float dy, float dt,
               float nu) {
  int i;
  int j;
  for (i = 1; i < (puntos_x - 1); i++) {
    for (j = 1; j < puntos_y - 1; j++) {
      u[i][j] = u_past[i][j] -
                (dt / dx) * u_past[i][j] * (u_past[i][j] - u_past[i - 1][j]) -
                (dt / dy) * v_past[i][j] * (u_past[i][j] - u_past[i][j - 1]) +
                nu * dt / (pow(dx, 2.0)) *
                    (u_past[i + 1][j] - 2 * u_past[i][j] + u_past[i - 1][j]) +
                nu * dt / (pow(dy, 2.0)) *
                    (u_past[i][j + 1] - 2 * u_past[i][j] + u_past[i][j + 1]);
      v[i][j] = v_past[i][j] -
                (dt / dx) * u_past[i][j] * (v_past[i][j] - v_past[i - 1][j]) -
                (dt / dy) * v_past[i][j] * (v_past[i][j] - v_past[i][j - 1]) +
                nu * dt / (pow(dx, 2.0)) *
                    (v_past[i + 1][j] - 2 * v_past[i][j] + v_past[i - 1][j]) +
                nu * dt / (pow(dy, 2.0)) *
                    (v_past[i][j + 1] - 2 * v_past[i][j] + v_past[i][j + 1]);
    }
  }
}


x86 assembly (clang, -O0):
<iteration>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
movss  %xmm0,-0x2c(%rbp)
movss  %xmm1,-0x30(%rbp)
movss  %xmm2,-0x34(%rbp)
movss  %xmm3,-0x38(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    15b5 <iteration+0x4a5>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    15a2 <iteration+0x492>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x34(%rbp),%xmm1
divss  -0x2c(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x34(%rbp),%xmm0
divss  -0x30(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x38(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x2c(%rbp),%xmm0
movsd  0xd90(%rip),%xmm1
call   1030 <pow@plt>
movss  -0x60(%rbp),%xmm1
movaps %xmm0,%xmm2
movss  -0x5c(%rbp),%xmm0
divss  %xmm2,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm3
subss  %xmm3,%xmm2
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x38(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x30(%rbp),%xmm0
movsd  0xd00(%rip),%xmm1
call   1030 <pow@plt>
movss  -0x58(%rbp),%xmm1
movaps %xmm0,%xmm2
movss  -0x54(%rbp),%xmm0
divss  %xmm2,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm3
subss  %xmm3,%xmm2
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x34(%rbp),%xmm1
divss  -0x2c(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x34(%rbp),%xmm0
divss  -0x30(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x38(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x2c(%rbp),%xmm0
movsd  0xb80(%rip),%xmm1
call   1030 <pow@plt>
movss  -0x50(%rbp),%xmm1
movaps %xmm0,%xmm2
movss  -0x4c(%rbp),%xmm0
divss  %xmm2,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm3
subss  %xmm3,%xmm2
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x38(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x30(%rbp),%xmm0
movsd  0xaf0(%rip),%xmm1
call   1030 <pow@plt>
movss  -0x48(%rbp),%xmm1
movaps %xmm0,%xmm2
movss  -0x44(%rbp),%xmm0
divss  %xmm2,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm3
subss  %xmm3,%xmm2
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1163 <iteration+0x53>
jmp    15a7 <iteration+0x497>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    114b <iteration+0x3b>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<iteration>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
cmp    $0x3,%r8d
jl     13da <iteration+0x2ca>
mov    %rcx,%rbx
mov    %rdx,%r12
mov    %rsi,%rbp
add    $0xffffffff,%r8d
lea    -0x1(%r9),%eax
movaps 0xec0(%rip),%xmm4
xorps  %xmm2,%xmm4
movaps %xmm4,%xmm5
divss  %xmm0,%xmm5
divss  %xmm1,%xmm4
mulss  %xmm2,%xmm3
lea    -0x4(,%rax,4),%r14
ff
mov    $0x1,%r15d
mov    %r9,0x18(%rsp)
mov    %r8,0x10(%rsp)
movaps %xmm4,0x40(%rsp)
movaps %xmm5,0x30(%rsp)
mov    %rdi,0x28(%rsp)
movss  %xmm3,0x4(%rsp)
movss  %xmm1,0xc(%rsp)
movss  %xmm0,0x8(%rsp)
jmp    11a0 <iteration+0x90>
nopl   (%rax)
add    $0x1,%r15
mov    %r15,%rax
cmp    %r8,%rax
je     13da <iteration+0x2ca>
cmp    $0x2,%r9d
jle    1190 <iteration+0x80>
lea    0x1(%r15),%rax
mov    %rax,0x20(%rsp)
mov    (%rbx,%r15,8),%rax
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
mov    -0x8(%r12,%r15,8),%rcx
mov    (%r12,%r15,8),%rdx
movss  0x4(%rdx,%r13,1),%xmm0
movaps %xmm0,%xmm1
subss  0x4(%rcx,%r13,1),%xmm1
movaps %xmm5,%xmm2
mulss  %xmm0,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm0,%xmm2
subss  (%rdx,%r13,1),%xmm0
movss  0x4(%rax,%r13,1),%xmm1
mulss  %xmm4,%xmm1
mulss  %xmm0,%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,(%rsp)
movss  0x8(%rsp),%xmm0
movsd  0xdfb(%rip),%xmm1
call   1030 <pow@plt>
movss  0x4(%rsp),%xmm1
divss  %xmm0,%xmm1
mov    0x8(%r12,%r15,8),%rax
movss  0x4(%rax,%r13,1),%xmm2
mov    -0x8(%r12,%r15,8),%rax
mov    (%r12,%r15,8),%rcx
movss  0x4(%rcx,%r13,1),%xmm0
addss  %xmm0,%xmm0
subss  %xmm0,%xmm2
addss  0x4(%rax,%r13,1),%xmm2
mulss  %xmm1,%xmm2
addss  (%rsp),%xmm2
movss  %xmm2,(%rsp)
movss  0xc(%rsp),%xmm0
movsd  0xda5(%rip),%xmm1
call   1030 <pow@plt>
movss  0x4(%rsp),%xmm1
divss  %xmm0,%xmm1
mov    (%r12,%r15,8),%rax
movss  0x4(%rax,%r13,1),%xmm0
movss  0x8(%rax,%r13,1),%xmm2
addss  %xmm0,%xmm0
movaps %xmm2,%xmm3
subss  %xmm0,%xmm3
addss  %xmm2,%xmm3
mulss  %xmm1,%xmm3
addss  (%rsp),%xmm3
mov    0x28(%rsp),%rcx
mov    (%rcx,%r15,8),%rcx
movss  %xmm3,0x4(%rcx,%r13,1)
mov    -0x8(%rbx,%r15,8),%rcx
mov    (%rbx,%r15,8),%rdx
movss  0x4(%rdx,%r13,1),%xmm2
movaps %xmm2,%xmm0
subss  0x4(%rcx,%r13,1),%xmm0
movss  0x4(%rax,%r13,1),%xmm1
mulss  0x30(%rsp),%xmm1
mulss  %xmm0,%xmm1
addss  %xmm2,%xmm1
movaps 0x40(%rsp),%xmm0
mulss  %xmm2,%xmm0
subss  (%rdx,%r13,1),%xmm2
mulss  %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rsp)
movss  0x8(%rsp),%xmm0
movsd  0xd03(%rip),%xmm1
call   1030 <pow@plt>
movss  0x4(%rsp),%xmm1
divss  %xmm0,%xmm1
mov    0x8(%rbx,%r15,8),%rax
movss  0x4(%rax,%r13,1),%xmm2
mov    -0x8(%rbx,%r15,8),%rax
mov    (%rbx,%r15,8),%rcx
movss  0x4(%rcx,%r13,1),%xmm0
addss  %xmm0,%xmm0
subss  %xmm0,%xmm2
addss  0x4(%rax,%r13,1),%xmm2
mulss  %xmm1,%xmm2
addss  (%rsp),%xmm2
movss  %xmm2,(%rsp)
movss  0xc(%rsp),%xmm0
movsd  0xcad(%rip),%xmm1
call   1030 <pow@plt>
movaps 0x30(%rsp),%xmm5
movaps 0x40(%rsp),%xmm4
movss  0x4(%rsp),%xmm1
divss  %xmm0,%xmm1
mov    (%rbx,%r15,8),%rax
movss  0x4(%rax,%r13,1),%xmm0
movss  0x8(%rax,%r13,1),%xmm2
addss  %xmm0,%xmm0
movaps %xmm2,%xmm3
subss  %xmm0,%xmm3
addss  %xmm2,%xmm3
mulss  %xmm1,%xmm3
addss  (%rsp),%xmm3
mov    0x0(%rbp,%r15,8),%rcx
movss  %xmm3,0x4(%rcx,%r13,1)
add    $0x4,%r13
cmp    %r13,%r14
jne    11c0 <iteration+0xb0>
mov    0x20(%rsp),%rax
mov    %rax,%r15
mov    0x18(%rsp),%r9
mov    0x10(%rsp),%r8
cmp    %r8,%rax
jne    11a0 <iteration+0x90>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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