#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 */
typedef int i;

/* Variables and functions */
int /*<<< orphan*/ lin_solve(int, int, int, int /*<<< orphan*/, float *,
                             float *, int, int);
int /*<<< orphan*/ set_bnd(int, int, float *);
void project(int method, int iters, int N, float *u, float *v, float *p,
             float *div) {
  int i, j;
  for (i = 1; i <= N; i++) {
    for (j = 1; j <= N; j++) {
      div[((i) + (N + 2) * (j))] =
          -0.5f *
          (u[((i + 1) + (N + 2) * (j))] - u[((i - 1) + (N + 2) * (j))] +
           v[((i) + (N + 2) * (j + 1))] - v[((i) + (N + 2) * (j - 1))]) /
          N;
      p[((i) + (N + 2) * (j))] = div[((i) + (N + 2) * (j))];
    }
  }
  set_bnd(N, 0, div);
  set_bnd(N, 0, p);
  lin_solve(method, iters, N, 0, p, div, 1, 4);
  for (i = 1; i <= N; i++) {
    for (j = 1; j <= N; j++) {
      u[((i) + (N + 2) * (j))] -=
          0.5f * N *
          (p[((i + 1) + (N + 2) * (j))] - p[((i - 1) + (N + 2) * (j))]);
      v[((i) + (N + 2) * (j))] -=
          0.5f * N *
          (p[((i) + (N + 2) * (j + 1))] - p[((i) + (N + 2) * (j - 1))]);
    }
  }
  set_bnd(N, 1, u);
  set_bnd(N, 2, v);
}


x86 assembly (clang, -O0):
<project>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     126a <project+0x14a>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1257 <project+0x137>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    -0xc(%rbp),%edx
add    $0x2,%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0xc(%rbp),%edx
add    $0x2,%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0xc(%rbp),%edx
add    $0x2,%edx
mov    -0x30(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0xc(%rbp),%edx
add    $0x2,%edx
mov    -0x30(%rbp),%esi
sub    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm1
movss  0xe19(%rip),%xmm0
mulss  %xmm1,%xmm0
cvtsi2ssl -0xc(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0xc(%rbp),%edx
add    $0x2,%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0xc(%rbp),%edx
add    $0x2,%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0xc(%rbp),%edx
add    $0x2,%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    115b <project+0x3b>
jmp    125c <project+0x13c>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1148 <project+0x28>
mov    -0xc(%rbp),%edi
mov    0x10(%rbp),%rdx
xor    %esi,%esi
call   1030 <set_bnd@plt>
mov    -0xc(%rbp),%edi
mov    -0x28(%rbp),%rdx
xor    %esi,%esi
call   1030 <set_bnd@plt>
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    -0xc(%rbp),%edx
mov    -0x28(%rbp),%r8
mov    0x10(%rbp),%r9
xor    %ecx,%ecx
movl   $0x1,(%rsp)
movl   $0x4,0x8(%rsp)
call   1040 <lin_solve@plt>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     13fe <project+0x2de>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     13eb <project+0x2cb>
cvtsi2ssl -0xc(%rbp),%xmm1
movss  0xd20(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    -0xc(%rbp),%edx
add    $0x2,%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0xc(%rbp),%edx
add    $0x2,%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0xc(%rbp),%edx
add    $0x2,%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
cvtsi2ssl -0xc(%rbp),%xmm1
movss  0xc9d(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0xc(%rbp),%edx
add    $0x2,%edx
mov    -0x30(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0xc(%rbp),%edx
add    $0x2,%edx
mov    -0x30(%rbp),%esi
sub    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0xc(%rbp),%edx
add    $0x2,%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12c7 <project+0x1a7>
jmp    13f0 <project+0x2d0>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12b4 <project+0x194>
mov    -0xc(%rbp),%edi
mov    -0x18(%rbp),%rdx
mov    $0x1,%esi
call   1030 <set_bnd@plt>
mov    -0xc(%rbp),%edi
mov    -0x20(%rbp),%rdx
mov    $0x2,%esi
call   1030 <set_bnd@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<project>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %r9,%r12
mov    %r8,%r15
mov    %rcx,%r13
mov    %edx,%ebx
mov    %esi,%r14d
mov    %edi,%eax
mov    0x70(%rsp),%rbp
test   %edx,%edx
mov    %rbx,0x10(%rsp)
mov    %edi,0xc(%rsp)
jle    1333 <project+0x213>
mov    %r14d,0x24(%rsp)
lea    0x2(%rbx),%r14d
cvtsi2ss %ebx,%xmm2
mov    %ebx,%eax
lea    0x1(%rax),%rcx
mov    %rcx,0x30(%rsp)
mov    %rbp,0x28(%rsp)
lea    0xc(%rbp,%rax,4),%r9
lea    0x8(,%rax,4),%rsi
lea    0xc(%r12,%rax,4),%rdi
mov    %rax,0x18(%rsp)
lea    (%r15,%rax,8),%rbp
add    $0x14,%rbp
mov    $0x1,%eax
xor    %r10d,%r10d
movss  0xe60(%rip),%xmm0
mov    %r14d,%r11d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rax,(%rsp)
mov    0x18(%rsp),%rcx
mov    %r10,%rbx
mov    %r11d,%eax
nop
lea    0x2(%rax),%r8d
movslq %r8d,%rdx
movss  0x0(%r13,%rdx,4),%xmm1
cltq
subss  0x0(%r13,%rax,4),%xmm1
addss  0x0(%rbp,%rbx,1),%xmm1
subss  0x4(%r15,%rbx,1),%xmm1
mulss  %xmm0,%xmm1
divss  %xmm2,%xmm1
movss  %xmm1,(%r9,%rbx,1)
movss  %xmm1,(%rdi,%rbx,1)
add    %r14d,%eax
add    %rsi,%rbx
add    $0xffffffffffffffff,%rcx
jne    11c0 <project+0xa0>
mov    (%rsp),%rax
add    $0x1,%rax
add    $0x1,%r11d
add    $0x4,%r10
cmp    0x30(%rsp),%rax
jne    11b0 <project+0x90>
mov    0x10(%rsp),%rbx
mov    %ebx,%edi
xor    %esi,%esi
mov    0x28(%rsp),%rbp
mov    %rbp,%rdx
movss  %xmm2,(%rsp)
call   1030 <set_bnd@plt>
mov    %ebx,%edi
xor    %esi,%esi
mov    %r12,%rdx
call   1030 <set_bnd@plt>
mov    0xc(%rsp),%edi
mov    0x24(%rsp),%esi
mov    %ebx,%edx
xor    %ecx,%ecx
mov    %r12,%r8
mov    %rbp,%r9
push   $0x4
push   $0x1
call   1040 <lin_solve@plt>
movss  0x10(%rsp),%xmm1
add    $0x10,%rsp
test   %ebx,%ebx
jle    1369 <project+0x249>
mulss  0xd8a(%rip),%xmm1
mov    0x10(%rsp),%rax
add    $0x2,%eax
mov    0x18(%rsp),%rcx
lea    0x1(%rcx),%rdx
mov    %rdx,(%rsp)
lea    0xc(%r13,%rcx,4),%rdx
lea    0x8(,%rcx,4),%rsi
lea    (%r15,%rcx,4),%rdi
add    $0xc,%rdi
lea    (%r12,%rcx,8),%rcx
add    $0x14,%rcx
mov    $0x1,%r9d
xor    %r14d,%r14d
mov    %eax,%r11d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x18(%rsp),%rbp
mov    %r14,%r10
mov    %r11d,%r8d
nopl   0x0(%rax,%rax,1)
lea    0x2(%r8),%ebx
movslq %ebx,%rbx
movss  (%r12,%rbx,4),%xmm0
movslq %r8d,%r8
subss  (%r12,%r8,4),%xmm0
mulss  %xmm1,%xmm0
addss  (%rdx,%r10,1),%xmm0
movss  %xmm0,(%rdx,%r10,1)
movss  (%rcx,%r10,1),%xmm0
subss  0x4(%r12,%r10,1),%xmm0
mulss  %xmm1,%xmm0
addss  (%rdi,%r10,1),%xmm0
movss  %xmm0,(%rdi,%r10,1)
add    %eax,%r8d
add    %rsi,%r10
add    $0xffffffffffffffff,%rbp
jne    12d0 <project+0x1b0>
add    $0x1,%r9
add    $0x1,%r11d
add    $0x4,%r14
cmp    (%rsp),%r9
jne    12c0 <project+0x1a0>
jmp    1369 <project+0x249>
mov    %ebx,%edi
xor    %esi,%esi
mov    %rbp,%rdx
call   1030 <set_bnd@plt>
mov    %ebx,%edi
xor    %esi,%esi
mov    %r12,%rdx
call   1030 <set_bnd@plt>
mov    0xc(%rsp),%edi
mov    %r14d,%esi
mov    %ebx,%edx
xor    %ecx,%ecx
mov    %r12,%r8
mov    %rbp,%r9
push   $0x4
push   $0x1
call   1040 <lin_solve@plt>
add    $0x10,%rsp
mov    0x10(%rsp),%rbx
mov    %ebx,%edi
mov    $0x1,%esi
mov    %r13,%rdx
call   1030 <set_bnd@plt>
mov    %ebx,%edi
mov    $0x2,%esi
mov    %r15,%rdx
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <set_bnd@plt>

LLVM IR (-O0):
define void @project(i32 %0, i32 %1, i32 %2, float* %3, float* %4, float* %5, float* %6) {
%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
store i32 %0, i32* %8
store i32 %1, i32* %9
store i32 %2, i32* %10
store float* %3, float** %11
store float* %4, float** %12
store float* %5, float** %13
store float* %6, float** %14
store i32 1, i32* %15
br label %17
17: ; preds = %110, %7
%18 = load i32, i32* %15
%19 = load i32, i32* %10
%20 = icmp sle i32 %18, %19
br i1 %20, label %21, label %113
21: ; preds = %17
store i32 1, i32* %16
br label %22
22: ; preds = %106, %21
%23 = load i32, i32* %16
%24 = load i32, i32* %10
%25 = icmp sle i32 %23, %24
br i1 %25, label %26, label %109
26: ; preds = %22
%27 = load float*, float** %11
%28 = load i32, i32* %15
%29 = add nsw i32 %28, 1
%30 = load i32, i32* %10
%31 = add nsw i32 %30, 2
%32 = load i32, i32* %16
%33 = mul nsw i32 %31, %32
%34 = add nsw i32 %29, %33
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds float, float* %27, i64 %35
%37 = load float, float* %36
%38 = load float*, float** %11
%39 = load i32, i32* %15
%40 = sub nsw i32 %39, 1
%41 = load i32, i32* %10
%42 = add nsw i32 %41, 2
%43 = load i32, i32* %16
%44 = mul nsw i32 %42, %43
%45 = add nsw i32 %40, %44
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds float, float* %38, i64 %46
%48 = load float, float* %47
%49 = fsub float %37, %48
%50 = load float*, float** %12
%51 = load i32, i32* %15
%52 = load i32, i32* %10
%53 = add nsw i32 %52, 2
%54 = load i32, i32* %16
%55 = add nsw i32 %54, 1
%56 = mul nsw i32 %53, %55
%57 = add nsw i32 %51, %56
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds float, float* %50, i64 %58
%60 = load float, float* %59
%61 = fadd float %49, %60
%62 = load float*, float** %12
%63 = load i32, i32* %15
%64 = load i32, i32* %10
%65 = add nsw i32 %64, 2
%66 = load i32, i32* %16
%67 = sub nsw i32 %66, 1
%68 = mul nsw i32 %65, %67
%69 = add nsw i32 %63, %68
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds float, float* %62, i64 %70
%72 = load float, float* %71
%73 = fsub float %61, %72
%74 = fmul float -5.000000e-01, %73
%75 = load i32, i32* %10
%76 = sitofp i32 %75 to float
%77 = fdiv float %74, %76
%78 = load float*, float** %14
%79 = load i32, i32* %15
%80 = load i32, i32* %10
%81 = add nsw i32 %80, 2
%82 = load i32, i32* %16
%83 = mul nsw i32 %81, %82
%84 = add nsw i32 %79, %83
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds float, float* %78, i64 %85
store float %77, float* %86
%87 = load float*, float** %14
%88 = load i32, i32* %15
%89 = load i32, i32* %10
%90 = add nsw i32 %89, 2
%91 = load i32, i32* %16
%92 = mul nsw i32 %90, %91
%93 = add nsw i32 %88, %92
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds float, float* %87, i64 %94
%96 = load float, float* %95
%97 = load float*, float** %13
%98 = load i32, i32* %15
%99 = load i32, i32* %10
%100 = add nsw i32 %99, 2
%101 = load i32, i32* %16
%102 = mul nsw i32 %100, %101
%103 = add nsw i32 %98, %102
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds float, float* %97, i64 %104
store float %96, float* %105
br label %106
106: ; preds = %26
%107 = load i32, i32* %16
%108 = add nsw i32 %107, 1
store i32 %108, i32* %16
br label %22
109: ; preds = %22
br label %110
110: ; preds = %109
%111 = load i32, i32* %15
%112 = add nsw i32 %111, 1
store i32 %112, i32* %15
br label %17
113: ; preds = %17
%114 = load i32, i32* %10
%115 = load float*, float** %14
%116 = call i32 @set_bnd(i32 %114, i32 0, float* %115)
%117 = load i32, i32* %10
%118 = load float*, float** %13
%119 = call i32 @set_bnd(i32 %117, i32 0, float* %118)
%120 = load i32, i32* %8
%121 = load i32, i32* %9
%122 = load i32, i32* %10
%123 = load float*, float** %13
%124 = load float*, float** %14
%125 = call i32 @lin_solve(i32 %120, i32 %121, i32 %122, i32 0, float* %123, float* %124, i32 1, i32 4)
store i32 1, i32* %15
br label %126
126: ; preds = %216, %113
%127 = load i32, i32* %15
%128 = load i32, i32* %10
%129 = icmp sle i32 %127, %128
br i1 %129, label %130, label %219
130: ; preds = %126
store i32 1, i32* %16
br label %131
131: ; preds = %212, %130
%132 = load i32, i32* %16
%133 = load i32, i32* %10
%134 = icmp sle i32 %132, %133
br i1 %134, label %135, label %215
135: ; preds = %131
%136 = load i32, i32* %10
%137 = sitofp i32 %136 to float
%138 = fmul float 5.000000e-01, %137
%139 = load float*, float** %13
%140 = load i32, i32* %15
%141 = add nsw i32 %140, 1
%142 = load i32, i32* %10
%143 = add nsw i32 %142, 2
%144 = load i32, i32* %16
%145 = mul nsw i32 %143, %144
%146 = add nsw i32 %141, %145
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds float, float* %139, i64 %147
%149 = load float, float* %148
%150 = load float*, float** %13
%151 = load i32, i32* %15
%152 = sub nsw i32 %151, 1
%153 = load i32, i32* %10
%154 = add nsw i32 %153, 2
%155 = load i32, i32* %16
%156 = mul nsw i32 %154, %155
%157 = add nsw i32 %152, %156
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds float, float* %150, i64 %158
%160 = load float, float* %159
%161 = fsub float %149, %160
%162 = load float*, float** %11
%163 = load i32, i32* %15
%164 = load i32, i32* %10
%165 = add nsw i32 %164, 2
%166 = load i32, i32* %16
%167 = mul nsw i32 %165, %166
%168 = add nsw i32 %163, %167
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds float, float* %162, i64 %169
%171 = load float, float* %170
%172 = fneg float %138
%173 = call float @llvm.fmuladd.f32(float %172, float %161, float %171)
store float %173, float* %170
%174 = load i32, i32* %10
%175 = sitofp i32 %174 to float
%176 = fmul float 5.000000e-01, %175
%177 = load float*, float** %13
%178 = load i32, i32* %15
%179 = load i32, i32* %10
%180 = add nsw i32 %179, 2
%181 = load i32, i32* %16
%182 = add nsw i32 %181, 1
%183 = mul nsw i32 %180, %182
%184 = add nsw i32 %178, %183
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds float, float* %177, i64 %185
%187 = load float, float* %186
%188 = load float*, float** %13
%189 = load i32, i32* %15
%190 = load i32, i32* %10
%191 = add nsw i32 %190, 2
%192 = load i32, i32* %16
%193 = sub nsw i32 %192, 1
%194 = mul nsw i32 %191, %193
%195 = add nsw i32 %189, %194
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds float, float* %188, i64 %196
%198 = load float, float* %197
%199 = fsub float %187, %198
%200 = load float*, float** %12
%201 = load i32, i32* %15
%202 = load i32, i32* %10
%203 = add nsw i32 %202, 2
%204 = load i32, i32* %16
%205 = mul nsw i32 %203, %204
%206 = add nsw i32 %201, %205
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds float, float* %200, i64 %207
%209 = load float, float* %208
%210 = fneg float %176
%211 = call float @llvm.fmuladd.f32(float %210, float %199, float %209)
store float %211, float* %208
br label %212
212: ; preds = %135
%213 = load i32, i32* %16
%214 = add nsw i32 %213, 1
store i32 %214, i32* %16
br label %131
215: ; preds = %131
br label %216
216: ; preds = %215
%217 = load i32, i32* %15
%218 = add nsw i32 %217, 1
store i32 %218, i32* %15
br label %126
219: ; preds = %126
%220 = load i32, i32* %10
%221 = load float*, float** %11
%222 = call i32 @set_bnd(i32 %220, i32 1, float* %221)
%223 = load i32, i32* %10
%224 = load float*, float** %12
%225 = call i32 @set_bnd(i32 %223, i32 2, float* %224)
ret void
}

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