#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 j1;
typedef int j0;
typedef int i1;
typedef int i0;
typedef int count_y;
typedef int count_x;

/* Variables and functions */
int /*<<< orphan*/ boundary_condition(int, float *, int);
void advect(int N, int b, float *density, float *density_prev,
            float *velocity_u, float *velocity_v, float *velocity_w, float dt) {
  int count_x;
  int count_y;
  int count_z;
  int i0;
  int j0;
  int k0;
  int i1;
  int j1;
  int k1;
  float x;
  float y;
  float z;
  float s0;
  float t0;
  float s1;
  float t1;
  float u1;
  float u0;
  float dh;
  dh = dt * N;
  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++) {
        x = count_x - dh * velocity_u[((count_x) + (N + 2) * (count_y) +
                                       (N + 2) * (N + 2) * (count_z))];
        y = count_y - dh * velocity_v[((count_x) + (N + 2) * (count_y) +
                                       (N + 2) * (N + 2) * (count_z))];
        z = count_z - dh * velocity_w[((count_x) + (N + 2) * (count_y) +
                                       (N + 2) * (N + 2) * (count_z))];
        if (x < 0.5) {
          x = 0.5;
        }
        if (x > N + 0.5) {
          x = (float)(N + 0.5);
        }
        if (y < 0.5) {
          y = 0.5;
        }
        if (y > N + 0.5) {
          y = (float)(N + 0.5);
        }
        if (z < 0.5) {
          z = 0.5;
        }
        if (z > N + 0.5) {
          z = (float)(N + 0.5);
        }
        i0 = (int)x;
        i1 = i0 + 1;
        j0 = (int)y;
        j1 = j0 + 1;
        k0 = (int)z;
        k1 = k0 + 1;
        s1 = x - i0;
        s0 = 1 - s1;
        t1 = y - j0;
        t0 = 1 - t1;
        u1 = z - k0;
        u0 = 1 - u1;
        density[((count_x) + (N + 2) * (count_y) +
                 (N + 2) * (N + 2) * (count_z))] =
            s0 * (t0 * u0 *
                      density_prev[((i0) + (N + 2) * (j0) +
                                    (N + 2) * (N + 2) * (k0))] +
                  t1 * u0 *
                      density_prev[((i0) + (N + 2) * (j1) +
                                    (N + 2) * (N + 2) * (k0))] +
                  t0 * u1 *
                      density_prev[((i0) + (N + 2) * (j0) +
                                    (N + 2) * (N + 2) * (k1))] +
                  t1 * u1 *
                      density_prev[((i0) + (N + 2) * (j1) +
                                    (N + 2) * (N + 2) * (k1))]) +
            s1 * (t0 * u0 *
                      density_prev[((i1) + (N + 2) * (j0) +
                                    (N + 2) * (N + 2) * (k0))] +
                  t1 * u0 *
                      density_prev[((i1) + (N + 2) * (j1) +
                                    (N + 2) * (N + 2) * (k0))] +
                  t0 * u1 *
                      density_prev[((i1) + (N + 2) * (j0) +
                                    (N + 2) * (N + 2) * (k1))] +
                  t1 * u1 *
                      density_prev[((i1) + (N + 2) * (j1) +
                                    (N + 2) * (N + 2) * (k1))]);
      }
    }
  }
  boundary_condition(N, density, b);
}


x86 assembly (clang, -O0):
<advect>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movss  %xmm0,-0x2c(%rbp)
movss  -0x2c(%rbp),%xmm0
cvtsi2ssl -0x4(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     16d0 <advect+0x5c0>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     16bd <advect+0x5ad>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     16aa <advect+0x59a>
cvtsi2ssl -0x30(%rbp),%xmm1
movss  -0x78(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
cvtsi2ssl -0x34(%rbp),%xmm1
movss  -0x78(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
cvtsi2ssl -0x38(%rbp),%xmm1
movss  -0x78(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd6d(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    12aa <advect+0x19a>
movss  0xd63(%rip),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
cvtsi2sdl -0x4(%rbp),%xmm1
movsd  0xd40(%rip),%xmm2
addsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    12e8 <advect+0x1d8>
cvtsi2sdl -0x4(%rbp),%xmm0
movsd  0xd25(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd07(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1310 <advect+0x200>
movss  0xcfd(%rip),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
cvtsi2sdl -0x4(%rbp),%xmm1
movsd  0xcda(%rip),%xmm2
addsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    134e <advect+0x23e>
cvtsi2sdl -0x4(%rbp),%xmm0
movsd  0xcbf(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x5c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xca1(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1376 <advect+0x266>
movss  0xc97(%rip),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x5c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
cvtsi2sdl -0x4(%rbp),%xmm1
movsd  0xc74(%rip),%xmm2
addsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    13b4 <advect+0x2a4>
cvtsi2sdl -0x4(%rbp),%xmm0
movsd  0xc59(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
cvttss2si -0x54(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
cvttss2si -0x58(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
cvttss2si -0x5c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
movss  -0x54(%rbp),%xmm0
cvtsi2ssl -0x3c(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  0xc0a(%rip),%xmm0
subss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x58(%rbp),%xmm0
cvtsi2ssl -0x40(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  0xbe5(%rip),%xmm0
subss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x5c(%rbp),%xmm0
cvtsi2ssl -0x44(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  0xbc0(%rip),%xmm0
subss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x60(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
mulss  -0x74(%rbp),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x44(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x6c(%rbp),%xmm1
mulss  -0x74(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x4c(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x44(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x64(%rbp),%xmm1
mulss  -0x70(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x50(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x6c(%rbp),%xmm2
mulss  -0x70(%rbp),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x4c(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x50(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x68(%rbp),%xmm1
movss  -0x64(%rbp),%xmm3
mulss  -0x74(%rbp),%xmm3
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x44(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
movss  -0x6c(%rbp),%xmm4
mulss  -0x74(%rbp),%xmm4
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x4c(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x44(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
movss  -0x64(%rbp),%xmm4
mulss  -0x70(%rbp),%xmm4
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x50(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mulss  %xmm5,%xmm4
addss  %xmm3,%xmm4
movss  -0x6c(%rbp),%xmm3
mulss  -0x70(%rbp),%xmm3
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x4c(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x50(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    117a <advect+0x6a>
jmp    16af <advect+0x59f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1167 <advect+0x57>
jmp    16c2 <advect+0x5b2>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1154 <advect+0x44>
mov    -0x4(%rbp),%edi
mov    -0x10(%rbp),%rsi
mov    -0x8(%rbp),%edx
call   1030 <boundary_condition@plt>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<advect>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rdx,-0x58(%rsp)
mov    %esi,-0x6c(%rsp)
mov    %rdi,-0x60(%rsp)
test   %edi,%edi
jle    1453 <advect+0x343>
mov    0x38(%rsp),%rdx
mov    -0x60(%rsp),%rax
cvtsi2ss %eax,%xmm12
lea    0x2(%rax),%esi
mov    %esi,-0x68(%rsp)
mov    %esi,%r12d
imul   %r12d,%r12d
xorps  0xeab(%rip),%xmm12
cvtsi2sd %eax,%xmm13
addsd  0xead(%rip),%xmm13
mulss  %xmm0,%xmm12
cvtsd2ss %xmm13,%xmm14
lea    0x1(%rax),%esi
mov    %rsi,-0x78(%rsp)
mov    %eax,%edi
lea    0x2(%r12,%rdi,1),%rbp
lea    0x4(%r8,%rbp,4),%rax
mov    %rax,-0x8(%rsp)
lea    0x8(,%rdi,4),%rax
mov    %rax,-0x40(%rsp)
lea    0x0(,%r12,4),%rax
mov    %rax,-0x10(%rsp)
lea    0x4(%r9,%rbp,4),%rax
mov    %rax,-0x18(%rsp)
lea    0x4(%rdx,%rbp,4),%rax
mov    %rax,-0x20(%rsp)
mov    -0x58(%rsp),%rax
lea    (%rax,%rbp,4),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rsp)
mov    $0x1,%eax
xor    %ebp,%ebp
movss  0xe42(%rip),%xmm10
movss  0xe3d(%rip),%xmm11
jmp    120d <advect+0xfd>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0x48(%rsp),%rax
add    $0x1,%rax
mov    -0x50(%rsp),%rbp
add    $0x4,%rbp
cmp    -0x78(%rsp),%rax
je     1453 <advect+0x343>
mov    %rax,-0x48(%rsp)
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x64(%rsp)
mov    %rbp,-0x50(%rsp)
mov    $0x1,%eax
jmp    124a <advect+0x13a>
nopl   0x0(%rax,%rax,1)
mov    -0x38(%rsp),%rax
add    $0x1,%rax
mov    -0x30(%rsp),%rbp
add    -0x40(%rsp),%rbp
cmp    -0x78(%rsp),%rax
je     11f0 <advect+0xe0>
mov    %rax,-0x38(%rsp)
cvtsi2ss %eax,%xmm9
mov    $0x1,%edx
mov    %rbp,-0x30(%rsp)
jmp    13af <advect+0x29f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cvttss2si %xmm15,%r14d
cvttss2si %xmm0,%r8d
lea    0x1(%r8),%r10d
cvttss2si %xmm5,%edi
lea    0x1(%rdi),%r13d
mov    -0x68(%rsp),%eax
imul   %eax,%r8d
lea    (%r8,%r14,1),%r11d
imul   %r12d,%edi
imul   %eax,%r10d
lea    (%r10,%r14,1),%r15d
lea    (%r15,%rdi,1),%r9d
movslq %r9d,%rbx
movss  (%rcx,%rbx,4),%xmm3
lea    (%r11,%rdi,1),%ebx
movslq %ebx,%rbx
movss  (%rcx,%rbx,4),%xmm4
imul   %r12d,%r13d
add    %r13d,%r11d
movslq %r11d,%rbx
movss  (%rcx,%rbx,4),%xmm2
cvttps2dq %xmm0,%xmm1
cvtdq2ps %xmm1,%xmm1
subss  %xmm1,%xmm0
movaps %xmm11,%xmm1
subss  %xmm0,%xmm1
cvttps2dq %xmm5,%xmm6
cvtdq2ps %xmm6,%xmm6
subss  %xmm6,%xmm5
movaps %xmm11,%xmm6
subss  %xmm5,%xmm6
movaps %xmm1,%xmm7
mulss  %xmm6,%xmm7
mulss  %xmm0,%xmm6
mulss  %xmm6,%xmm3
lea    (%r8,%r14,1),%ebx
add    $0x1,%ebx
lea    (%r10,%r14,1),%esi
add    $0x1,%esi
lea    (%rbx,%rdi,1),%eax
add    %esi,%edi
movslq %edi,%rdi
mulss  (%rcx,%rdi,4),%xmm6
mulss  %xmm7,%xmm4
cltq
mulss  (%rcx,%rax,4),%xmm7
mulss  %xmm5,%xmm1
mulss  %xmm1,%xmm2
add    %r13d,%ebx
movslq %ebx,%rax
mulss  (%rcx,%rax,4),%xmm1
add    %r13d,%r15d
movslq %r15d,%rax
movss  (%rcx,%rax,4),%xmm8
add    %esi,%r13d
mulss  %xmm0,%xmm5
mulss  %xmm5,%xmm8
movslq %r13d,%rax
mulss  (%rcx,%rax,4),%xmm5
cvttps2dq %xmm15,%xmm0
cvtdq2ps %xmm0,%xmm0
subss  %xmm0,%xmm15
addss  %xmm3,%xmm4
movaps %xmm11,%xmm0
subss  %xmm15,%xmm0
addss  %xmm4,%xmm2
addss  %xmm2,%xmm8
mulss  %xmm0,%xmm8
addss  %xmm6,%xmm7
addss  %xmm7,%xmm1
addss  %xmm1,%xmm5
mulss  %xmm15,%xmm5
addss  %xmm8,%xmm5
mov    -0x28(%rsp),%rax
movss  %xmm5,(%rax,%rbp,1)
add    $0x1,%rdx
add    -0x10(%rsp),%rbp
cmp    %rdx,-0x78(%rsp)
je     1230 <advect+0x120>
mov    -0x8(%rsp),%rax
movss  (%rax,%rbp,1),%xmm1
mulss  %xmm12,%xmm1
addss  -0x64(%rsp),%xmm1
movaps %xmm10,%xmm0
maxss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
ucomisd %xmm13,%xmm1
movaps %xmm14,%xmm15
ja     13e2 <advect+0x2d2>
movaps %xmm0,%xmm15
mov    -0x18(%rsp),%rax
movss  (%rax,%rbp,1),%xmm0
mulss  %xmm12,%xmm0
addss  %xmm9,%xmm0
movaps %xmm10,%xmm1
maxss  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
ucomisd %xmm13,%xmm0
movaps %xmm14,%xmm0
ja     1413 <advect+0x303>
movaps %xmm1,%xmm0
xorps  %xmm1,%xmm1
cvtsi2ss %edx,%xmm1
mov    -0x20(%rsp),%rax
movss  (%rax,%rbp,1),%xmm2
mulss  %xmm12,%xmm2
addss  %xmm1,%xmm2
movaps %xmm10,%xmm1
maxss  %xmm2,%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm1,%xmm2
ucomisd %xmm13,%xmm2
movaps %xmm14,%xmm5
ja     1270 <advect+0x160>
movaps %xmm1,%xmm5
jmp    1270 <advect+0x160>
mov    -0x60(%rsp),%rdi
mov    -0x58(%rsp),%rsi
mov    -0x6c(%rsp),%edx
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <boundary_condition@plt>

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

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