#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__ strcmp(char const *, char *);
void spec_boundary_val(const char *problem, int imax, int jmax, double **U,
                       double **V, double UI, double VI) {
  int j;
  if (strcmp(problem, "Karman_vortex") == 0) {
    for (j = 1; j < jmax + 1; j++) {
      U[0][j] = UI;
      V[0][j] = 2 * VI - V[1][j];
    }
  } else if (strcmp(problem, "flow_over_a_step") == 0) {
    for (j = 1; j <= jmax / 2; j++) {
      U[0][j] = 0.0;
      V[0][j] = -V[1][j];
    }
    for (j = jmax / 2 + 1; j < jmax + 1; j++) {
      U[0][j] = UI;
      V[0][j] = 2 * VI - V[1][j];
    }
  }
}


x86 assembly (clang, -O0):
<spec_boundary_val>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
movsd  %xmm0,-0x28(%rbp)
movsd  %xmm1,-0x30(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xec1(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    11d3 <spec_boundary_val+0xc3>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    11ce <spec_boundary_val+0xbe>
movsd  -0x28(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1155 <spec_boundary_val+0x45>
jmp    12ff <spec_boundary_val+0x1ef>
mov    -0x8(%rbp),%rdi
lea    0xe30(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    12fa <spec_boundary_val+0x1ea>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x38(%rbp),%eax
cmp    %ecx,%eax
jg     126b <spec_boundary_val+0x15b>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11f4 <spec_boundary_val+0xe4>
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    12f5 <spec_boundary_val+0x1e5>
movsd  -0x28(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    127c <spec_boundary_val+0x16c>
jmp    12fa <spec_boundary_val+0x1ea>
jmp    12ff <spec_boundary_val+0x1ef>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<spec_boundary_val>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
movapd %xmm1,0x30(%rsp)
movapd %xmm0,0x20(%rsp)
mov    %r8,%r14
mov    %rcx,%r15
mov    %edx,%r12d
mov    %rdi,%rbx
lea    0xed3(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     12c4 <spec_boundary_val+0x1b4>
lea    0xecc(%rip),%rsi
mov    %rbx,%rdi
call   1030 <strcmp@plt>
test   %rax,%rax
movapd 0x30(%rsp),%xmm5
movapd 0x20(%rsp),%xmm6
jne    168c <spec_boundary_val+0x57c>
mov    %r12d,%r9d
shr    $0x1f,%r9d
add    %r12d,%r9d
sar    %r9d
cmp    $0x2,%r12d
jl     14f8 <spec_boundary_val+0x3e8>
mov    (%r15),%rcx
mov    (%r14),%rdx
mov    0x8(%r14),%rsi
lea    0x1(%r9),%r11d
lea    -0x1(%r11),%rax
mov    $0x1,%ebx
cmp    $0x4,%rax
jb     1480 <spec_boundary_val+0x370>
mov    %rax,0x18(%rsp)
lea    0x8(%rcx),%rax
lea    (%rcx,%r11,8),%rdi
lea    0x8(%rdx),%rbp
lea    (%rdx,%r11,8),%r13
lea    0x8(%rsi),%r8
lea    (%rsi,%r11,8),%r10
cmp    %r13,%rax
setb   0x10(%rsp)
cmp    %rdi,%rbp
setb   0xf(%rsp)
cmp    %r10,%rax
setb   0xe(%rsp)
cmp    %rdi,%r8
setb   0xd(%rsp)
cmp    %r10,%rbp
setb   %dil
cmp    %r13,%r8
setb   %bpl
mov    0xf(%rsp),%al
test   %al,0x10(%rsp)
jne    1480 <spec_boundary_val+0x370>
mov    0xd(%rsp),%al
and    %al,0xe(%rsp)
jne    1480 <spec_boundary_val+0x370>
and    %bpl,%dil
jne    1480 <spec_boundary_val+0x370>
mov    0x18(%rsp),%rbp
mov    %rbp,%rbx
and    $0xfffffffffffffffc,%rbx
lea    -0x4(%rbx),%rax
mov    %rax,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rax,%rax
je     1437 <spec_boundary_val+0x327>
mov    %r10,%rdi
and    $0xfffffffffffffffe,%rdi
mov    $0x1,%eax
xorpd  %xmm0,%xmm0
movapd 0xdad(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd %xmm0,(%rcx,%rax,8)
movupd %xmm0,0x10(%rcx,%rax,8)
movupd (%rsi,%rax,8),%xmm2
movupd 0x10(%rsi,%rax,8),%xmm3
xorpd  %xmm1,%xmm2
xorpd  %xmm1,%xmm3
movupd %xmm2,(%rdx,%rax,8)
movupd %xmm3,0x10(%rdx,%rax,8)
movupd %xmm0,0x20(%rcx,%rax,8)
movupd %xmm0,0x30(%rcx,%rax,8)
movupd 0x20(%rsi,%rax,8),%xmm2
movupd 0x30(%rsi,%rax,8),%xmm3
xorpd  %xmm1,%xmm2
xorpd  %xmm1,%xmm3
movupd %xmm2,0x20(%rdx,%rax,8)
movupd %xmm3,0x30(%rdx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdi
jne    1260 <spec_boundary_val+0x150>
jmp    143c <spec_boundary_val+0x32c>
test   %r12d,%r12d
movapd 0x30(%rsp),%xmm5
movapd 0x20(%rsp),%xmm6
jle    168c <spec_boundary_val+0x57c>
mov    (%r15),%rax
mov    (%r14),%rcx
mov    0x8(%r14),%rdx
mov    %r12d,%esi
lea    0x1(%rsi),%r9
mov    $0x1,%edi
cmp    $0x4,%r12d
jb     13c6 <spec_boundary_val+0x2b6>
mov    %rsi,0x10(%rsp)
lea    0x8(%rax),%rsi
lea    (%rax,%r9,8),%rbp
lea    0x8(%rcx),%r12
lea    (%rcx,%r9,8),%r11
lea    0x8(%rdx),%r15
lea    (%rdx,%r9,8),%rbx
cmp    %r11,%rsi
setb   %r13b
cmp    %rbp,%r12
setb   %r8b
cmp    %rbx,%rsi
setb   %r14b
cmp    %rbp,%r15
setb   %r10b
cmp    %rbx,%r12
setb   %sil
cmp    %r11,%r15
setb   %r11b
test   %r8b,%r13b
jne    13c6 <spec_boundary_val+0x2b6>
and    %r10b,%r14b
jne    13c6 <spec_boundary_val+0x2b6>
and    %r11b,%sil
jne    13c6 <spec_boundary_val+0x2b6>
mov    0x10(%rsp),%rbp
mov    %ebp,%ebx
and    $0xfffffffc,%ebx
lea    0x1(%rbx),%rdi
movapd %xmm6,%xmm0
unpcklpd %xmm6,%xmm0
movapd %xmm5,%xmm1
unpcklpd %xmm5,%xmm1
xor    %esi,%esi
addpd  %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
movupd %xmm0,0x8(%rax,%rsi,8)
movupd %xmm0,0x18(%rax,%rsi,8)
movupd 0x8(%rdx,%rsi,8),%xmm2
movupd 0x18(%rdx,%rsi,8),%xmm3
movapd %xmm1,%xmm4
subpd  %xmm2,%xmm4
movapd %xmm1,%xmm2
subpd  %xmm3,%xmm2
movupd %xmm4,0x8(%rcx,%rsi,8)
movupd %xmm2,0x18(%rcx,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rbx
jne    1380 <spec_boundary_val+0x270>
cmp    %rbx,%rbp
je     168c <spec_boundary_val+0x57c>
mov    %rdi,%rsi
not    %rsi
test   $0x1,%r9b
jne    13ed <spec_boundary_val+0x2dd>
movsd  %xmm6,(%rax,%rdi,8)
movapd %xmm5,%xmm0
addsd  %xmm5,%xmm0
subsd  (%rdx,%rdi,8),%xmm0
movsd  %xmm0,(%rcx,%rdi,8)
add    $0x1,%rdi
add    %r9,%rsi
je     168c <spec_boundary_val+0x57c>
addsd  %xmm5,%xmm5
nopw   0x0(%rax,%rax,1)
movsd  %xmm6,(%rax,%rdi,8)
movapd %xmm5,%xmm0
subsd  (%rdx,%rdi,8),%xmm0
movsd  %xmm0,(%rcx,%rdi,8)
movsd  %xmm6,0x8(%rax,%rdi,8)
movapd %xmm5,%xmm0
subsd  0x8(%rdx,%rdi,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r9
jne    1400 <spec_boundary_val+0x2f0>
jmp    168c <spec_boundary_val+0x57c>
mov    $0x1,%eax
test   $0x1,%r10b
je     1477 <spec_boundary_val+0x367>
xorpd  %xmm0,%xmm0
movupd %xmm0,(%rcx,%rax,8)
movupd %xmm0,0x10(%rcx,%rax,8)
movupd (%rsi,%rax,8),%xmm0
movupd 0x10(%rsi,%rax,8),%xmm1
movapd 0xb9c(%rip),%xmm2
xorpd  %xmm2,%xmm0
xorpd  %xmm2,%xmm1
movupd %xmm0,(%rdx,%rax,8)
movupd %xmm1,0x10(%rdx,%rax,8)
cmp    %rbx,%rbp
je     14f8 <spec_boundary_val+0x3e8>
or     $0x1,%rbx
mov    %rbx,%rax
not    %rax
test   $0x1,%r11b
jne    14aa <spec_boundary_val+0x39a>
movq   $0x0,(%rcx,%rbx,8)
movsd  (%rsi,%rbx,8),%xmm0
xorpd  0xb5f(%rip),%xmm0
movlpd %xmm0,(%rdx,%rbx,8)
add    $0x1,%rbx
add    %r11,%rax
je     14f8 <spec_boundary_val+0x3e8>
movapd 0xb49(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movq   $0x0,(%rcx,%rbx,8)
movsd  (%rsi,%rbx,8),%xmm1
xorpd  %xmm0,%xmm1
movlpd %xmm1,(%rdx,%rbx,8)
movq   $0x0,0x8(%rcx,%rbx,8)
movsd  0x8(%rsi,%rbx,8),%xmm1
xorpd  %xmm0,%xmm1
movlpd %xmm1,0x8(%rdx,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%r11
jne    14c0 <spec_boundary_val+0x3b0>
cmp    %r12d,%r9d
jge    168c <spec_boundary_val+0x57c>
mov    (%r15),%r15
mov    (%r14),%r13
mov    0x8(%r14),%rsi
movslq %r9d,%r9
movslq %r12d,%r10
mov    %r10,%r8
sub    %r9,%r8
cmp    $0x4,%r8
jb     1611 <spec_boundary_val+0x501>
lea    (%r15,%r9,8),%rax
add    $0x8,%rax
lea    0x8(%r15,%r10,8),%rcx
lea    0x8(%r13,%r9,8),%rdi
lea    0x8(,%r10,8),%rbp
add    %r13,%rbp
lea    (%rsi,%r9,8),%rbx
add    $0x8,%rbx
lea    (%rsi,%r10,8),%rdx
add    $0x8,%rdx
cmp    %rbp,%rax
setb   %r14b
cmp    %rcx,%rdi
setb   %r11b
cmp    %rdx,%rax
setb   %al
cmp    %rcx,%rbx
setb   0x10(%rsp)
cmp    %rdx,%rdi
setb   %cl
cmp    %rbp,%rbx
setb   %bl
test   %r11b,%r14b
jne    1611 <spec_boundary_val+0x501>
and    0x10(%rsp),%al
jne    1611 <spec_boundary_val+0x501>
and    %bl,%cl
jne    1611 <spec_boundary_val+0x501>
mov    %r8,%r11
and    $0xfffffffffffffffc,%r11
lea    (%r11,%r9,1),%rdi
movapd %xmm6,%xmm0
unpcklpd %xmm6,%xmm0
movapd %xmm5,%xmm1
unpcklpd %xmm5,%xmm1
lea    0x18(,%r9,8),%rax
add    %r13,%rax
lea    (%rsi,%r9,8),%rbx
add    $0x18,%rbx
lea    (%r15,%r9,8),%rcx
add    $0x18,%rcx
xor    %edx,%edx
addpd  %xmm1,%xmm1
nopl   (%rax)
movupd %xmm0,-0x10(%rcx,%rdx,8)
movupd %xmm0,(%rcx,%rdx,8)
movupd -0x10(%rbx,%rdx,8),%xmm2
movupd (%rbx,%rdx,8),%xmm3
movapd %xmm1,%xmm4
subpd  %xmm2,%xmm4
movapd %xmm1,%xmm2
subpd  %xmm3,%xmm2
movupd %xmm4,-0x10(%rax,%rdx,8)
movupd %xmm2,(%rax,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%r11
jne    15d0 <spec_boundary_val+0x4c0>
cmp    %r11,%r8
jne    1614 <spec_boundary_val+0x504>
jmp    168c <spec_boundary_val+0x57c>
mov    %r9,%rdi
sub    %edi,%r12d
mov    %rdi,%rax
not    %rax
test   $0x1,%r12b
je     1643 <spec_boundary_val+0x533>
movsd  %xmm6,0x8(%r15,%rdi,8)
movapd %xmm5,%xmm0
addsd  %xmm5,%xmm0
subsd  0x8(%rsi,%rdi,8),%xmm0
movsd  %xmm0,0x8(%r13,%rdi,8)
add    $0x1,%rdi
add    %r10,%rax
je     168c <spec_boundary_val+0x57c>
addsd  %xmm5,%xmm5
nopl   0x0(%rax)
movsd  %xmm6,0x8(%r15,%rdi,8)
movapd %xmm5,%xmm0
subsd  0x8(%rsi,%rdi,8),%xmm0
movsd  %xmm0,0x8(%r13,%rdi,8)
movsd  %xmm6,0x10(%r15,%rdi,8)
movapd %xmm5,%xmm0
subsd  0x10(%rsi,%rdi,8),%xmm0
movsd  %xmm0,0x10(%r13,%rdi,8)
lea    0x2(%rdi),%rax
mov    %rax,%rdi
cmp    %rax,%r10
jne    1650 <spec_boundary_val+0x540>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [14 x i8] c"Karman_vortex\00"
@.str.1 = [17 x i8] c"flow_over_a_step\00"
define void @spec_boundary_val(i8* %0, i32 %1, i32 %2, double** %3, double** %4, double %5, double %6) {
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i32
%11 = alloca double**
%12 = alloca double**
%13 = alloca double
%14 = alloca double
%15 = alloca i32
store i8* %0, i8** %8
store i32 %1, i32* %9
store i32 %2, i32* %10
store double** %3, double*** %11
store double** %4, double*** %12
store double %5, double* %13
store double %6, double* %14
%16 = load i8*, i8** %8
%17 = call i64 @strcmp(i8* %16, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0))
%18 = icmp eq i64 %17, 0
br i1 %18, label %19, label %53
19: ; preds = %7
store i32 1, i32* %15
br label %20
20: ; preds = %49, %19
%21 = load i32, i32* %15
%22 = load i32, i32* %10
%23 = add nsw i32 %22, 1
%24 = icmp slt i32 %21, %23
br i1 %24, label %25, label %52
25: ; preds = %20
%26 = load double, double* %13
%27 = load double**, double*** %11
%28 = getelementptr inbounds double*, double** %27, i64 0
%29 = load double*, double** %28
%30 = load i32, i32* %15
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds double, double* %29, i64 %31
store double %26, double* %32
%33 = load double, double* %14
%34 = load double**, double*** %12
%35 = getelementptr inbounds double*, double** %34, i64 1
%36 = load double*, double** %35
%37 = load i32, i32* %15
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds double, double* %36, i64 %38
%40 = load double, double* %39
%41 = fneg double %40
%42 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %33, double %41)
%43 = load double**, double*** %12
%44 = getelementptr inbounds double*, double** %43, i64 0
%45 = load double*, double** %44
%46 = load i32, i32* %15
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds double, double* %45, i64 %47
store double %42, double* %48
br label %49
49: ; preds = %25
%50 = load i32, i32* %15
%51 = add nsw i32 %50, 1
store i32 %51, i32* %15
br label %20
52: ; preds = %20
br label %125
53: ; preds = %7
%54 = load i8*, i8** %8
%55 = call i64 @strcmp(i8* %54, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.1, i64 0, i64 0))
%56 = icmp eq i64 %55, 0
br i1 %56, label %57, label %124
57: ; preds = %53
store i32 1, i32* %15
br label %58
58: ; preds = %84, %57
%59 = load i32, i32* %15
%60 = load i32, i32* %10
%61 = sdiv i32 %60, 2
%62 = icmp sle i32 %59, %61
br i1 %62, label %63, label %87
63: ; preds = %58
%64 = load double**, double*** %11
%65 = getelementptr inbounds double*, double** %64, i64 0
%66 = load double*, double** %65
%67 = load i32, i32* %15
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds double, double* %66, i64 %68
store double 0.000000e+00, double* %69
%70 = load double**, double*** %12
%71 = getelementptr inbounds double*, double** %70, i64 1
%72 = load double*, double** %71
%73 = load i32, i32* %15
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds double, double* %72, i64 %74
%76 = load double, double* %75
%77 = fneg double %76
%78 = load double**, double*** %12
%79 = getelementptr inbounds double*, double** %78, i64 0
%80 = load double*, double** %79
%81 = load i32, i32* %15
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds double, double* %80, i64 %82
store double %77, double* %83
br label %84
84: ; preds = %63
%85 = load i32, i32* %15
%86 = add nsw i32 %85, 1
store i32 %86, i32* %15
br label %58
87: ; preds = %58
%88 = load i32, i32* %10
%89 = sdiv i32 %88, 2
%90 = add nsw i32 %89, 1
store i32 %90, i32* %15
br label %91
91: ; preds = %120, %87
%92 = load i32, i32* %15
%93 = load i32, i32* %10
%94 = add nsw i32 %93, 1
%95 = icmp slt i32 %92, %94
br i1 %95, label %96, label %123
96: ; preds = %91
%97 = load double, double* %13
%98 = load double**, double*** %11
%99 = getelementptr inbounds double*, double** %98, i64 0
%100 = load double*, double** %99
%101 = load i32, i32* %15
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds double, double* %100, i64 %102
store double %97, double* %103
%104 = load double, double* %14
%105 = load double**, double*** %12
%106 = getelementptr inbounds double*, double** %105, i64 1
%107 = load double*, double** %106
%108 = load i32, i32* %15
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds double, double* %107, i64 %109
%111 = load double, double* %110
%112 = fneg double %111
%113 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %104, double %112)
%114 = load double**, double*** %12
%115 = getelementptr inbounds double*, double** %114, i64 0
%116 = load double*, double** %115
%117 = load i32, i32* %15
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds double, double* %116, i64 %118
store double %113, double* %119
br label %120
120: ; preds = %96
%121 = load i32, i32* %15
%122 = add nsw i32 %121, 1
store i32 %122, i32* %15
br label %91
123: ; preds = %91
br label %124
124: ; preds = %123, %53
br label %125
125: ; preds = %124, %52
ret void
}

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