#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 count_y;
typedef int count_x;

/* Variables and functions */
int /*<<< orphan*/ boundary_condition(int, float *, int);
int /*<<< orphan*/ lin_solve(int, int /*<<< orphan*/, float *, float *, int,
                             int);
void project(int N, float *velocity_u, float *velocity_v, float *velocity_w,
             float *p, float *div) {
  int count_x;
  int count_y;
  int count_z;
  for (count_x = 1; count_x <= N; count_x++) {
    for (count_y = 1; count_y <= N; count_y++) {
      for (count_z = 1; count_z <= N; count_z++) {
        div[((count_x) + (N + 2) * (count_y) + (N + 2) * (N + 2) * (count_z))] =
            (float)(-1.0 / 3.0 *
                    ((velocity_u[((count_x + 1) + (N + 2) * (count_y) +
                                  (N + 2) * (N + 2) * (count_z))] -
                      velocity_u[((count_x - 1) + (N + 2) * (count_y) +
                                  (N + 2) * (N + 2) * (count_z))]) /
                         N +
                     (velocity_v[((count_x) + (N + 2) * (count_y + 1) +
                                  (N + 2) * (N + 2) * (count_z))] -
                      velocity_v[((count_x) + (N + 2) * (count_y - 1) +
                                  (N + 2) * (N + 2) * (count_z))]) /
                         N +
                     (velocity_w[((count_x) + (N + 2) * (count_y) +
                                  (N + 2) * (N + 2) * (count_z + 1))] -
                      velocity_w[((count_x) + (N + 2) * (count_y) +
                                  (N + 2) * (N + 2) * (count_z - 1))]) /
                         N));
        p[((count_x) + (N + 2) * (count_y) + (N + 2) * (N + 2) * (count_z))] =
            0;
      }
    }
  }
  boundary_condition(N, div, 0);
  boundary_condition(N, p, 0);
  lin_solve(N, 0, p, div, 1, 6);
  for (count_x = 1; count_x <= N; count_x++) {
    for (count_y = 1; count_y <= N; count_y++) {
      for (count_z = 1; count_z <= N; count_z++) {
        velocity_u[((count_x) + (N + 2) * (count_y) +
                    (N + 2) * (N + 2) * (count_z))] -=
            0.5f * N *
            (p[((count_x + 1) + (N + 2) * (count_y) +
                (N + 2) * (N + 2) * (count_z))] -
             p[((count_x - 1) + (N + 2) * (count_y) +
                (N + 2) * (N + 2) * (count_z))]);
        velocity_v[((count_x) + (N + 2) * (count_y) +
                    (N + 2) * (N + 2) * (count_z))] -=
            0.5f * N *
            (p[((count_x) + (N + 2) * (count_y + 1) +
                (N + 2) * (N + 2) * (count_z))] -
             p[((count_x) + (N + 2) * (count_y - 1) +
                (N + 2) * (N + 2) * (count_z))]);
        velocity_w[((count_x) + (N + 2) * (count_y) +
                    (N + 2) * (N + 2) * (count_z))] -=
            0.5f * N *
            (p[((count_x) + (N + 2) * (count_y) +
                (N + 2) * (N + 2) * (count_z + 1))] -
             p[((count_x) + (N + 2) * (count_y) +
                (N + 2) * (N + 2) * (count_z - 1))]);
      }
    }
  }
  boundary_condition(N, velocity_u, 1);
  boundary_condition(N, velocity_v, 2);
  boundary_condition(N, velocity_w, 3);
}


x86 assembly (clang, -O0):
<project>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1380 <project+0x260>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     136d <project+0x24d>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     135a <project+0x23a>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x4(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x38(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x38(%rbp),%esi
sub    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x4(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
mov    -0x3c(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
mov    -0x3c(%rbp),%esi
sub    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x4(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd27(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    116c <project+0x4c>
jmp    135f <project+0x23f>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1159 <project+0x39>
jmp    1372 <project+0x252>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1146 <project+0x26>
mov    -0x4(%rbp),%edi
mov    -0x30(%rbp),%rsi
xor    %edx,%edx
call   1030 <boundary_condition@plt>
mov    -0x4(%rbp),%edi
mov    -0x28(%rbp),%rsi
xor    %edx,%edx
call   1030 <boundary_condition@plt>
mov    -0x4(%rbp),%edi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
xor    %esi,%esi
mov    $0x1,%r8d
mov    $0x6,%r9d
call   1040 <lin_solve@plt>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1675 <project+0x555>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1662 <project+0x542>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     164f <project+0x52f>
cvtsi2ssl -0x4(%rbp),%xmm1
movss  0xc00(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x3c(%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 -0x4(%rbp),%xmm1
movss  0xb3e(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x38(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x38(%rbp),%esi
sub    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x3c(%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 -0x4(%rbp),%xmm1
movss  0xa78(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
mov    -0x3c(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
mov    -0x3c(%rbp),%esi
sub    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x3c(%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    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13e7 <project+0x2c7>
jmp    1654 <project+0x534>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13d4 <project+0x2b4>
jmp    1667 <project+0x547>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13c1 <project+0x2a1>
mov    -0x4(%rbp),%edi
mov    -0x10(%rbp),%rsi
mov    $0x1,%edx
call   1030 <boundary_condition@plt>
mov    -0x4(%rbp),%edi
mov    -0x18(%rbp),%rsi
mov    $0x2,%edx
call   1030 <boundary_condition@plt>
mov    -0x4(%rbp),%edi
mov    -0x20(%rbp),%rsi
mov    $0x3,%edx
call   1030 <boundary_condition@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    $0x88,%rsp
mov    %r9,%r12
mov    %r8,%r14
mov    %rdx,0x68(%rsp)
mov    %edi,%ebp
test   %edi,%edi
mov    %rbp,0x28(%rsp)
mov    %rcx,0x78(%rsp)
mov    %rsi,0x50(%rsp)
jle    151f <project+0x3ff>
lea    0x2(%rbp),%eax
mov    %eax,0x14(%rsp)
mov    %eax,%r15d
imul   %r15d,%r15d
cvtsi2ss %ebp,%xmm3
mov    %ebp,%edi
lea    0x1(%rdi),%rax
mov    %rax,0x20(%rsp)
lea    0x5(%r15,%rbp,2),%ebx
lea    0x0(%rbp,%r15,1),%r13d
lea    0x2(%r15,%rdi,1),%rax
mov    %r12,0x30(%rsp)
lea    0x4(%r12,%rax,4),%rbp
lea    0x8(,%rdi,4),%rsi
mov    %rsi,0x18(%rsp)
mov    %rcx,%rsi
mov    %r14,0x48(%rsp)
lea    0x4(%r14,%rax,4),%rcx
lea    0xc(%rsi,%rdi,4),%rdx
mov    %rdi,0x58(%rsp)
lea    0x2(%rdi,%r15,2),%rax
lea    0x0(,%r15,4),%rdi
lea    (%rsi,%rax,4),%r12
add    $0x4,%r12
mov    $0x1,%r8d
xor    %r14d,%r14d
movsd  0xe2b(%rip),%xmm0
xor    %eax,%eax
mov    0x50(%rsp),%r10
nopl   0x0(%rax)
mov    %r8,0x40(%rsp)
mov    %r14,0x38(%rsp)
mov    %eax,(%rsp)
mov    $0x1,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rsi
mov    %rsi,0x60(%rsp)
mov    0x58(%rsp),%r9
mov    %r14,0x8(%rsp)
mov    %eax,0x4(%rsp)
mov    %eax,%r8d
nopw   0x0(%rax,%rax,1)
lea    (%r8,%r13,1),%r11d
add    $0x4,%r11d
movslq %r11d,%rsi
mov    %rdi,%r11
mov    0x68(%rsp),%rdi
movss  (%r10,%rsi,4),%xmm1
lea    0x2(%r13,%r8,1),%esi
movslq %esi,%rsi
subss  (%r10,%rsi,4),%xmm1
divss  %xmm3,%xmm1
lea    (%rbx,%r8,1),%esi
movslq %esi,%rsi
movss  (%rdi,%rsi,4),%xmm2
lea    0x1(%r15,%r8,1),%esi
mov    %r8d,%eax
movslq %esi,%rsi
subss  (%rdi,%rsi,4),%xmm2
mov    %r11,%rdi
add    %r15d,%eax
divss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  (%r12,%r14,1),%xmm1
subss  (%rdx,%r14,1),%xmm1
divss  %xmm3,%xmm1
addss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,0x0(%rbp,%r14,1)
movl   $0x0,(%rcx,%r14,1)
add    %r11,%r14
mov    %eax,%r8d
add    $0xffffffffffffffff,%r9
jne    1220 <project+0x100>
mov    0x4(%rsp),%eax
add    0x14(%rsp),%eax
mov    0x8(%rsp),%r14
add    0x18(%rsp),%r14
mov    0x60(%rsp),%rsi
cmp    0x20(%rsp),%rsi
jne    1200 <project+0xe0>
mov    0x40(%rsp),%r8
add    $0x1,%r8
mov    (%rsp),%eax
add    $0x1,%eax
mov    0x38(%rsp),%r14
add    $0x4,%r14
cmp    0x20(%rsp),%r8
jne    11e0 <project+0xc0>
mov    0x28(%rsp),%rbx
mov    %ebx,%edi
mov    0x30(%rsp),%rbp
mov    %rbp,%rsi
xor    %edx,%edx
movss  %xmm3,0x8(%rsp)
call   1030 <boundary_condition@plt>
mov    %ebx,%edi
mov    0x48(%rsp),%r14
mov    %r14,%rsi
xor    %edx,%edx
call   1030 <boundary_condition@plt>
mov    %ebx,%edi
xor    %esi,%esi
mov    %r14,%rdx
mov    %rbp,%rcx
mov    $0x1,%r8d
mov    $0x6,%r9d
call   1040 <lin_solve@plt>
movss  0x8(%rsp),%xmm1
test   %ebx,%ebx
jle    1552 <project+0x432>
mulss  0xcb1(%rip),%xmm1
mov    0x58(%rsp),%r8
lea    0x1(%r8),%rax
mov    %rax,0x18(%rsp)
lea    0x1(%r15),%r10d
mov    0x28(%rsp),%rcx
lea    0x5(%r15,%rcx,2),%r11d
lea    0x2(%rcx,%r15,1),%eax
lea    0x2(%r15,%r8,1),%rsi
mov    0x50(%rsp),%rcx
lea    0x4(%rcx,%rsi,4),%rdi
lea    0x8(,%r8,4),%rcx
mov    %rcx,0x40(%rsp)
mov    0x68(%rsp),%rcx
lea    0x4(%rcx,%rsi,4),%rdx
mov    0x78(%rsp),%rcx
lea    0x4(%rcx,%rsi,4),%rsi
mov    0x48(%rsp),%rcx
lea    0xc(%rcx,%r8,4),%r12
lea    0x2(%r8,%r15,2),%r9
lea    0x0(,%r15,4),%r8
lea    (%rcx,%r9,4),%r9
add    $0x4,%r9
mov    $0x1,%ecx
xor    %ebx,%ebx
mov    0x48(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rcx,0x30(%rsp)
mov    %rbx,0x80(%rsp)
mov    %eax,(%rsp)
mov    %r11d,0x38(%rsp)
mov    %r10d,0x74(%rsp)
mov    %r10d,%ecx
mov    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rbp
mov    %rbp,0x20(%rsp)
mov    0x58(%rsp),%r14
mov    %rbx,0x8(%rsp)
mov    %eax,0x4(%rsp)
mov    %eax,%r10d
mov    %r11d,0x60(%rsp)
mov    %ecx,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x2(%r10),%eax
cltq
movss  0x0(%r13,%rax,4),%xmm0
movslq %r10d,%r10
subss  0x0(%r13,%r10,4),%xmm0
mulss  %xmm1,%xmm0
addss  (%rdi,%rbx,1),%xmm0
movss  %xmm0,(%rdi,%rbx,1)
movslq %r11d,%r11
movss  0x0(%r13,%r11,4),%xmm0
movslq %ecx,%rcx
subss  0x0(%r13,%rcx,4),%xmm0
mulss  %xmm1,%xmm0
addss  (%rdx,%rbx,1),%xmm0
movss  %xmm0,(%rdx,%rbx,1)
movss  (%r9,%rbx,1),%xmm0
subss  (%r12,%rbx,1),%xmm0
mulss  %xmm1,%xmm0
addss  (%rsi,%rbx,1),%xmm0
movss  %xmm0,(%rsi,%rbx,1)
add    %r15d,%ecx
add    %r15d,%r11d
add    %r15d,%r10d
add    %r8,%rbx
add    $0xffffffffffffffff,%r14
jne    1440 <project+0x320>
mov    0x14(%rsp),%eax
mov    %ebp,%ecx
add    %eax,%ecx
mov    0x60(%rsp),%r11d
add    %eax,%r11d
mov    0x4(%rsp),%ebp
add    %eax,%ebp
mov    %ebp,%eax
mov    0x8(%rsp),%rbx
add    0x40(%rsp),%rbx
mov    0x20(%rsp),%rbp
cmp    0x18(%rsp),%rbp
jne    1410 <project+0x2f0>
mov    0x30(%rsp),%rcx
add    $0x1,%rcx
mov    0x74(%rsp),%r10d
add    $0x1,%r10d
mov    0x38(%rsp),%r11d
add    $0x1,%r11d
mov    (%rsp),%eax
add    $0x1,%eax
mov    0x80(%rsp),%rbx
add    $0x4,%rbx
cmp    0x18(%rsp),%rcx
jne    13e0 <project+0x2c0>
jmp    1552 <project+0x432>
mov    %ebp,%edi
mov    %r12,%rsi
xor    %edx,%edx
call   1030 <boundary_condition@plt>
mov    %ebp,%edi
mov    %r14,%rsi
xor    %edx,%edx
call   1030 <boundary_condition@plt>
mov    %ebp,%edi
xor    %esi,%esi
mov    %r14,%rdx
mov    %r12,%rcx
mov    $0x1,%r8d
mov    $0x6,%r9d
call   1040 <lin_solve@plt>
mov    0x28(%rsp),%rbx
mov    %ebx,%edi
mov    0x50(%rsp),%rsi
mov    $0x1,%edx
call   1030 <boundary_condition@plt>
mov    %ebx,%edi
mov    0x68(%rsp),%rsi
mov    $0x2,%edx
call   1030 <boundary_condition@plt>
mov    %ebx,%edi
mov    0x78(%rsp),%rsi
mov    $0x3,%edx
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <boundary_condition@plt>

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

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