#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_free_slip(int, int, int, double ***,
                                            double ***, double ***, int ***);
int /*<<< orphan*/ boundaryvalues_inflow(int, int, int, double ***, double ***,
                                         double ***, int ***, double);
int /*<<< orphan*/ boundaryvalues_moving_wall(int, int, int, double ***,
                                              double ***, double ***, int ***,
                                              double *);
int /*<<< orphan*/ boundaryvalues_no_slip(int, int, int, double ***, double ***,
                                          double ***, int ***);
int /*<<< orphan*/ boundaryvalues_outflow(int, int, int, double ***, double ***,
                                          double ***, int ***);
void boundaryvalues(int imax, int jmax, int kmax, double ***U, double ***V,
                    double ***W, double ***P, int wl, int wr, int wf, int wh,
                    int wt, int wb, double ***F, double ***G, double ***H,
                    char *problem, int ***Flag, double velIN, double *velMW) {
  int i, j, k, temp;
  for (i = 0; i < imax + 2; i++) {
    for (j = 0; j < jmax + 2; j++) {
      for (k = 0; k < kmax + 2; k++) {
        temp = Flag[i][j][k] >> 12;
        temp = (temp >> 2) * 2 + temp % 2 +
               ((temp & 1) != ((temp >> 1) & 1)) * 5 + 2;
        switch (temp) {
        case 2:
          boundaryvalues_no_slip(i, j, k, U, V, W, Flag);
          break;
        case 3:
          boundaryvalues_free_slip(i, j, k, U, V, W, Flag);
          break;
        case 5:
          boundaryvalues_no_slip(i, j, k, U, V, W, Flag);
          boundaryvalues_inflow(i, j, k, U, V, W, Flag, velIN);
          break;
        case 4:
          boundaryvalues_outflow(i, j, k, U, V, W, Flag);
          break;
        case 6:
          boundaryvalues_moving_wall(i, j, k, U, V, W, Flag, velMW);
          break;
        default:
          break;
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<boundaryvalues>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
jge    13a4 <boundaryvalues+0x254>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
jge    1391 <boundaryvalues+0x241>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
jge    137e <boundaryvalues+0x22e>
mov    0x68(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sar    $0xc,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%edx
mov    %edx,%eax
sar    $0x2,%eax
mov    %edx,%esi
shr    $0x1f,%esi
mov    %edx,%ecx
add    %esi,%ecx
and    $0xfffffffe,%ecx
mov    %edx,%esi
sub    %ecx,%esi
mov    %eax,%ecx
mov    %esi,%eax
lea    (%rax,%rcx,2),%ecx
mov    %edx,%eax
and    $0x1,%eax
shr    %edx
and    $0x1,%edx
sub    %edx,%eax
setne  %al
movzbl %al,%edx
mov    %edx,%eax
lea    (%rax,%rax,4),%edx
mov    %ecx,%eax
mov    %edx,%ecx
lea    0x2(%rax,%rcx,1),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
add    $0xfffffffe,%eax
mov    %eax,%ecx
mov    %rcx,-0x48(%rbp)
sub    $0x4,%eax
ja     1366 <boundaryvalues+0x216>
mov    -0x48(%rbp),%rax
lea    0xd96(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x34(%rbp),%edi
mov    -0x38(%rbp),%esi
mov    -0x3c(%rbp),%edx
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%r8
mov    -0x28(%rbp),%r9
mov    0x68(%rbp),%rax
mov    %rax,(%rsp)
call   1030 <boundaryvalues_no_slip@plt>
jmp    136b <boundaryvalues+0x21b>
mov    -0x34(%rbp),%edi
mov    -0x38(%rbp),%esi
mov    -0x3c(%rbp),%edx
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%r8
mov    -0x28(%rbp),%r9
mov    0x68(%rbp),%rax
mov    %rax,(%rsp)
call   1060 <boundaryvalues_free_slip@plt>
jmp    136b <boundaryvalues+0x21b>
mov    -0x34(%rbp),%edi
mov    -0x38(%rbp),%esi
mov    -0x3c(%rbp),%edx
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%r8
mov    -0x28(%rbp),%r9
mov    0x68(%rbp),%rax
mov    %rax,(%rsp)
call   1030 <boundaryvalues_no_slip@plt>
mov    -0x34(%rbp),%edi
mov    -0x38(%rbp),%esi
mov    -0x3c(%rbp),%edx
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%r8
mov    -0x28(%rbp),%r9
mov    0x68(%rbp),%rax
movsd  -0x30(%rbp),%xmm0
mov    %rax,(%rsp)
call   1070 <boundaryvalues_inflow@plt>
jmp    136b <boundaryvalues+0x21b>
mov    -0x34(%rbp),%edi
mov    -0x38(%rbp),%esi
mov    -0x3c(%rbp),%edx
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%r8
mov    -0x28(%rbp),%r9
mov    0x68(%rbp),%rax
mov    %rax,(%rsp)
call   1040 <boundaryvalues_outflow@plt>
jmp    136b <boundaryvalues+0x21b>
mov    -0x34(%rbp),%edi
mov    -0x38(%rbp),%esi
mov    -0x3c(%rbp),%edx
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%r8
mov    -0x28(%rbp),%r9
mov    0x68(%rbp),%r10
mov    0x70(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1050 <boundaryvalues_moving_wall@plt>
jmp    136b <boundaryvalues+0x21b>
jmp    136b <boundaryvalues+0x21b>
jmp    1370 <boundaryvalues+0x220>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11d7 <boundaryvalues+0x87>
jmp    1383 <boundaryvalues+0x233>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11bf <boundaryvalues+0x6f>
jmp    1396 <boundaryvalues+0x246>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11a7 <boundaryvalues+0x57>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<boundaryvalues>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
movsd  %xmm0,0x50(%rsp)
mov    %r9,0x20(%rsp)
mov    %rdx,0x38(%rsp)
mov    %rsi,0x30(%rsp)
mov    %rdi,0x28(%rsp)
cmp    $0xffffffff,%edi
jl     1340 <boundaryvalues+0x1f0>
mov    %r8,%r14
mov    %rcx,%r15
mov    0xe8(%rsp),%rbx
mov    0x38(%rsp),%rax
lea    0x2(%rax),%r13d
mov    0x30(%rsp),%rax
add    $0x2,%eax
mov    %rax,0x40(%rsp)
mov    0x28(%rsp),%rax
add    $0x2,%eax
mov    %rax,0x28(%rsp)
xor    %edi,%edi
mov    %r13,0x48(%rsp)
jmp    11cf <boundaryvalues+0x7f>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdi
cmp    0x28(%rsp),%rdi
je     1340 <boundaryvalues+0x1f0>
cmpl   $0xffffffff,0x30(%rsp)
jl     11c0 <boundaryvalues+0x70>
xor    %ebp,%ebp
mov    %rdi,0x18(%rsp)
jmp    11eb <boundaryvalues+0x9b>
nop
add    $0x1,%rbp
cmp    0x40(%rsp),%rbp
je     11c0 <boundaryvalues+0x70>
cmpl   $0xffffffff,0x38(%rsp)
jl     11e0 <boundaryvalues+0x90>
xor    %r12d,%r12d
jmp    123e <boundaryvalues+0xee>
mov    0xf0(%rsp),%rax
mov    %rax,0x8(%rsp)
mov    %rbx,(%rsp)
mov    0x18(%rsp),%rdi
mov    %ebp,%esi
mov    %r12d,%edx
mov    %r15,%rcx
mov    %r14,%r8
mov    0x20(%rsp),%r9
call   1050 <boundaryvalues_moving_wall@plt>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x18(%rsp),%rdi
add    $0x1,%r12
cmp    %r12,%r13
je     11e0 <boundaryvalues+0x90>
mov    (%rbx,%rdi,8),%rax
mov    (%rax,%rbp,8),%rax
mov    (%rax,%r12,4),%eax
mov    %eax,%ecx
sar    $0xc,%ecx
mov    %eax,%edx
sar    $0xd,%edx
and    $0xfffffffe,%edx
mov    %eax,%esi
shr    $0x1f,%esi
add    %ecx,%esi
and    $0xfffffffe,%esi
shr    $0xd,%eax
xor    %ecx,%eax
sub    %esi,%ecx
add    %edx,%ecx
and    $0x1,%eax
lea    (%rax,%rax,4),%eax
add    %ecx,%eax
cmp    $0x4,%eax
ja     1235 <boundaryvalues+0xe5>
lea    0xd82(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    %rbx,(%rsp)
mov    0x18(%rsp),%rdi
mov    %ebp,%esi
mov    %r12d,%edx
mov    %r15,%rcx
mov    %r14,%r8
mov    0x20(%rsp),%r9
call   1030 <boundaryvalues_no_slip@plt>
jmp    1230 <boundaryvalues+0xe0>
mov    %rbx,(%rsp)
mov    0x18(%rsp),%rdi
mov    %ebp,%esi
mov    %r12d,%edx
mov    %r15,%rcx
mov    %r14,%r8
mov    0x20(%rsp),%r9
call   1060 <boundaryvalues_free_slip@plt>
jmp    1230 <boundaryvalues+0xe0>
mov    %rbx,(%rsp)
mov    0x18(%rsp),%rdi
mov    %ebp,%esi
mov    %r12d,%edx
mov    %r15,%rcx
mov    %r14,%r8
mov    0x20(%rsp),%r9
call   1040 <boundaryvalues_outflow@plt>
jmp    1230 <boundaryvalues+0xe0>
mov    %rbx,(%rsp)
mov    0x18(%rsp),%rdi
mov    %ebp,%esi
mov    %r12d,%edx
mov    %r15,%rcx
mov    %r14,%r8
mov    %rbx,%r13
mov    0x20(%rsp),%rbx
mov    %rbx,%r9
call   1030 <boundaryvalues_no_slip@plt>
mov    %r13,(%rsp)
mov    0x18(%rsp),%rdi
mov    %ebp,%esi
mov    %r12d,%edx
mov    %r15,%rcx
mov    %r14,%r8
mov    %rbx,%r9
mov    %r13,%rbx
mov    0x48(%rsp),%r13
movsd  0x50(%rsp),%xmm0
call   1070 <boundaryvalues_inflow@plt>
jmp    1230 <boundaryvalues+0xe0>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @boundaryvalues(i32 %0, i32 %1, i32 %2, double*** %3, double*** %4, double*** %5, double*** nocapture readnone %6, i32 %7, i32 %8, i32 %9, i32 %10, i32 %11, i32 %12, double*** nocapture readnone %13, double*** nocapture readnone %14, double*** nocapture readnone %15, i8* nocapture readnone %16, i32*** %17, double %18, double* %19) {
%21 = icmp sgt i32 %0, -2
br i1 %21, label %22, label %90
22: ; preds = %20
%23 = icmp sgt i32 %1, -2
%24 = icmp sgt i32 %2, -2
%25 = add i32 %2, 2
%26 = add i32 %1, 2
%27 = add i32 %0, 2
%28 = zext i32 %27 to i64
%29 = zext i32 %26 to i64
%30 = zext i32 %25 to i64
br label %31
31: ; preds = %22, %87
%32 = phi i64 [ 0, %22 ], [ %88, %87 ]
br i1 %23, label %33, label %87
33: ; preds = %31
%34 = getelementptr inbounds i32**, i32*** %17, i64 %32
%35 = trunc i64 %32 to i32
%36 = trunc i64 %32 to i32
%37 = trunc i64 %32 to i32
%38 = trunc i64 %32 to i32
%39 = trunc i64 %32 to i32
br label %40
40: ; preds = %33, %84
%41 = phi i64 [ 0, %33 ], [ %85, %84 ]
br i1 %24, label %42, label %84
42: ; preds = %40
%43 = trunc i64 %41 to i32
%44 = trunc i64 %41 to i32
%45 = trunc i64 %41 to i32
%46 = trunc i64 %41 to i32
%47 = trunc i64 %41 to i32
br label %48
48: ; preds = %42, %81
%49 = phi i64 [ 0, %42 ], [ %82, %81 ]
%50 = load i32**, i32*** %34
%51 = getelementptr inbounds i32*, i32** %50, i64 %41
%52 = load i32*, i32** %51
%53 = getelementptr inbounds i32, i32* %52, i64 %49
%54 = load i32, i32* %53
%55 = ashr i32 %54, 12
%56 = ashr i32 %54, 13
%57 = and i32 %56, -2
%58 = srem i32 %55, 2
%59 = add nsw i32 %57, %58
%60 = lshr i32 %54, 13
%61 = xor i32 %55, %60
%62 = and i32 %61, 1
%63 = mul nuw nsw i32 %62, 5
%64 = add nsw i32 %59, %63
switch i32 %64, label %81 [
i32 0, label %65
i32 1, label %68
i32 3, label %71
i32 2, label %75
i32 4, label %78
]
65: ; preds = %48
%66 = trunc i64 %49 to i32
%67 = tail call i32 @boundaryvalues_no_slip(i32 %39, i32 %47, i32 %66, double*** %3, double*** %4, double*** %5, i32*** %17)
br label %81
68: ; preds = %48
%69 = trunc i64 %49 to i32
%70 = tail call i32 @boundaryvalues_free_slip(i32 %38, i32 %46, i32 %69, double*** %3, double*** %4, double*** %5, i32*** %17)
br label %81
71: ; preds = %48
%72 = trunc i64 %49 to i32
%73 = tail call i32 @boundaryvalues_no_slip(i32 %37, i32 %45, i32 %72, double*** %3, double*** %4, double*** %5, i32*** %17)
%74 = tail call i32 @boundaryvalues_inflow(i32 %37, i32 %45, i32 %72, double*** %3, double*** %4, double*** %5, i32*** %17, double %18)
br label %81
75: ; preds = %48
%76 = trunc i64 %49 to i32
%77 = tail call i32 @boundaryvalues_outflow(i32 %36, i32 %44, i32 %76, double*** %3, double*** %4, double*** %5, i32*** %17)
br label %81
78: ; preds = %48
%79 = trunc i64 %49 to i32
%80 = tail call i32 @boundaryvalues_moving_wall(i32 %35, i32 %43, i32 %79, double*** %3, double*** %4, double*** %5, i32*** %17, double* %19)
br label %81
81: ; preds = %65, %68, %71, %75, %78, %48
%82 = add nuw nsw i64 %49, 1
%83 = icmp eq i64 %82, %30
br i1 %83, label %84, label %48
84: ; preds = %81, %40
%85 = add nuw nsw i64 %41, 1
%86 = icmp eq i64 %85, %29
br i1 %86, label %87, label %40
87: ; preds = %84, %31
%88 = add nuw nsw i64 %32, 1
%89 = icmp eq i64 %88, %28
br i1 %89, label %90, label %31
90: ; preds = %87, %20
ret void
}