#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 */
int /*<<< orphan*/ boundaryvalues_pressure(double ***, int ***, int, int, int);
scalar_t__ isfluid(int);
double sqrt(double);
void sor(double omg, double dx, double dy, double dz, int imax, int jmax,
         int kmax, double ***P, double ***RS, double *res, int ***Flag) {
  int i, j, k;
  double rloc;
  double coeff =
      omg / (2.0 * (1.0 / (dx * dx) + 1.0 / (dy * dy) + 1.0 / (dz * dz)));
  double FluidCells = 0.0;
  double tmp = 0;
  for (i = 1; i <= imax; i++) {
    for (j = 1; j <= jmax; j++) {
      for (k = 1; k <= kmax; k++) {
        if (isfluid(Flag[i][j][k])) {
          P[i][j][k] = (1.0 - omg) * P[i][j][k] +
                       coeff * ((P[i + 1][j][k] + P[i - 1][j][k]) / (dx * dx) +
                                (P[i][j + 1][k] + P[i][j - 1][k]) / (dy * dy) +
                                (P[i][j][k + 1] + P[i][j][k - 1]) / (dz * dz) -
                                RS[i][j][k]);
          FluidCells++;
        }
      }
    }
  }
  rloc = 0;
  for (i = 1; i <= imax; i++) {
    for (j = 1; j <= jmax; j++) {
      for (k = 1; k <= kmax; k++) {
        if (isfluid(Flag[i][j][k])) {
          tmp =
              (P[i + 1][j][k] - 2.0 * P[i][j][k] + P[i - 1][j][k]) / (dx * dx) +
              (P[i][j + 1][k] - 2.0 * P[i][j][k] + P[i][j - 1][k]) / (dy * dy) +
              (P[i][j][k + 1] - 2.0 * P[i][j][k] + P[i][j][k - 1]) / (dz * dz) -
              RS[i][j][k];
          rloc += tmp * tmp;
        }
      }
    }
  }
  rloc = rloc / FluidCells;
  rloc = sqrt(rloc);
  *res = rloc;
  boundaryvalues_pressure(P, Flag, imax, jmax, kmax);
}


x86 assembly (clang, -O0):
<sor>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
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)
movsd  -0x8(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm1
mulsd  -0x10(%rbp),%xmm1
movsd  0xe89(%rip),%xmm2
divsd  %xmm1,%xmm2
movsd  -0x18(%rbp),%xmm3
mulsd  -0x18(%rbp),%xmm3
movsd  0xe73(%rip),%xmm1
divsd  %xmm3,%xmm1
addsd  %xmm1,%xmm2
movsd  -0x20(%rbp),%xmm3
mulsd  -0x20(%rbp),%xmm3
movsd  0xe59(%rip),%xmm1
divsd  %xmm3,%xmm1
addsd  %xmm1,%xmm2
movsd  0xe41(%rip),%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     13fd <sor+0x2cd>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     13ea <sor+0x2ba>
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     13d7 <sor+0x2a7>
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
mov    (%rax,%rcx,4),%edi
call   1030 <isfluid@plt>
cmp    $0x0,%rax
je     13c4 <sor+0x294>
movsd  0xdc1(%rip),%xmm0
subsd  -0x8(%rbp),%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  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mov    -0x38(%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),%xmm3
mov    -0x38(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm3
movsd  -0x10(%rbp),%xmm4
mulsd  -0x10(%rbp),%xmm4
divsd  %xmm4,%xmm3
mov    -0x38(%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),%xmm4
mov    -0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm4
movsd  -0x18(%rbp),%xmm5
mulsd  -0x18(%rbp),%xmm5
divsd  %xmm5,%xmm4
addsd  %xmm4,%xmm3
mov    -0x38(%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),%xmm4
mov    -0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm4
movsd  -0x20(%rbp),%xmm5
mulsd  -0x20(%rbp),%xmm5
divsd  %xmm5,%xmm4
addsd  %xmm4,%xmm3
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
subsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
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)
movsd  0xc4e(%rip),%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    13c9 <sor+0x299>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1209 <sor+0xd9>
jmp    13dc <sor+0x2ac>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    11f6 <sor+0xc6>
jmp    13ef <sor+0x2bf>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    11e3 <sor+0xb3>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     164c <sor+0x51c>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     1639 <sor+0x509>
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     1626 <sor+0x4f6>
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
mov    (%rax,%rcx,4),%edi
call   1030 <isfluid@plt>
cmp    $0x0,%rax
je     1613 <sor+0x4e3>
mov    -0x38(%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),%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  (%rax,%rcx,8),%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  -0x10(%rbp),%xmm1
mulsd  -0x10(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x38(%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),%xmm1
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  (%rax,%rcx,8),%xmm2
addsd  %xmm2,%xmm2
subsd  %xmm2,%xmm1
mov    -0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  -0x18(%rbp),%xmm2
mulsd  -0x18(%rbp),%xmm2
divsd  %xmm2,%xmm1
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
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
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  (%rax,%rcx,8),%xmm2
addsd  %xmm2,%xmm2
subsd  %xmm2,%xmm1
mov    -0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm2
mulsd  -0x20(%rbp),%xmm2
divsd  %xmm2,%xmm1
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
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    1618 <sor+0x4e8>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1432 <sor+0x302>
jmp    162b <sor+0x4fb>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    141f <sor+0x2ef>
jmp    163e <sor+0x50e>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    140c <sor+0x2dc>
movsd  -0x60(%rbp),%xmm0
divsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
call   1050 <sqrt@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x38(%rbp),%rdi
mov    0x10(%rbp),%rsi
mov    -0x24(%rbp),%edx
mov    -0x28(%rbp),%ecx
mov    -0x2c(%rbp),%r8d
call   1040 <boundaryvalues_pressure@plt>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sor>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %r9,%rbx
mov    %r8,0x78(%rsp)
mov    %rcx,%r15
mov    %rdx,0x10(%rsp)
mov    %rsi,0x8(%rsp)
mov    0xf0(%rsp),%rax
mov    %rax,0x38(%rsp)
xorpd  %xmm4,%xmm4
xorpd  %xmm5,%xmm5
mov    %rdi,0x18(%rsp)
test   %edi,%edi
jle    1548 <sor+0x418>
mov    %rbx,0x58(%rsp)
unpcklpd %xmm3,%xmm1
mulpd  %xmm1,%xmm1
movsd  0xe73(%rip),%xmm5
movapd %xmm5,%xmm4
divsd  %xmm1,%xmm4
mulsd  %xmm2,%xmm2
movsd  %xmm2,0x70(%rsp)
movapd %xmm1,%xmm3
movapd %xmm5,%xmm1
divsd  %xmm2,%xmm1
addsd  %xmm4,%xmm1
movapd %xmm3,0xa0(%rsp)
unpckhpd %xmm3,%xmm3
movapd %xmm5,%xmm2
movapd %xmm3,0x80(%rsp)
divsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm2
subsd  %xmm0,%xmm5
movsd  %xmm5,0x28(%rsp)
divsd  %xmm2,%xmm0
mov    0x10(%rsp),%rax
lea    0x1(%rax),%r13d
mov    0x8(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x68(%rsp)
mov    0x18(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x60(%rsp)
xorpd  %xmm4,%xmm4
mov    $0x1,%ebp
movsd  %xmm0,0x30(%rsp)
jmp    1236 <sor+0x106>
nopw   0x0(%rax,%rax,1)
mov    0x98(%rsp),%rax
mov    %rax,%rbp
cmp    0x60(%rsp),%rax
je     139c <sor+0x26c>
cmpl   $0x0,0x8(%rsp)
jle    1390 <sor+0x260>
lea    0x1(%rbp),%rax
mov    %rax,0x98(%rsp)
mov    %eax,%eax
mov    %rax,0x40(%rsp)
mov    $0x1,%ebx
jmp    126f <sor+0x13f>
nopl   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rax
mov    %rax,%rbx
cmp    0x68(%rsp),%rax
je     1220 <sor+0xf0>
lea    0x1(%rbx),%rax
cmpl   $0x0,0x10(%rsp)
mov    %rax,0x20(%rsp)
jle    1260 <sor+0x130>
mov    %eax,%r14d
mov    $0x1,%r12d
jmp    134e <sor+0x21e>
nopl   (%rax)
mov    -0x8(%r15,%rbp,8),%rcx
mov    (%r15,%rbp,8),%rdx
mov    -0x8(%rdx,%rbx,8),%rsi
mov    (%rdx,%rbx,8),%rax
mov    0x40(%rsp),%rdi
mov    (%r15,%rdi,8),%rdi
mov    (%rdi,%rbx,8),%rdi
movsd  (%rdi,%r12,8),%xmm0
mov    (%rcx,%rbx,8),%rcx
addsd  (%rcx,%r12,8),%xmm0
mov    (%rdx,%r14,8),%rcx
movsd  (%rcx,%r12,8),%xmm1
addsd  (%rsi,%r12,8),%xmm1
divsd  0xa0(%rsp),%xmm0
divsd  0x70(%rsp),%xmm1
addsd  %xmm0,%xmm1
lea    0x1(%r12),%rcx
mov    %ecx,%edx
movsd  (%rax,%rdx,8),%xmm2
addsd  -0x8(%rax,%r12,8),%xmm2
divsd  0x80(%rsp),%xmm2
addsd  %xmm1,%xmm2
mov    0x78(%rsp),%rdx
mov    (%rdx,%rbp,8),%rdx
mov    (%rdx,%rbx,8),%rdx
subsd  (%rdx,%r12,8),%xmm2
movsd  0x30(%rsp),%xmm0
mulsd  %xmm0,%xmm2
movsd  (%rax,%r12,8),%xmm1
mulsd  0x28(%rsp),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rax,%r12,8)
movsd  (%rsp),%xmm4
addsd  0xcbe(%rip),%xmm4
mov    %rcx,%r12
cmp    %r13,%r12
je     1260 <sor+0x130>
movsd  %xmm4,(%rsp)
mov    0x38(%rsp),%rax
mov    (%rax,%rbp,8),%rax
mov    (%rax,%rbx,8),%rax
mov    (%rax,%r12,4),%edi
call   1030 <isfluid@plt>
test   %rax,%rax
jne    1290 <sor+0x160>
add    $0x1,%r12
movsd  (%rsp),%xmm4
cmp    %r13,%r12
jne    134e <sor+0x21e>
jmp    1260 <sor+0x130>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbp
mov    %rbp,%rax
jmp    122b <sor+0xfb>
cmpl   $0x0,0x18(%rsp)
jle    153f <sor+0x40f>
xorpd  %xmm0,%xmm0
movapd %xmm0,0x40(%rsp)
mov    $0x1,%r12d
jmp    13d3 <sor+0x2a3>
nopl   0x0(%rax)
mov    0x20(%rsp),%rax
mov    %rax,%r12
cmp    0x60(%rsp),%rax
je     1532 <sor+0x402>
cmpl   $0x0,0x8(%rsp)
jle    1520 <sor+0x3f0>
lea    0x1(%r12),%rax
mov    %rax,0x20(%rsp)
mov    %eax,%eax
mov    %rax,0x80(%rsp)
mov    $0x1,%r14d
movsd  %xmm4,(%rsp)
jmp    140f <sor+0x2df>
nop
mov    0x28(%rsp),%rax
mov    %rax,%r14
cmp    0x68(%rsp),%rax
je     13c0 <sor+0x290>
lea    0x1(%r14),%rax
cmpl   $0x0,0x10(%rsp)
mov    %rax,0x28(%rsp)
jle    1400 <sor+0x2d0>
mov    %eax,%eax
mov    %rax,0x30(%rsp)
mov    $0x1,%ebp
jmp    14ef <sor+0x3bf>
mov    0x80(%rsp),%rax
mov    (%r15,%rax,8),%rax
mov    (%rax,%r14,8),%rcx
mov    -0x8(%r15,%r12,8),%rax
mov    (%r15,%r12,8),%rdx
mov    -0x8(%rdx,%r14,8),%rsi
mov    (%rdx,%r14,8),%rdi
movsd  (%rdi,%rbp,8),%xmm0
mov    (%rax,%r14,8),%rbx
mov    0x30(%rsp),%rax
mov    (%rdx,%rax,8),%rax
movsd  (%rax,%rbp,8),%xmm1
addsd  %xmm0,%xmm0
subsd  %xmm0,%xmm1
addsd  (%rsi,%rbp,8),%xmm1
lea    0x1(%rbp),%rax
mov    %eax,%edx
movsd  (%rcx,%rbp,8),%xmm2
movhpd (%rdi,%rdx,8),%xmm2
unpcklpd %xmm0,%xmm0
subpd  %xmm0,%xmm2
movsd  (%rbx,%rbp,8),%xmm0
movhpd -0x8(%rdi,%rbp,8),%xmm0
divsd  0x70(%rsp),%xmm1
addpd  %xmm2,%xmm0
divpd  0xa0(%rsp),%xmm0
addsd  %xmm0,%xmm1
unpckhpd %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x78(%rsp),%rcx
mov    (%rcx,%r12,8),%rcx
mov    (%rcx,%r14,8),%rcx
subsd  (%rcx,%rbp,8),%xmm0
mulsd  %xmm0,%xmm0
movapd 0x40(%rsp),%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,0x40(%rsp)
mov    %rax,%rbp
movsd  (%rsp),%xmm4
cmp    %r13,%rbp
je     1400 <sor+0x2d0>
mov    0x38(%rsp),%rax
mov    (%rax,%r12,8),%rax
mov    (%rax,%r14,8),%rax
mov    (%rax,%rbp,4),%edi
call   1030 <isfluid@plt>
test   %rax,%rax
jne    1430 <sor+0x300>
add    $0x1,%rbp
jmp    14e1 <sor+0x3b1>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r12
mov    %r12,%rax
cmp    0x60(%rsp),%rax
jne    13d3 <sor+0x2a3>
mov    0x58(%rsp),%rbx
movapd 0x40(%rsp),%xmm5
jmp    1548 <sor+0x418>
xorpd  %xmm5,%xmm5
mov    0x58(%rsp),%rbx
divsd  %xmm4,%xmm5
ucomisd 0xab4(%rip),%xmm5
movapd %xmm5,%xmm0
jb     1560 <sor+0x430>
sqrtsd %xmm0,%xmm0
jmp    1565 <sor+0x435>
call   1050 <sqrt@plt>
movsd  %xmm0,(%rbx)
mov    %r15,%rdi
mov    0x38(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    0x8(%rsp),%rcx
mov    0x10(%rsp),%r8
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <boundaryvalues_pressure@plt>

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

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