#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ isfluid(int);
void calculate_uvw(double dt, double dx, double dy, double dz, int imax,
                   int jmax, int kmax, double ***U, double ***V, double ***W,
                   double ***F, double ***G, double ***H, double ***P,
                   int ***Flag) {
  int i, j, k;
  for (i = 1; i < imax; i++) {
    for (j = 1; j < jmax + 1; j++) {
      for (k = 1; k < kmax + 1; k++) {
        if (isfluid(Flag[i][j][k]) && isfluid(Flag[i + 1][j][k])) {
          U[i][j][k] = F[i][j][k] - dt / dx * (P[i + 1][j][k] - P[i][j][k]);
        }
      }
    }
  }
  for (i = 1; i < imax + 1; i++) {
    for (j = 1; j < jmax; j++) {
      for (k = 1; k < kmax + 1; k++) {
        if (isfluid(Flag[i][j][k]) && isfluid(Flag[i][j + 1][k])) {
          V[i][j][k] = G[i][j][k] - dt / dy * (P[i][j + 1][k] - P[i][j][k]);
        }
      }
    }
  }
  for (i = 1; i < imax + 1; i++) {
    for (j = 1; j < jmax + 1; j++) {
      for (k = 1; k < kmax; k++) {
        if (isfluid(Flag[i][j][k]) && isfluid(Flag[i][j][k + 1])) {
          W[i][j][k] = H[i][j][k] - dt / dz * (P[i][j][k + 1] - P[i][j][k]);
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<calculate_uvw>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
movsd  %xmm0,-0x8(%rbp)
movsd  %xmm1,-0x10(%rbp)
movsd  %xmm2,-0x18(%rbp)
movsd  %xmm3,-0x20(%rbp)
mov    %edi,-0x24(%rbp)
mov    %esi,-0x28(%rbp)
mov    %edx,-0x2c(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %r8,-0x40(%rbp)
mov    %r9,-0x48(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12cc <calculate_uvw+0x1bc>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    12b9 <calculate_uvw+0x1a9>
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    12a6 <calculate_uvw+0x196>
mov    0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
call   1030 <isfluid@plt>
cmp    $0x0,%rax
je     1293 <calculate_uvw+0x183>
mov    0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
call   1030 <isfluid@plt>
cmp    $0x0,%rax
je     1293 <calculate_uvw+0x183>
mov    0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x8(%rbp),%xmm0
divsd  -0x10(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1298 <calculate_uvw+0x188>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1187 <calculate_uvw+0x77>
jmp    12ab <calculate_uvw+0x19b>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    116f <calculate_uvw+0x5f>
jmp    12be <calculate_uvw+0x1ae>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    115c <calculate_uvw+0x4c>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1443 <calculate_uvw+0x333>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1430 <calculate_uvw+0x320>
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    141d <calculate_uvw+0x30d>
mov    0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
call   1030 <isfluid@plt>
cmp    $0x0,%rax
je     140a <calculate_uvw+0x2fa>
mov    0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
call   1030 <isfluid@plt>
cmp    $0x0,%rax
je     140a <calculate_uvw+0x2fa>
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x8(%rbp),%xmm0
divsd  -0x18(%rbp),%xmm0
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    140f <calculate_uvw+0x2ff>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    12fe <calculate_uvw+0x1ee>
jmp    1422 <calculate_uvw+0x312>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    12eb <calculate_uvw+0x1db>
jmp    1435 <calculate_uvw+0x325>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12d3 <calculate_uvw+0x1c3>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    15ba <calculate_uvw+0x4aa>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    15a7 <calculate_uvw+0x497>
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1594 <calculate_uvw+0x484>
mov    0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
call   1030 <isfluid@plt>
cmp    $0x0,%rax
je     1581 <calculate_uvw+0x471>
mov    0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edi
call   1030 <isfluid@plt>
cmp    $0x0,%rax
je     1581 <calculate_uvw+0x471>
mov    0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x8(%rbp),%xmm0
divsd  -0x20(%rbp),%xmm0
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1586 <calculate_uvw+0x476>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    147a <calculate_uvw+0x36a>
jmp    1599 <calculate_uvw+0x489>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1462 <calculate_uvw+0x352>
jmp    15ac <calculate_uvw+0x49c>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    144a <calculate_uvw+0x33a>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<calculate_uvw>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r9,0x70(%rsp)
mov    %r8,0x28(%rsp)
mov    %rdx,0x8(%rsp)
mov    %rsi,(%rsp)
movsd  %xmm3,0x58(%rsp)
movsd  %xmm2,0x60(%rsp)
movapd %xmm0,0x30(%rsp)
mov    0xd0(%rsp),%r13
mov    %rdi,0x18(%rsp)
cmp    $0x2,%edi
jl     12ac <calculate_uvw+0x19c>
mov    %rcx,%rbp
movapd 0xe9c(%rip),%xmm0
xorpd  0x30(%rsp),%xmm0
divsd  %xmm1,%xmm0
movapd %xmm0,0x40(%rsp)
mov    0x8(%rsp),%rax
add    $0x1,%eax
mov    (%rsp),%rcx
add    $0x1,%ecx
mov    %rcx,0x20(%rsp)
mov    0x18(%rsp),%ecx
mov    %rcx,0x68(%rsp)
lea    -0x4(,%rax,4),%r12
ff
mov    $0x1,%r14d
jmp    11c3 <calculate_uvw+0xb3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rax
mov    %rax,%r14
cmp    0x68(%rsp),%rax
je     12ac <calculate_uvw+0x19c>
cmpl   $0x0,(%rsp)
jle    12a0 <calculate_uvw+0x190>
lea    0x1(%r14),%rax
mov    %rax,0x10(%rsp)
mov    $0x1,%ebx
jmp    11eb <calculate_uvw+0xdb>
nopl   (%rax)
add    $0x1,%rbx
cmp    0x20(%rsp),%rbx
je     11b0 <calculate_uvw+0xa0>
cmpl   $0x0,0x8(%rsp)
jle    11e0 <calculate_uvw+0xd0>
xor    %r15d,%r15d
jmp    1209 <calculate_uvw+0xf9>
nopw   0x0(%rax,%rax,1)
add    $0x4,%r15
cmp    %r15,%r12
je     11e0 <calculate_uvw+0xd0>
mov    0x0(%r13,%r14,8),%rax
mov    (%rax,%rbx,8),%rax
mov    0x4(%rax,%r15,1),%edi
call   1030 <isfluid@plt>
test   %rax,%rax
je     1200 <calculate_uvw+0xf0>
mov    0x8(%r13,%r14,8),%rax
mov    (%rax,%rbx,8),%rax
mov    0x4(%rax,%r15,1),%edi
call   1030 <isfluid@plt>
test   %rax,%rax
je     1200 <calculate_uvw+0xf0>
mov    0xb0(%rsp),%rax
mov    (%rax,%r14,8),%rax
mov    0xc8(%rsp),%rdx
mov    (%rdx,%r14,8),%rcx
mov    0x8(%rdx,%r14,8),%rdx
mov    (%rdx,%rbx,8),%rdx
movsd  0x8(%rdx,%r15,2),%xmm0
mov    (%rcx,%rbx,8),%rcx
subsd  0x8(%rcx,%r15,2),%xmm0
mov    (%rax,%rbx,8),%rax
mulsd  0x40(%rsp),%xmm0
addsd  0x8(%rax,%r15,2),%xmm0
mov    0x0(%rbp,%r14,8),%rax
mov    (%rax,%rbx,8),%rax
movsd  %xmm0,0x8(%rax,%r15,2)
jmp    1200 <calculate_uvw+0xf0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r14
mov    %r14,%rax
jmp    11b8 <calculate_uvw+0xa8>
mov    0x18(%rsp),%rcx
test   %ecx,%ecx
jle    14ed <calculate_uvw+0x3dd>
movapd 0x30(%rsp),%xmm0
xorpd  0xd39(%rip),%xmm0
movapd %xmm0,0x30(%rsp)
divsd  0x60(%rsp),%xmm0
movapd %xmm0,0x40(%rsp)
mov    0x8(%rsp),%rax
add    $0x1,%eax
add    $0x1,%ecx
mov    %rcx,0x10(%rsp)
mov    (%rsp),%ecx
mov    %rcx,0x20(%rsp)
lea    -0x4(,%rax,4),%r12
ff
mov    $0x1,%r14d
jmp    131f <calculate_uvw+0x20f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14
cmp    0x10(%rsp),%r14
je     13db <calculate_uvw+0x2cb>
cmpl   $0x2,(%rsp)
jl     1310 <calculate_uvw+0x200>
mov    $0x1,%ebx
jmp    133a <calculate_uvw+0x22a>
nopl   0x0(%rax)
mov    %r15,%rbx
cmp    0x20(%rsp),%r15
je     1310 <calculate_uvw+0x200>
lea    0x1(%rbx),%r15
cmpl   $0x0,0x8(%rsp)
jle    1330 <calculate_uvw+0x220>
xor    %ebp,%ebp
jmp    1359 <calculate_uvw+0x249>
nopl   0x0(%rax)
add    $0x4,%rbp
cmp    %rbp,%r12
je     1330 <calculate_uvw+0x220>
mov    0x0(%r13,%r14,8),%rax
mov    (%rax,%rbx,8),%rax
mov    0x4(%rax,%rbp,1),%edi
call   1030 <isfluid@plt>
test   %rax,%rax
je     1350 <calculate_uvw+0x240>
mov    0x0(%r13,%r14,8),%rax
mov    (%rax,%r15,8),%rax
mov    0x4(%rax,%rbp,1),%edi
call   1030 <isfluid@plt>
test   %rax,%rax
je     1350 <calculate_uvw+0x240>
mov    0xb8(%rsp),%rax
mov    (%rax,%r14,8),%rax
mov    0xc8(%rsp),%rcx
mov    (%rcx,%r14,8),%rcx
mov    (%rcx,%r15,8),%rdx
movsd  0x8(%rdx,%rbp,2),%xmm0
mov    (%rcx,%rbx,8),%rcx
subsd  0x8(%rcx,%rbp,2),%xmm0
mov    (%rax,%rbx,8),%rax
mulsd  0x40(%rsp),%xmm0
addsd  0x8(%rax,%rbp,2),%xmm0
mov    0x28(%rsp),%rax
mov    (%rax,%r14,8),%rax
mov    (%rax,%rbx,8),%rax
movsd  %xmm0,0x8(%rax,%rbp,2)
jmp    1350 <calculate_uvw+0x240>
cmpl   $0x0,0x18(%rsp)
jle    14ed <calculate_uvw+0x3dd>
movapd 0x30(%rsp),%xmm0
divsd  0x58(%rsp),%xmm0
movapd %xmm0,0x30(%rsp)
mov    (%rsp),%rax
add    $0x1,%eax
mov    %rax,0x28(%rsp)
mov    0x8(%rsp),%r14d
mov    $0x1,%r15d
jmp    142f <calculate_uvw+0x31f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r15
cmp    0x10(%rsp),%r15
je     14ed <calculate_uvw+0x3dd>
cmpl   $0x0,(%rsp)
jle    1420 <calculate_uvw+0x310>
mov    $0x1,%ebp
jmp    144b <calculate_uvw+0x33b>
nopl   0x0(%rax)
add    $0x1,%rbp
cmp    0x28(%rsp),%rbp
je     1420 <calculate_uvw+0x310>
cmpl   $0x2,0x8(%rsp)
jl     1440 <calculate_uvw+0x330>
mov    $0x1,%ebx
jmp    146f <calculate_uvw+0x35f>
nopl   0x0(%rax)
add    $0x1,%rbx
mov    %rbx,%r12
mov    %r12,%rbx
cmp    %r14,%r12
je     1440 <calculate_uvw+0x330>
mov    0x0(%r13,%r15,8),%rax
mov    (%rax,%rbp,8),%rax
mov    (%rax,%rbx,4),%edi
call   1030 <isfluid@plt>
test   %rax,%rax
je     1460 <calculate_uvw+0x350>
mov    0x0(%r13,%r15,8),%rax
mov    (%rax,%rbp,8),%rax
lea    0x1(%rbx),%r12
mov    0x4(%rax,%rbx,4),%edi
call   1030 <isfluid@plt>
test   %rax,%rax
je     1467 <calculate_uvw+0x357>
mov    0xc0(%rsp),%rax
mov    (%rax,%r15,8),%rax
mov    0xc8(%rsp),%rcx
mov    (%rcx,%r15,8),%rcx
mov    (%rcx,%rbp,8),%rcx
movsd  0x8(%rcx,%rbx,8),%xmm0
subsd  (%rcx,%rbx,8),%xmm0
mov    (%rax,%rbp,8),%rax
mulsd  0x30(%rsp),%xmm0
addsd  (%rax,%rbx,8),%xmm0
mov    0x70(%rsp),%rax
mov    (%rax,%r15,8),%rax
mov    (%rax,%rbp,8),%rax
movsd  %xmm0,(%rax,%rbx,8)
jmp    1467 <calculate_uvw+0x357>
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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