#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 *, char *);
void spec_boundary_val(char *problem, int imax, int jmax, double **U,
                       double **V, int **Flag, double vel) {
  if ((Flag[0][jmax / 2] & 32) == 0) {
    if (strcmp(problem, "KARMAN.pgm") != 0 ||
        strcmp(problem, "SHEAR.pgm") != 0) {
      for (int j = 1; j <= jmax; j++) {
        U[0][j] = vel;
        V[0][j] = -V[1][j];
      }
    } else if (strcmp(problem, "STEP.pgm") != 0) {
      for (int j = jmax / 2; j <= jmax; j++) {
        U[0][j] = vel;
        V[0][j] = -V[1][j];
      }
    }
  }
  for (int i = 1; i <= imax; i++) {
    for (int j = 1; j <= jmax; j++) {
      switch (Flag[i][j]) {
      case 1:
        V[i][j] = 0;
        U[i - 1][j] = -U[i - 1][j + 1];
        U[i][j] = -U[i][j + 1];
        break;
      case 8:
        U[i][j] = 0;
        V[i][j - 1] = -V[i + 1][j - 1];
        V[i][j] = -V[i + 1][j];
        break;
      case 2:
        V[i][j - 1] = 0;
        U[i - 1][j] = -U[i - 1][j - 1];
        U[i][j] = -U[i][j - 1];
        break;
      case 4:
        U[i - 1][j] = 0;
        V[i][j - 1] = -V[i - 1][j - 1];
        V[i][j] = -V[i - 1][j];
        break;
      case 9:
        V[i][j] = 0;
        U[i][j] = 0;
        U[i - 1][j] = -U[i - 1][j + 1];
        V[i][j - 1] = -V[i + 1][j - 1];
        break;
      case 5:
        V[i][j] = 0;
        U[i - 1][j] = 0;
        U[i][j] = -U[i][j + 1];
        V[i][j - 1] = -V[i - 1][j - 1];
        break;
      case 12:
        V[i][j - 1] = 0;
        U[i][j] = 0;
        U[i - 1][j] = -U[i - 1][j - 1];
        V[i][j] = -V[i + 1][j];
        break;
      case 6:
        V[i][j - 1] = 0;
        U[i - 1][j] = 0;
        U[i][j] = -U[i][j - 1];
        V[i][j] = -V[i - 1][j];
        break;
      case 0:
        V[i][j] = 0;
        U[i][j] = 0;
        break;
      }
    }
  }
  for (int i = 0; i <= imax + 1; i++) {
    if ((Flag[i][0] & 31) == 0) {
      V[i][0] = 0;
      U[i][0] = 0;
    }
    if ((Flag[i][jmax + 1] & 31) == 0) {
      V[i][jmax + 1] = 0;
      U[i][jmax + 1] = 0;
    }
  }
  for (int j = 0; j <= jmax + 1; j++) {
    if (Flag[0][j] == 0) {
      V[0][j] = 0;
      U[0][j] = 0;
    }
    if (Flag[imax + 1][j] == 0) {
      V[imax + 1][j] = 0;
      U[imax + 1][j] = 0;
    }
  }
}


x86 assembly (clang, -O0):
<spec_boundary_val>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
and    $0x20,%eax
cmp    $0x0,%eax
jne    12a6 <spec_boundary_val+0x196>
mov    -0x8(%rbp),%rdi
lea    0xec8(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1195 <spec_boundary_val+0x85>
mov    -0x8(%rbp),%rdi
lea    0xeb9(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1208 <spec_boundary_val+0xf8>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1203 <spec_boundary_val+0xf3>
movsd  -0x30(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
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    119c <spec_boundary_val+0x8c>
jmp    12a1 <spec_boundary_val+0x191>
mov    -0x8(%rbp),%rdi
lea    0xe36(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     129c <spec_boundary_val+0x18c>
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1297 <spec_boundary_val+0x187>
movsd  -0x30(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x38(%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 -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1230 <spec_boundary_val+0x120>
jmp    129c <spec_boundary_val+0x18c>
jmp    12a1 <spec_boundary_val+0x191>
jmp    12a6 <spec_boundary_val+0x196>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     196d <spec_boundary_val+0x85d>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     195a <spec_boundary_val+0x84a>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %rax,-0x58(%rbp)
sub    $0xc,%rax
ja     1947 <spec_boundary_val+0x837>
mov    -0x58(%rbp),%rax
lea    0xd08(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1947 <spec_boundary_val+0x837>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1947 <spec_boundary_val+0x837>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1947 <spec_boundary_val+0x837>
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1947 <spec_boundary_val+0x837>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1947 <spec_boundary_val+0x837>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1947 <spec_boundary_val+0x837>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1947 <spec_boundary_val+0x837>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1947 <spec_boundary_val+0x837>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    194c <spec_boundary_val+0x83c>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    12c0 <spec_boundary_val+0x1b0>
jmp    195f <spec_boundary_val+0x84f>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12ad <spec_boundary_val+0x19d>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1a36 <spec_boundary_val+0x926>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%eax
and    $0x1f,%eax
cmp    $0x0,%eax
jne    19c5 <spec_boundary_val+0x8b5>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
and    $0x1f,%eax
cmp    $0x0,%eax
jne    1a23 <spec_boundary_val+0x913>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1a28 <spec_boundary_val+0x918>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1974 <spec_boundary_val+0x864>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1af5 <spec_boundary_val+0x9e5>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x48(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1a89 <spec_boundary_val+0x979>
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x48(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x48(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1ae2 <spec_boundary_val+0x9d2>
mov    -0x20(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ae7 <spec_boundary_val+0x9d7>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1a3d <spec_boundary_val+0x92d>
add    $0x60,%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
mov    %r8,%r14
mov    %rcx,%r12
mov    %edx,%r15d
mov    %rsi,0x28(%rsp)
mov    %r9,0x18(%rsp)
mov    (%r9),%rax
mov    %edx,%r13d
shr    $0x1f,%r13d
add    %edx,%r13d
sar    %r13d
movslq %r13d,%rcx
testb  $0x20,(%rax,%rcx,4)
jne    134e <spec_boundary_val+0x23e>
mov    %rdi,%rbp
mov    %rcx,0x10(%rsp)
movaps %xmm0,0x30(%rsp)
lea    0xee2(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1184 <spec_boundary_val+0x74>
lea    0xedc(%rip),%rsi
mov    %rbp,%rdi
call   1030 <strcmp@plt>
test   %rax,%rax
je     16a0 <spec_boundary_val+0x590>
test   %r15d,%r15d
movaps 0x30(%rsp),%xmm4
jle    134e <spec_boundary_val+0x23e>
mov    (%r12),%rax
mov    (%r14),%rcx
mov    0x8(%r14),%rdx
mov    %r15d,%esi
lea    0x1(%rsi),%r10
mov    $0x1,%edi
cmp    $0x4,%r15d
jb     12e6 <spec_boundary_val+0x1d6>
mov    %rsi,0x20(%rsp)
lea    0x8(%rax),%rsi
lea    (%rax,%r10,8),%rbp
lea    0x8(%rcx),%r9
lea    (%rcx,%r10,8),%r13
lea    0x8(%rdx),%r8
lea    (%rdx,%r10,8),%r11
cmp    %r13,%rsi
setb   0x10(%rsp)
cmp    %rbp,%r9
setb   0xf(%rsp)
cmp    %r11,%rsi
setb   %sil
cmp    %rbp,%r8
setb   %bpl
cmp    %r11,%r9
setb   %r9b
cmp    %r13,%r8
setb   %r8b
mov    0xf(%rsp),%bl
test   %bl,0x10(%rsp)
jne    12e6 <spec_boundary_val+0x1d6>
and    %bpl,%sil
jne    12e6 <spec_boundary_val+0x1d6>
and    %r8b,%r9b
jne    12e6 <spec_boundary_val+0x1d6>
mov    0x20(%rsp),%r8
mov    %r8d,%edi
and    $0xfffffffc,%edi
movaps %xmm4,%xmm0
movlhps %xmm4,%xmm0
lea    -0x4(%rdi),%rsi
mov    %rsi,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     17fe <spec_boundary_val+0x6ee>
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
mov    $0x1,%ebp
movaps 0xda8(%rip),%xmm1
nopl   0x0(%rax,%rax,1)
movups %xmm0,(%rax,%rbp,8)
movups %xmm0,0x10(%rax,%rbp,8)
movups (%rdx,%rbp,8),%xmm2
movups 0x10(%rdx,%rbp,8),%xmm3
xorps  %xmm1,%xmm2
xorps  %xmm1,%xmm3
movups %xmm2,(%rcx,%rbp,8)
movups %xmm3,0x10(%rcx,%rbp,8)
movups %xmm0,0x20(%rax,%rbp,8)
movups %xmm0,0x30(%rax,%rbp,8)
movups 0x20(%rdx,%rbp,8),%xmm2
movups 0x30(%rdx,%rbp,8),%xmm3
xorps  %xmm1,%xmm2
xorps  %xmm1,%xmm3
movups %xmm2,0x20(%rcx,%rbp,8)
movups %xmm3,0x30(%rcx,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rsi
jne    1260 <spec_boundary_val+0x150>
test   $0x1,%r9b
je     12dd <spec_boundary_val+0x1cd>
movups %xmm0,(%rax,%rbp,8)
movups %xmm0,0x10(%rax,%rbp,8)
movups (%rdx,%rbp,8),%xmm0
movups 0x10(%rdx,%rbp,8),%xmm1
movaps 0xd32(%rip),%xmm2
xorps  %xmm2,%xmm0
xorps  %xmm2,%xmm1
movups %xmm0,(%rcx,%rbp,8)
movups %xmm1,0x10(%rcx,%rbp,8)
cmp    %rdi,%r8
je     134e <spec_boundary_val+0x23e>
or     $0x1,%rdi
mov    %rdi,%rsi
not    %rsi
test   $0x1,%r10b
jne    130b <spec_boundary_val+0x1fb>
movsd  %xmm4,(%rax,%rdi,8)
movsd  (%rdx,%rdi,8),%xmm0
xorps  0xcfd(%rip),%xmm0
movlps %xmm0,(%rcx,%rdi,8)
add    $0x1,%rdi
add    %r10,%rsi
je     134e <spec_boundary_val+0x23e>
movaps 0xce9(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movsd  %xmm4,(%rax,%rdi,8)
movsd  (%rdx,%rdi,8),%xmm1
xorps  %xmm0,%xmm1
movlps %xmm1,(%rcx,%rdi,8)
movsd  %xmm4,0x8(%rax,%rdi,8)
movsd  0x8(%rdx,%rdi,8),%xmm1
xorps  %xmm0,%xmm1
movlps %xmm1,0x8(%rcx,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r10
jne    1320 <spec_boundary_val+0x210>
mov    0x28(%rsp),%r13
test   %r13d,%r13d
jle    15a8 <spec_boundary_val+0x498>
lea    0x1(%r15),%eax
lea    0x1(%r13),%r8d
lea    -0x4(,%rax,4),%rcx
ff
mov    $0x1,%edx
lea    0xc98(%rip),%rsi
movaps 0xc81(%rip),%xmm0
mov    0x18(%rsp),%r11
jmp    139c <spec_boundary_val+0x28c>
cs nopw 0x0(%rax,%rax,1)
mov    %r9,%rdx
cmp    %r8,%r9
je     15a0 <spec_boundary_val+0x490>
test   %r15d,%r15d
jle    1590 <spec_boundary_val+0x480>
mov    (%r11,%rdx,8),%rbp
lea    0x1(%rdx),%r9
mov    %r9d,%r10d
xor    %edi,%edi
jmp    13fa <spec_boundary_val+0x2ea>
mov    (%r14,%rdx,8),%rax
movq   $0x0,(%rax,%rdi,2)
mov    (%r12,%rdx,8),%rbx
movq   $0x0,0x8(%rbx,%rdi,2)
mov    -0x8(%r12,%rdx,8),%rbx
movsd  (%rbx,%rdi,2),%xmm1
xorps  %xmm0,%xmm1
movlps %xmm1,0x8(%rbx,%rdi,2)
mov    (%r14,%r10,8),%rbx
movsd  0x8(%rbx,%rdi,2),%xmm1
xorps  %xmm0,%xmm1
movlps %xmm1,0x8(%rax,%rdi,2)
add    $0x4,%rdi
cmp    %rdi,%rcx
je     1390 <spec_boundary_val+0x280>
mov    0x4(%rbp,%rdi,1),%eax
cmp    $0xc,%rax
ja     13f1 <spec_boundary_val+0x2e1>
movslq (%rsi,%rax,4),%rax
add    %rsi,%rax
jmp    *%rax
mov    (%r14,%rdx,8),%rax
movq   $0x0,0x8(%rax,%rdi,2)
mov    (%r12,%rdx,8),%rax
movq   $0x0,0x8(%rax,%rdi,2)
jmp    13f1 <spec_boundary_val+0x2e1>
mov    (%r14,%rdx,8),%rax
movq   $0x0,0x8(%rax,%rdi,2)
mov    -0x8(%r12,%rdx,8),%rax
movsd  0x10(%rax,%rdi,2),%xmm1
xorps  %xmm0,%xmm1
movlps %xmm1,0x8(%rax,%rdi,2)
mov    (%r12,%rdx,8),%rax
movsd  0x10(%rax,%rdi,2),%xmm1
jmp    13e9 <spec_boundary_val+0x2d9>
mov    (%r14,%rdx,8),%rax
movq   $0x0,(%rax,%rdi,2)
mov    -0x8(%r12,%rdx,8),%rax
movsd  (%rax,%rdi,2),%xmm1
xorps  %xmm0,%xmm1
movlps %xmm1,0x8(%rax,%rdi,2)
mov    (%r12,%rdx,8),%rax
movsd  (%rax,%rdi,2),%xmm1
jmp    13e9 <spec_boundary_val+0x2d9>
mov    -0x8(%r12,%rdx,8),%rax
movq   $0x0,0x8(%rax,%rdi,2)
mov    -0x8(%r14,%rdx,8),%rax
mov    (%r14,%rdx,8),%rbx
movsd  (%rax,%rdi,2),%xmm1
xorps  %xmm0,%xmm1
jmp    152e <spec_boundary_val+0x41e>
mov    (%r14,%rdx,8),%rax
movq   $0x0,0x8(%rax,%rdi,2)
mov    -0x8(%r12,%rdx,8),%rbx
movq   $0x0,0x8(%rbx,%rdi,2)
mov    (%r12,%rdx,8),%rbx
movsd  0x10(%rbx,%rdi,2),%xmm1
xorps  %xmm0,%xmm1
movlps %xmm1,0x8(%rbx,%rdi,2)
mov    -0x8(%r14,%rdx,8),%rbx
jmp    1576 <spec_boundary_val+0x466>
mov    (%r14,%rdx,8),%rax
movq   $0x0,(%rax,%rdi,2)
mov    -0x8(%r12,%rdx,8),%rbx
movq   $0x0,0x8(%rbx,%rdi,2)
mov    (%r12,%rdx,8),%rbx
movsd  (%rbx,%rdi,2),%xmm1
xorps  %xmm0,%xmm1
movlps %xmm1,0x8(%rbx,%rdi,2)
mov    -0x8(%r14,%rdx,8),%rbx
jmp    13e3 <spec_boundary_val+0x2d3>
mov    (%r12,%rdx,8),%rax
movq   $0x0,0x8(%rax,%rdi,2)
mov    (%r14,%r10,8),%rax
movsd  (%rax,%rdi,2),%xmm1
xorps  %xmm0,%xmm1
mov    (%r14,%rdx,8),%rbx
movlps %xmm1,(%rbx,%rdi,2)
movsd  0x8(%rax,%rdi,2),%xmm1
xorps  %xmm0,%xmm1
movlps %xmm1,0x8(%rbx,%rdi,2)
jmp    13f1 <spec_boundary_val+0x2e1>
mov    (%r14,%rdx,8),%rax
movq   $0x0,0x8(%rax,%rdi,2)
mov    (%r12,%rdx,8),%rbx
movq   $0x0,0x8(%rbx,%rdi,2)
mov    -0x8(%r12,%rdx,8),%rbx
movsd  0x10(%rbx,%rdi,2),%xmm1
xorps  %xmm0,%xmm1
movlps %xmm1,0x8(%rbx,%rdi,2)
mov    (%r14,%r10,8),%rbx
movsd  (%rbx,%rdi,2),%xmm1
xorps  %xmm0,%xmm1
movlps %xmm1,(%rax,%rdi,2)
jmp    13f1 <spec_boundary_val+0x2e1>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdx
mov    %rdx,%r9
cmp    %r8,%r9
jne    139c <spec_boundary_val+0x28c>
cmp    $0xffffffff,%r13d
jge    15d0 <spec_boundary_val+0x4c0>
jmp    15b7 <spec_boundary_val+0x4a7>
lea    0x1(%r13),%r8d
mov    0x18(%rsp),%r11
cmp    $0xffffffff,%r13d
jge    15d0 <spec_boundary_val+0x4c0>
cmp    $0xffffffff,%r15d
jge    163e <spec_boundary_val+0x52e>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x1(%r15),%eax
cltq
xor    %ecx,%ecx
test   %r8d,%r8d
mov    $0x0,%edx
cmovg  %r8d,%edx
add    $0x1,%edx
jmp    1615 <spec_boundary_val+0x505>
nopl   0x0(%rax)
mov    (%r14,%rcx,8),%rdi
movq   $0x0,(%rdi)
mov    (%r12,%rcx,8),%rdi
movq   $0x0,(%rdi)
testb  $0x1f,(%rsi,%rax,4)
je     1624 <spec_boundary_val+0x514>
add    $0x1,%rcx
cmp    %rcx,%rdx
je     15b7 <spec_boundary_val+0x4a7>
mov    (%r11,%rcx,8),%rsi
testb  $0x1f,(%rsi)
je     15f0 <spec_boundary_val+0x4e0>
testb  $0x1f,(%rsi,%rax,4)
jne    160c <spec_boundary_val+0x4fc>
mov    (%r14,%rcx,8),%rsi
movq   $0x0,(%rsi,%rax,8)
mov    (%r12,%rcx,8),%rsi
movq   $0x0,(%rsi,%rax,8)
jmp    160c <spec_boundary_val+0x4fc>
mov    (%r11),%rax
movslq %r8d,%rcx
mov    (%r11,%rcx,8),%rdx
add    $0x2,%r15d
xor    %esi,%esi
jmp    167a <spec_boundary_val+0x56a>
mov    (%r14),%rdi
movq   $0x0,(%rdi,%rsi,8)
mov    (%r12),%rdi
movq   $0x0,(%rdi,%rsi,8)
cmpl   $0x0,(%rdx,%rsi,4)
je     1686 <spec_boundary_val+0x576>
add    $0x1,%rsi
cmp    %rsi,%r15
je     15c1 <spec_boundary_val+0x4b1>
cmpl   $0x0,(%rax,%rsi,4)
je     1650 <spec_boundary_val+0x540>
cmpl   $0x0,(%rdx,%rsi,4)
jne    166d <spec_boundary_val+0x55d>
mov    (%r14,%rcx,8),%rdi
movq   $0x0,(%rdi,%rsi,8)
mov    (%r12,%rcx,8),%rdi
movq   $0x0,(%rdi,%rsi,8)
jmp    166d <spec_boundary_val+0x55d>
lea    0x9b2(%rip),%rsi
mov    %rbp,%rdi
call   1030 <strcmp@plt>
test   %rax,%rax
movaps 0x30(%rsp),%xmm4
mov    0x10(%rsp),%rdi
je     134e <spec_boundary_val+0x23e>
cmp    %r15d,%r13d
jg     134e <spec_boundary_val+0x23e>
mov    (%r12),%r11
mov    (%r14),%r8
mov    0x8(%r14),%rdx
mov    %r15d,%r10d
sub    %r13d,%r10d
cmp    $0x3,%r10d
jb     1861 <spec_boundary_val+0x751>
lea    (%r11,%rdi,8),%rax
lea    (%r10,%rdi,1),%rcx
lea    (%r11,%rcx,8),%rsi
add    $0x8,%rsi
mov    %rdi,%rbp
lea    (%r8,%rdi,8),%rdi
lea    (%r8,%rcx,8),%r9
add    $0x8,%r9
lea    (%rdx,%rbp,8),%rbp
lea    (%rdx,%rcx,8),%rcx
add    $0x8,%rcx
cmp    %r9,%rax
setb   0xf(%rsp)
cmp    %rsi,%rdi
setb   %r13b
cmp    %rcx,%rax
setb   %al
cmp    %rsi,%rbp
setb   %sil
cmp    %rcx,%rdi
setb   %cl
cmp    %r9,%rbp
setb   %dil
test   %r13b,0xf(%rsp)
jne    1812 <spec_boundary_val+0x702>
and    %sil,%al
jne    1812 <spec_boundary_val+0x702>
and    %dil,%cl
jne    1812 <spec_boundary_val+0x702>
add    $0x1,%r10
mov    %r10,%r13
and    $0xfffffffffffffffc,%r13
movaps %xmm4,%xmm0
movlhps %xmm4,%xmm0
lea    -0x4(%r13),%rax
mov    %rax,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rax,%rax
je     1819 <spec_boundary_val+0x709>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
mov    0x10(%rsp),%rcx
lea    (%r8,%rcx,8),%rsi
add    $0x30,%rsi
lea    (%rdx,%rcx,8),%rax
add    $0x30,%rax
lea    (%r11,%rcx,8),%rcx
add    $0x30,%rcx
xor    %ebp,%ebp
movaps 0x853(%rip),%xmm1
movups %xmm0,-0x30(%rcx,%rbp,8)
movups %xmm0,-0x20(%rcx,%rbp,8)
movups -0x30(%rax,%rbp,8),%xmm2
movups -0x20(%rax,%rbp,8),%xmm3
xorps  %xmm1,%xmm2
xorps  %xmm1,%xmm3
movups %xmm2,-0x30(%rsi,%rbp,8)
movups %xmm3,-0x20(%rsi,%rbp,8)
movups %xmm0,-0x10(%rcx,%rbp,8)
movups %xmm0,(%rcx,%rbp,8)
movups -0x10(%rax,%rbp,8),%xmm2
movups (%rax,%rbp,8),%xmm3
xorps  %xmm1,%xmm2
xorps  %xmm1,%xmm3
movups %xmm2,-0x10(%rsi,%rbp,8)
movups %xmm3,(%rsi,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rdi
jne    17ad <spec_boundary_val+0x69d>
jmp    181b <spec_boundary_val+0x70b>
mov    $0x1,%ebp
test   $0x1,%r9b
jne    12b5 <spec_boundary_val+0x1a5>
jmp    12dd <spec_boundary_val+0x1cd>
mov    0x10(%rsp),%rdi
jmp    1861 <spec_boundary_val+0x751>
xor    %ebp,%ebp
test   $0x1,%r9b
mov    0x10(%rsp),%rdi
je     1855 <spec_boundary_val+0x745>
add    %rdi,%rbp
movups %xmm0,(%r11,%rbp,8)
movups %xmm0,0x10(%r11,%rbp,8)
movups (%rdx,%rbp,8),%xmm0
movups 0x10(%rdx,%rbp,8),%xmm1
movaps 0x7bc(%rip),%xmm2
xorps  %xmm2,%xmm0
xorps  %xmm2,%xmm1
movups %xmm0,(%r8,%rbp,8)
movups %xmm1,0x10(%r8,%rbp,8)
cmp    %r13,%r10
je     134e <spec_boundary_val+0x23e>
add    %r13,%rdi
lea    0x1(%r15),%ecx
mov    %ecx,%eax
sub    %edi,%eax
test   $0x1,%al
jne    1872 <spec_boundary_val+0x762>
mov    %rdi,%rax
jmp    1890 <spec_boundary_val+0x780>
movsd  %xmm4,(%r11,%rdi,8)
movsd  (%rdx,%rdi,8),%xmm0
xorps  0x77c(%rip),%xmm0
movlps %xmm0,(%r8,%rdi,8)
mov    %rdi,%rax
add    $0x1,%rax
cmp    %r15d,%edi
je     134e <spec_boundary_val+0x23e>
mov    %ecx,%ecx
movaps 0x75e(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm4,(%r11,%rax,8)
movsd  (%rdx,%rax,8),%xmm1
xorps  %xmm0,%xmm1
movlps %xmm1,(%r8,%rax,8)
movsd  %xmm4,0x8(%r11,%rax,8)
movsd  0x8(%rdx,%rax,8),%xmm1
xorps  %xmm0,%xmm1
movlps %xmm1,0x8(%r8,%rax,8)
add    $0x2,%rax
cmp    %eax,%ecx
jne    18b0 <spec_boundary_val+0x7a0>
jmp    134e <spec_boundary_val+0x23e>

LLVM IR (-O0):
@.str = [11 x i8] c"KARMAN.pgm\00"
@.str.1 = [10 x i8] c"SHEAR.pgm\00"
@.str.2 = [9 x i8] c"STEP.pgm\00"
define void @spec_boundary_val(i8* %0, i32 %1, i32 %2, double** %3, double** %4, i32** %5, double %6) {
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i32
%11 = alloca double**
%12 = alloca double**
%13 = alloca i32**
%14 = alloca double
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = 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 i32** %5, i32*** %13
store double %6, double* %14
%21 = load i32**, i32*** %13
%22 = getelementptr inbounds i32*, i32** %21, i64 0
%23 = load i32*, i32** %22
%24 = load i32, i32* %10
%25 = sdiv i32 %24, 2
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds i32, i32* %23, i64 %26
%28 = load i32, i32* %27
%29 = and i32 %28, 32
%30 = icmp eq i32 %29, 0
br i1 %30, label %31, label %109
31: ; preds = %7
%32 = load i8*, i8** %8
%33 = call i64 @strcmp(i8* %32, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i64 0, i64 0))
%34 = icmp ne i64 %33, 0
br i1 %34, label %39, label %35
35: ; preds = %31
%36 = load i8*, i8** %8
%37 = call i64 @strcmp(i8* %36, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0))
%38 = icmp ne i64 %37, 0
br i1 %38, label %39, label %70
39: ; preds = %35, %31
store i32 1, i32* %15
br label %40
40: ; preds = %66, %39
%41 = load i32, i32* %15
%42 = load i32, i32* %10
%43 = icmp sle i32 %41, %42
br i1 %43, label %44, label %69
44: ; preds = %40
%45 = load double, double* %14
%46 = load double**, double*** %11
%47 = getelementptr inbounds double*, double** %46, i64 0
%48 = load double*, double** %47
%49 = load i32, i32* %15
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds double, double* %48, i64 %50
store double %45, double* %51
%52 = load double**, double*** %12
%53 = getelementptr inbounds double*, double** %52, i64 1
%54 = load double*, double** %53
%55 = load i32, i32* %15
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds double, double* %54, i64 %56
%58 = load double, double* %57
%59 = fneg double %58
%60 = load double**, double*** %12
%61 = getelementptr inbounds double*, double** %60, i64 0
%62 = load double*, double** %61
%63 = load i32, i32* %15
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds double, double* %62, i64 %64
store double %59, double* %65
br label %66
66: ; preds = %44
%67 = load i32, i32* %15
%68 = add nsw i32 %67, 1
store i32 %68, i32* %15
br label %40
69: ; preds = %40
br label %108
70: ; preds = %35
%71 = load i8*, i8** %8
%72 = call i64 @strcmp(i8* %71, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0))
%73 = icmp ne i64 %72, 0
br i1 %73, label %74, label %107
74: ; preds = %70
%75 = load i32, i32* %10
%76 = sdiv i32 %75, 2
store i32 %76, i32* %16
br label %77
77: ; preds = %103, %74
%78 = load i32, i32* %16
%79 = load i32, i32* %10
%80 = icmp sle i32 %78, %79
br i1 %80, label %81, label %106
81: ; preds = %77
%82 = load double, double* %14
%83 = load double**, double*** %11
%84 = getelementptr inbounds double*, double** %83, i64 0
%85 = load double*, double** %84
%86 = load i32, i32* %16
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds double, double* %85, i64 %87
store double %82, double* %88
%89 = load double**, double*** %12
%90 = getelementptr inbounds double*, double** %89, i64 1
%91 = load double*, double** %90
%92 = load i32, i32* %16
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds double, double* %91, i64 %93
%95 = load double, double* %94
%96 = fneg double %95
%97 = load double**, double*** %12
%98 = getelementptr inbounds double*, double** %97, i64 0
%99 = load double*, double** %98
%100 = load i32, i32* %16
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds double, double* %99, i64 %101
store double %96, double* %102
br label %103
103: ; preds = %81
%104 = load i32, i32* %16
%105 = add nsw i32 %104, 1
store i32 %105, i32* %16
br label %77
106: ; preds = %77
br label %107
107: ; preds = %106, %70
br label %108
108: ; preds = %107, %69
br label %109
109: ; preds = %108, %7
store i32 1, i32* %17
br label %110
110: ; preds = %581, %109
%111 = load i32, i32* %17
%112 = load i32, i32* %9
%113 = icmp sle i32 %111, %112
br i1 %113, label %114, label %584
114: ; preds = %110
store i32 1, i32* %18
br label %115
115: ; preds = %577, %114
%116 = load i32, i32* %18
%117 = load i32, i32* %10
%118 = icmp sle i32 %116, %117
br i1 %118, label %119, label %580
119: ; preds = %115
%120 = load i32**, i32*** %13
%121 = load i32, i32* %17
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds i32*, i32** %120, i64 %122
%124 = load i32*, i32** %123
%125 = load i32, i32* %18
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds i32, i32* %124, i64 %126
%128 = load i32, i32* %127
switch i32 %128, label %576 [
i32 1, label %129
i32 8, label %178
i32 2, label %227
i32 4, label %277
i32 9, label %327
i32 5, label %386
i32 12, label %444
i32 6, label %502
i32 0, label %559
]
129: ; preds = %119
%130 = load double**, double*** %12
%131 = load i32, i32* %17
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds double*, double** %130, i64 %132
%134 = load double*, double** %133
%135 = load i32, i32* %18
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds double, double* %134, i64 %136
store double 0.000000e+00, double* %137
%138 = load double**, double*** %11
%139 = load i32, i32* %17
%140 = sub nsw i32 %139, 1
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds double*, double** %138, i64 %141
%143 = load double*, double** %142
%144 = load i32, i32* %18
%145 = add nsw i32 %144, 1
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds double, double* %143, i64 %146
%148 = load double, double* %147
%149 = fneg double %148
%150 = load double**, double*** %11
%151 = load i32, i32* %17
%152 = sub nsw i32 %151, 1
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds double*, double** %150, i64 %153
%155 = load double*, double** %154
%156 = load i32, i32* %18
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds double, double* %155, i64 %157
store double %149, double* %158
%159 = load double**, double*** %11
%160 = load i32, i32* %17
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds double*, double** %159, i64 %161
%163 = load double*, double** %162
%164 = load i32, i32* %18
%165 = add nsw i32 %164, 1
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds double, double* %163, i64 %166
%168 = load double, double* %167
%169 = fneg double %168
%170 = load double**, double*** %11
%171 = load i32, i32* %17
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds double*, double** %170, i64 %172
%174 = load double*, double** %173
%175 = load i32, i32* %18
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds double, double* %174, i64 %176
store double %169, double* %177
br label %576
178: ; preds = %119
%179 = load double**, double*** %11
%180 = load i32, i32* %17
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds double*, double** %179, i64 %181
%183 = load double*, double** %182
%184 = load i32, i32* %18
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds double, double* %183, i64 %185
store double 0.000000e+00, double* %186
%187 = load double**, double*** %12
%188 = load i32, i32* %17
%189 = add nsw i32 %188, 1
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds double*, double** %187, i64 %190
%192 = load double*, double** %191
%193 = load i32, i32* %18
%194 = sub nsw i32 %193, 1
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds double, double* %192, i64 %195
%197 = load double, double* %196
%198 = fneg double %197
%199 = load double**, double*** %12
%200 = load i32, i32* %17
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds double*, double** %199, i64 %201
%203 = load double*, double** %202
%204 = load i32, i32* %18
%205 = sub nsw i32 %204, 1
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds double, double* %203, i64 %206
store double %198, double* %207
%208 = load double**, double*** %12
%209 = load i32, i32* %17
%210 = add nsw i32 %209, 1
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds double*, double** %208, i64 %211
%213 = load double*, double** %212
%214 = load i32, i32* %18
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds double, double* %213, i64 %215
%217 = load double, double* %216
%218 = fneg double %217
%219 = load double**, double*** %12
%220 = load i32, i32* %17
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds double*, double** %219, i64 %221
%223 = load double*, double** %222
%224 = load i32, i32* %18
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds double, double* %223, i64 %225
store double %218, double* %226
br label %576
227: ; preds = %119
%228 = load double**, double*** %12
%229 = load i32, i32* %17
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds double*, double** %228, i64 %230
%232 = load double*, double** %231
%233 = load i32, i32* %18
%234 = sub nsw i32 %233, 1
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds double, double* %232, i64 %235
store double 0.000000e+00, double* %236
%237 = load double**, double*** %11
%238 = load i32, i32* %17
%239 = sub nsw i32 %238, 1
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds double*, double** %237, i64 %240
%242 = load double*, double** %241
%243 = load i32, i32* %18
%244 = sub nsw i32 %243, 1
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds double, double* %242, i64 %245
%247 = load double, double* %246
%248 = fneg double %247
%249 = load double**, double*** %11
%250 = load i32, i32* %17
%251 = sub nsw i32 %250, 1
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds double*, double** %249, i64 %252
%254 = load double*, double** %253
%255 = load i32, i32* %18
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds double, double* %254, i64 %256
store double %248, double* %257
%258 = load double**, double*** %11
%259 = load i32, i32* %17
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds double*, double** %258, i64 %260
%262 = load double*, double** %261
%263 = load i32, i32* %18
%264 = sub nsw i32 %263, 1
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds double, double* %262, i64 %265
%267 = load double, double* %266
%268 = fneg double %267
%269 = load double**, double*** %11
%270 = load i32, i32* %17
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds double*, double** %269, i64 %271
%273 = load double*, double** %272
%274 = load i32, i32* %18
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds double, double* %273, i64 %275
store double %268, double* %276
br label %576
277: ; preds = %119
%278 = load double**, double*** %11
%279 = load i32, i32* %17
%280 = sub nsw i32 %279, 1
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds double*, double** %278, i64 %281
%283 = load double*, double** %282
%284 = load i32, i32* %18
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds double, double* %283, i64 %285
store double 0.000000e+00, double* %286
%287 = load double**, double*** %12
%288 = load i32, i32* %17
%289 = sub nsw i32 %288, 1
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds double*, double** %287, i64 %290
%292 = load double*, double** %291
%293 = load i32, i32* %18
%294 = sub nsw i32 %293, 1
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds double, double* %292, i64 %295
%297 = load double, double* %296
%298 = fneg double %297
%299 = load double**, double*** %12
%300 = load i32, i32* %17
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds double*, double** %299, i64 %301
%303 = load double*, double** %302
%304 = load i32, i32* %18
%305 = sub nsw i32 %304, 1
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds double, double* %303, i64 %306
store double %298, double* %307
%308 = load double**, double*** %12
%309 = load i32, i32* %17
%310 = sub nsw i32 %309, 1
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds double*, double** %308, i64 %311
%313 = load double*, double** %312
%314 = load i32, i32* %18
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds double, double* %313, i64 %315
%317 = load double, double* %316
%318 = fneg double %317
%319 = load double**, double*** %12
%320 = load i32, i32* %17
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds double*, double** %319, i64 %321
%323 = load double*, double** %322
%324 = load i32, i32* %18
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds double, double* %323, i64 %325
store double %318, double* %326
br label %576
327: ; preds = %119
%328 = load double**, double*** %12
%329 = load i32, i32* %17
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds double*, double** %328, i64 %330
%332 = load double*, double** %331
%333 = load i32, i32* %18
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds double, double* %332, i64 %334
store double 0.000000e+00, double* %335
%336 = load double**, double*** %11
%337 = load i32, i32* %17
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds double*, double** %336, i64 %338
%340 = load double*, double** %339
%341 = load i32, i32* %18
%342 = sext i32 %341 to i64
%343 = getelementptr inbounds double, double* %340, i64 %342
store double 0.000000e+00, double* %343
%344 = load double**, double*** %11
%345 = load i32, i32* %17
%346 = sub nsw i32 %345, 1
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds double*, double** %344, i64 %347
%349 = load double*, double** %348
%350 = load i32, i32* %18
%351 = add nsw i32 %350, 1
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds double, double* %349, i64 %352
%354 = load double, double* %353
%355 = fneg double %354
%356 = load double**, double*** %11
%357 = load i32, i32* %17
%358 = sub nsw i32 %357, 1
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds double*, double** %356, i64 %359
%361 = load double*, double** %360
%362 = load i32, i32* %18
%363 = sext i32 %362 to i64
%364 = getelementptr inbounds double, double* %361, i64 %363
store double %355, double* %364
%365 = load double**, double*** %12
%366 = load i32, i32* %17
%367 = add nsw i32 %366, 1
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds double*, double** %365, i64 %368
%370 = load double*, double** %369
%371 = load i32, i32* %18
%372 = sub nsw i32 %371, 1
%373 = sext i32 %372 to i64
%374 = getelementptr inbounds double, double* %370, i64 %373
%375 = load double, double* %374
%376 = fneg double %375
%377 = load double**, double*** %12
%378 = load i32, i32* %17
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds double*, double** %377, i64 %379
%381 = load double*, double** %380
%382 = load i32, i32* %18
%383 = sub nsw i32 %382, 1
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds double, double* %381, i64 %384
store double %376, double* %385
br label %576
386: ; preds = %119
%387 = load double**, double*** %12
%388 = load i32, i32* %17
%389 = sext i32 %388 to i64
%390 = getelementptr inbounds double*, double** %387, i64 %389
%391 = load double*, double** %390
%392 = load i32, i32* %18
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds double, double* %391, i64 %393
store double 0.000000e+00, double* %394
%395 = load double**, double*** %11
%396 = load i32, i32* %17
%397 = sub nsw i32 %396, 1
%398 = sext i32 %397 to i64
%399 = getelementptr inbounds double*, double** %395, i64 %398
%400 = load double*, double** %399
%401 = load i32, i32* %18
%402 = sext i32 %401 to i64
%403 = getelementptr inbounds double, double* %400, i64 %402
store double 0.000000e+00, double* %403
%404 = load double**, double*** %11
%405 = load i32, i32* %17
%406 = sext i32 %405 to i64
%407 = getelementptr inbounds double*, double** %404, i64 %406
%408 = load double*, double** %407
%409 = load i32, i32* %18
%410 = add nsw i32 %409, 1
%411 = sext i32 %410 to i64
%412 = getelementptr inbounds double, double* %408, i64 %411
%413 = load double, double* %412
%414 = fneg double %413
%415 = load double**, double*** %11
%416 = load i32, i32* %17
%417 = sext i32 %416 to i64
%418 = getelementptr inbounds double*, double** %415, i64 %417
%419 = load double*, double** %418
%420 = load i32, i32* %18
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds double, double* %419, i64 %421
store double %414, double* %422
%423 = load double**, double*** %12
%424 = load i32, i32* %17
%425 = sub nsw i32 %424, 1
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds double*, double** %423, i64 %426
%428 = load double*, double** %427
%429 = load i32, i32* %18
%430 = sub nsw i32 %429, 1
%431 = sext i32 %430 to i64
%432 = getelementptr inbounds double, double* %428, i64 %431
%433 = load double, double* %432
%434 = fneg double %433
%435 = load double**, double*** %12
%436 = load i32, i32* %17
%437 = sext i32 %436 to i64
%438 = getelementptr inbounds double*, double** %435, i64 %437
%439 = load double*, double** %438
%440 = load i32, i32* %18
%441 = sub nsw i32 %440, 1
%442 = sext i32 %441 to i64
%443 = getelementptr inbounds double, double* %439, i64 %442
store double %434, double* %443
br label %576
444: ; preds = %119
%445 = load double**, double*** %12
%446 = load i32, i32* %17
%447 = sext i32 %446 to i64
%448 = getelementptr inbounds double*, double** %445, i64 %447
%449 = load double*, double** %448
%450 = load i32, i32* %18
%451 = sub nsw i32 %450, 1
%452 = sext i32 %451 to i64
%453 = getelementptr inbounds double, double* %449, i64 %452
store double 0.000000e+00, double* %453
%454 = load double**, double*** %11
%455 = load i32, i32* %17
%456 = sext i32 %455 to i64
%457 = getelementptr inbounds double*, double** %454, i64 %456
%458 = load double*, double** %457
%459 = load i32, i32* %18
%460 = sext i32 %459 to i64
%461 = getelementptr inbounds double, double* %458, i64 %460
store double 0.000000e+00, double* %461
%462 = load double**, double*** %11
%463 = load i32, i32* %17
%464 = sub nsw i32 %463, 1
%465 = sext i32 %464 to i64
%466 = getelementptr inbounds double*, double** %462, i64 %465
%467 = load double*, double** %466
%468 = load i32, i32* %18
%469 = sub nsw i32 %468, 1
%470 = sext i32 %469 to i64
%471 = getelementptr inbounds double, double* %467, i64 %470
%472 = load double, double* %471
%473 = fneg double %472
%474 = load double**, double*** %11
%475 = load i32, i32* %17
%476 = sub nsw i32 %475, 1
%477 = sext i32 %476 to i64
%478 = getelementptr inbounds double*, double** %474, i64 %477
%479 = load double*, double** %478
%480 = load i32, i32* %18
%481 = sext i32 %480 to i64
%482 = getelementptr inbounds double, double* %479, i64 %481
store double %473, double* %482
%483 = load double**, double*** %12
%484 = load i32, i32* %17
%485 = add nsw i32 %484, 1
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds double*, double** %483, i64 %486
%488 = load double*, double** %487
%489 = load i32, i32* %18
%490 = sext i32 %489 to i64
%491 = getelementptr inbounds double, double* %488, i64 %490
%492 = load double, double* %491
%493 = fneg double %492
%494 = load double**, double*** %12
%495 = load i32, i32* %17
%496 = sext i32 %495 to i64
%497 = getelementptr inbounds double*, double** %494, i64 %496
%498 = load double*, double** %497
%499 = load i32, i32* %18
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds double, double* %498, i64 %500
store double %493, double* %501
br label %576
502: ; preds = %119
%503 = load double**, double*** %12
%504 = load i32, i32* %17
%505 = sext i32 %504 to i64
%506 = getelementptr inbounds double*, double** %503, i64 %505
%507 = load double*, double** %506
%508 = load i32, i32* %18
%509 = sub nsw i32 %508, 1
%510 = sext i32 %509 to i64
%511 = getelementptr inbounds double, double* %507, i64 %510
store double 0.000000e+00, double* %511
%512 = load double**, double*** %11
%513 = load i32, i32* %17
%514 = sub nsw i32 %513, 1
%515 = sext i32 %514 to i64
%516 = getelementptr inbounds double*, double** %512, i64 %515
%517 = load double*, double** %516
%518 = load i32, i32* %18
%519 = sext i32 %518 to i64
%520 = getelementptr inbounds double, double* %517, i64 %519
store double 0.000000e+00, double* %520
%521 = load double**, double*** %11
%522 = load i32, i32* %17
%523 = sext i32 %522 to i64
%524 = getelementptr inbounds double*, double** %521, i64 %523
%525 = load double*, double** %524
%526 = load i32, i32* %18
%527 = sub nsw i32 %526, 1
%528 = sext i32 %527 to i64
%529 = getelementptr inbounds double, double* %525, i64 %528
%530 = load double, double* %529
%531 = fneg double %530
%532 = load double**, double*** %11
%533 = load i32, i32* %17
%534 = sext i32 %533 to i64
%535 = getelementptr inbounds double*, double** %532, i64 %534
%536 = load double*, double** %535
%537 = load i32, i32* %18
%538 = sext i32 %537 to i64
%539 = getelementptr inbounds double, double* %536, i64 %538
store double %531, double* %539
%540 = load double**, double*** %12
%541 = load i32, i32* %17
%542 = sub nsw i32 %541, 1
%543 = sext i32 %542 to i64
%544 = getelementptr inbounds double*, double** %540, i64 %543
%545 = load double*, double** %544
%546 = load i32, i32* %18
%547 = sext i32 %546 to i64
%548 = getelementptr inbounds double, double* %545, i64 %547
%549 = load double, double* %548
%550 = fneg double %549
%551 = load double**, double*** %12
%552 = load i32, i32* %17
%553 = sext i32 %552 to i64
%554 = getelementptr inbounds double*, double** %551, i64 %553
%555 = load double*, double** %554
%556 = load i32, i32* %18
%557 = sext i32 %556 to i64
%558 = getelementptr inbounds double, double* %555, i64 %557
store double %550, double* %558
br label %576
559: ; preds = %119
%560 = load double**, double*** %12
%561 = load i32, i32* %17
%562 = sext i32 %561 to i64
%563 = getelementptr inbounds double*, double** %560, i64 %562
%564 = load double*, double** %563
%565 = load i32, i32* %18
%566 = sext i32 %565 to i64
%567 = getelementptr inbounds double, double* %564, i64 %566
store double 0.000000e+00, double* %567
%568 = load double**, double*** %11
%569 = load i32, i32* %17
%570 = sext i32 %569 to i64
%571 = getelementptr inbounds double*, double** %568, i64 %570
%572 = load double*, double** %571
%573 = load i32, i32* %18
%574 = sext i32 %573 to i64
%575 = getelementptr inbounds double, double* %572, i64 %574
store double 0.000000e+00, double* %575
br label %576
576: ; preds = %119, %559, %502, %444, %386, %327, %277, %227, %178, %129
br label %577
577: ; preds = %576
%578 = load i32, i32* %18
%579 = add nsw i32 %578, 1
store i32 %579, i32* %18
br label %115
580: ; preds = %115
br label %581
581: ; preds = %580
%582 = load i32, i32* %17
%583 = add nsw i32 %582, 1
store i32 %583, i32* %17
br label %110
584: ; preds = %110
store i32 0, i32* %19
br label %585
585: ; preds = %646, %584
%586 = load i32, i32* %19
%587 = load i32, i32* %9
%588 = add nsw i32 %587, 1
%589 = icmp sle i32 %586, %588
br i1 %589, label %590, label %649
590: ; preds = %585
%591 = load i32**, i32*** %13
%592 = load i32, i32* %19
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds i32*, i32** %591, i64 %593
%595 = load i32*, i32** %594
%596 = getelementptr inbounds i32, i32* %595, i64 0
%597 = load i32, i32* %596
%598 = and i32 %597, 31
%599 = icmp eq i32 %598, 0
br i1 %599, label %600, label %613
600: ; preds = %590
%601 = load double**, double*** %12
%602 = load i32, i32* %19
%603 = sext i32 %602 to i64
%604 = getelementptr inbounds double*, double** %601, i64 %603
%605 = load double*, double** %604
%606 = getelementptr inbounds double, double* %605, i64 0
store double 0.000000e+00, double* %606
%607 = load double**, double*** %11
%608 = load i32, i32* %19
%609 = sext i32 %608 to i64
%610 = getelementptr inbounds double*, double** %607, i64 %609
%611 = load double*, double** %610
%612 = getelementptr inbounds double, double* %611, i64 0
store double 0.000000e+00, double* %612
br label %613
613: ; preds = %600, %590
%614 = load i32**, i32*** %13
%615 = load i32, i32* %19
%616 = sext i32 %615 to i64
%617 = getelementptr inbounds i32*, i32** %614, i64 %616
%618 = load i32*, i32** %617
%619 = load i32, i32* %10
%620 = add nsw i32 %619, 1
%621 = sext i32 %620 to i64
%622 = getelementptr inbounds i32, i32* %618, i64 %621
%623 = load i32, i32* %622
%624 = and i32 %623, 31
%625 = icmp eq i32 %624, 0
br i1 %625, label %626, label %645
626: ; preds = %613
%627 = load double**, double*** %12
%628 = load i32, i32* %19
%629 = sext i32 %628 to i64
%630 = getelementptr inbounds double*, double** %627, i64 %629
%631 = load double*, double** %630
%632 = load i32, i32* %10
%633 = add nsw i32 %632, 1
%634 = sext i32 %633 to i64
%635 = getelementptr inbounds double, double* %631, i64 %634
store double 0.000000e+00, double* %635
%636 = load double**, double*** %11
%637 = load i32, i32* %19
%638 = sext i32 %637 to i64
%639 = getelementptr inbounds double*, double** %636, i64 %638
%640 = load double*, double** %639
%641 = load i32, i32* %10
%642 = add nsw i32 %641, 1
%643 = sext i32 %642 to i64
%644 = getelementptr inbounds double, double* %640, i64 %643
store double 0.000000e+00, double* %644
br label %645
645: ; preds = %626, %613
br label %646
646: ; preds = %645
%647 = load i32, i32* %19
%648 = add nsw i32 %647, 1
store i32 %648, i32* %19
br label %585
649: ; preds = %585
store i32 0, i32* %20
br label %650
650: ; preds = %709, %649
%651 = load i32, i32* %20
%652 = load i32, i32* %10
%653 = add nsw i32 %652, 1
%654 = icmp sle i32 %651, %653
br i1 %654, label %655, label %712
655: ; preds = %650
%656 = load i32**, i32*** %13
%657 = getelementptr inbounds i32*, i32** %656, i64 0
%658 = load i32*, i32** %657
%659 = load i32, i32* %20
%660 = sext i32 %659 to i64
%661 = getelementptr inbounds i32, i32* %658, i64 %660
%662 = load i32, i32* %661
%663 = icmp eq i32 %662, 0
br i1 %663, label %664, label %677
664: ; preds = %655
%665 = load double**, double*** %12
%666 = getelementptr inbounds double*, double** %665, i64 0
%667 = load double*, double** %666
%668 = load i32, i32* %20
%669 = sext i32 %668 to i64
%670 = getelementptr inbounds double, double* %667, i64 %669
store double 0.000000e+00, double* %670
%671 = load double**, double*** %11
%672 = getelementptr inbounds double*, double** %671, i64 0
%673 = load double*, double** %672
%674 = load i32, i32* %20
%675 = sext i32 %674 to i64
%676 = getelementptr inbounds double, double* %673, i64 %675
store double 0.000000e+00, double* %676
br label %677
677: ; preds = %664, %655
%678 = load i32**, i32*** %13
%679 = load i32, i32* %9
%680 = add nsw i32 %679, 1
%681 = sext i32 %680 to i64
%682 = getelementptr inbounds i32*, i32** %678, i64 %681
%683 = load i32*, i32** %682
%684 = load i32, i32* %20
%685 = sext i32 %684 to i64
%686 = getelementptr inbounds i32, i32* %683, i64 %685
%687 = load i32, i32* %686
%688 = icmp eq i32 %687, 0
br i1 %688, label %689, label %708
689: ; preds = %677
%690 = load double**, double*** %12
%691 = load i32, i32* %9
%692 = add nsw i32 %691, 1
%693 = sext i32 %692 to i64
%694 = getelementptr inbounds double*, double** %690, i64 %693
%695 = load double*, double** %694
%696 = load i32, i32* %20
%697 = sext i32 %696 to i64
%698 = getelementptr inbounds double, double* %695, i64 %697
store double 0.000000e+00, double* %698
%699 = load double**, double*** %11
%700 = load i32, i32* %9
%701 = add nsw i32 %700, 1
%702 = sext i32 %701 to i64
%703 = getelementptr inbounds double*, double** %699, i64 %702
%704 = load double*, double** %703
%705 = load i32, i32* %20
%706 = sext i32 %705 to i64
%707 = getelementptr inbounds double, double* %704, i64 %706
store double 0.000000e+00, double* %707
br label %708
708: ; preds = %689, %677
br label %709
709: ; preds = %708
%710 = load i32, i32* %20
%711 = add nsw i32 %710, 1
store i32 %711, i32* %20
br label %650
712: ; preds = %650
ret void
}

LLVM IR (-O2):
@.str = [11 x i8] c"KARMAN.pgm\00"
@.str.1 = [10 x i8] c"SHEAR.pgm\00"
@.str.2 = [9 x i8] c"STEP.pgm\00"
define void @spec_boundary_val(i8* %0, i32 %1, i32 %2, double** %3, double** %4, i32** nocapture %5, double %6) {
%8 = load i32*, i32** %5
%9 = sdiv i32 %2, 2
%10 = sext i32 %9 to i64
%11 = getelementptr inbounds i32, i32* %8, i64 %10
%12 = load i32, i32* %11
%13 = and i32 %12, 32
%14 = icmp eq i32 %13, 0
br i1 %14, label %15, label %307
15: ; preds = %7
%16 = tail call i64 @strcmp(i8* %0, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i64 0, i64 0))
%17 = icmp eq i64 %16, 0
br i1 %17, label %18, label %21
18: ; preds = %15
%19 = tail call i64 @strcmp(i8* %0, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0))
%20 = icmp eq i64 %19, 0
br i1 %20, label %159, label %21
21: ; preds = %18, %15
%22 = icmp slt i32 %2, 1
br i1 %22, label %307, label %23
23: ; preds = %21
%24 = load double*, double** %3
%25 = getelementptr inbounds double*, double** %4, i64 1
%26 = load double*, double** %25
%27 = load double*, double** %4
%28 = add nuw i32 %2, 1
%29 = zext i32 %28 to i64
%30 = add nsw i64 %29, -1
%31 = icmp ult i64 %30, 4
br i1 %31, label %128, label %32
32: ; preds = %23
%33 = getelementptr double, double* %24, i64 1
%34 = getelementptr double, double* %24, i64 %29
%35 = getelementptr double, double* %27, i64 1
%36 = getelementptr double, double* %27, i64 %29
%37 = getelementptr double, double* %26, i64 1
%38 = getelementptr double, double* %26, i64 %29
%39 = icmp ult double* %33, %36
%40 = icmp ult double* %35, %34
%41 = and i1 %39, %40
%42 = icmp ult double* %33, %38
%43 = icmp ult double* %37, %34
%44 = and i1 %42, %43
%45 = or i1 %41, %44
%46 = icmp ult double* %35, %38
%47 = icmp ult double* %37, %36
%48 = and i1 %46, %47
%49 = or i1 %45, %48
br i1 %49, label %128, label %50
50: ; preds = %32
%51 = and i64 %30, -4
%52 = or i64 %51, 1
%53 = insertelement <2 x double> poison, double %6, i64 0
%54 = shufflevector <2 x double> %53, <2 x double> poison, <2 x i32> zeroinitializer
%55 = insertelement <2 x double> poison, double %6, i64 0
%56 = shufflevector <2 x double> %55, <2 x double> poison, <2 x i32> zeroinitializer
%57 = add nsw i64 %51, -4
%58 = lshr exact i64 %57, 2
%59 = add nuw nsw i64 %58, 1
%60 = and i64 %59, 1
%61 = icmp eq i64 %57, 0
br i1 %61, label %106, label %62
62: ; preds = %50
%63 = and i64 %59, 9223372036854775806
br label %64
64: ; preds = %64, %62
%65 = phi i64 [ 0, %62 ], [ %101, %64 ]
%66 = phi i64 [ 0, %62 ], [ %102, %64 ]
%67 = or i64 %65, 1
%68 = getelementptr inbounds double, double* %24, i64 %67
%69 = bitcast double* %68 to <2 x double>*
store <2 x double> %54, <2 x double>* %69
%70 = getelementptr inbounds double, double* %68, i64 2
%71 = bitcast double* %70 to <2 x double>*
store <2 x double> %56, <2 x double>* %71
%72 = getelementptr inbounds double, double* %26, i64 %67
%73 = bitcast double* %72 to <2 x double>*
%74 = load <2 x double>, <2 x double>* %73
%75 = getelementptr inbounds double, double* %72, i64 2
%76 = bitcast double* %75 to <2 x double>*
%77 = load <2 x double>, <2 x double>* %76
%78 = fneg <2 x double> %74
%79 = fneg <2 x double> %77
%80 = getelementptr inbounds double, double* %27, i64 %67
%81 = bitcast double* %80 to <2 x double>*
store <2 x double> %78, <2 x double>* %81
%82 = getelementptr inbounds double, double* %80, i64 2
%83 = bitcast double* %82 to <2 x double>*
store <2 x double> %79, <2 x double>* %83
%84 = or i64 %65, 5
%85 = getelementptr inbounds double, double* %24, i64 %84
%86 = bitcast double* %85 to <2 x double>*
store <2 x double> %54, <2 x double>* %86
%87 = getelementptr inbounds double, double* %85, i64 2
%88 = bitcast double* %87 to <2 x double>*
store <2 x double> %56, <2 x double>* %88
%89 = getelementptr inbounds double, double* %26, i64 %84
%90 = bitcast double* %89 to <2 x double>*
%91 = load <2 x double>, <2 x double>* %90
%92 = getelementptr inbounds double, double* %89, i64 2
%93 = bitcast double* %92 to <2 x double>*
%94 = load <2 x double>, <2 x double>* %93
%95 = fneg <2 x double> %91
%96 = fneg <2 x double> %94
%97 = getelementptr inbounds double, double* %27, i64 %84
%98 = bitcast double* %97 to <2 x double>*
store <2 x double> %95, <2 x double>* %98
%99 = getelementptr inbounds double, double* %97, i64 2
%100 = bitcast double* %99 to <2 x double>*
store <2 x double> %96, <2 x double>* %100
%101 = add nuw i64 %65, 8
%102 = add i64 %66, 2
%103 = icmp eq i64 %102, %63
br i1 %103, label %104, label %64
104: ; preds = %64
%105 = or i64 %101, 1
br label %106
106: ; preds = %104, %50
%107 = phi i64 [ 1, %50 ], [ %105, %104 ]
%108 = icmp eq i64 %60, 0
br i1 %108, label %126, label %109
109: ; preds = %106
%110 = getelementptr inbounds double, double* %24, i64 %107
%111 = bitcast double* %110 to <2 x double>*
store <2 x double> %54, <2 x double>* %111
%112 = getelementptr inbounds double, double* %110, i64 2
%113 = bitcast double* %112 to <2 x double>*
store <2 x double> %56, <2 x double>* %113
%114 = getelementptr inbounds double, double* %26, i64 %107
%115 = bitcast double* %114 to <2 x double>*
%116 = load <2 x double>, <2 x double>* %115
%117 = getelementptr inbounds double, double* %114, i64 2
%118 = bitcast double* %117 to <2 x double>*
%119 = load <2 x double>, <2 x double>* %118
%120 = fneg <2 x double> %116
%121 = fneg <2 x double> %119
%122 = getelementptr inbounds double, double* %27, i64 %107
%123 = bitcast double* %122 to <2 x double>*
store <2 x double> %120, <2 x double>* %123
%124 = getelementptr inbounds double, double* %122, i64 2
%125 = bitcast double* %124 to <2 x double>*
store <2 x double> %121, <2 x double>* %125
br label %126
126: ; preds = %106, %109
%127 = icmp eq i64 %30, %51
br i1 %127, label %307, label %128
128: ; preds = %32, %23, %126
%129 = phi i64 [ 1, %32 ], [ 1, %23 ], [ %52, %126 ]
%130 = xor i64 %129, -1
%131 = and i64 %29, 1
%132 = icmp eq i64 %131, 0
br i1 %132, label %133, label %140
133: ; preds = %128
%134 = getelementptr inbounds double, double* %24, i64 %129
store double %6, double* %134
%135 = getelementptr inbounds double, double* %26, i64 %129
%136 = load double, double* %135
%137 = fneg double %136
%138 = getelementptr inbounds double, double* %27, i64 %129
store double %137, double* %138
%139 = add nuw nsw i64 %129, 1
br label %140
140: ; preds = %133, %128
%141 = phi i64 [ %129, %128 ], [ %139, %133 ]
%142 = sub nsw i64 0, %29
%143 = icmp eq i64 %130, %142
br i1 %143, label %307, label %144
144: ; preds = %140, %144
%145 = phi i64 [ %157, %144 ], [ %141, %140 ]
%146 = getelementptr inbounds double, double* %24, i64 %145
store double %6, double* %146
%147 = getelementptr inbounds double, double* %26, i64 %145
%148 = load double, double* %147
%149 = fneg double %148
%150 = getelementptr inbounds double, double* %27, i64 %145
store double %149, double* %150
%151 = add nuw nsw i64 %145, 1
%152 = getelementptr inbounds double, double* %24, i64 %151
store double %6, double* %152
%153 = getelementptr inbounds double, double* %26, i64 %151
%154 = load double, double* %153
%155 = fneg double %154
%156 = getelementptr inbounds double, double* %27, i64 %151
store double %155, double* %156
%157 = add nuw nsw i64 %145, 2
%158 = icmp eq i64 %157, %29
br i1 %158, label %307, label %144
159: ; preds = %18
%160 = tail call i64 @strcmp(i8* %0, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0))
%161 = icmp eq i64 %160, 0
%162 = icmp sgt i32 %9, %2
%163 = or i1 %161, %162
br i1 %163, label %307, label %164
164: ; preds = %159
%165 = load double*, double** %3
%166 = getelementptr inbounds double*, double** %4, i64 1
%167 = load double*, double** %166
%168 = load double*, double** %4
%169 = add i32 %2, 1
%170 = sub i32 %2, %9
%171 = zext i32 %170 to i64
%172 = add nuw nsw i64 %171, 1
%173 = icmp ult i32 %170, 3
br i1 %173, label %274, label %174
174: ; preds = %164
%175 = getelementptr double, double* %165, i64 %10
%176 = sub i32 %2, %9
%177 = zext i32 %176 to i64
%178 = add nsw i64 %10, %177
%179 = add nsw i64 %178, 1
%180 = getelementptr double, double* %165, i64 %179
%181 = getelementptr double, double* %168, i64 %10
%182 = getelementptr double, double* %168, i64 %179
%183 = getelementptr double, double* %167, i64 %10
%184 = getelementptr double, double* %167, i64 %179
%185 = icmp ult double* %175, %182
%186 = icmp ult double* %181, %180
%187 = and i1 %185, %186
%188 = icmp ult double* %175, %184
%189 = icmp ult double* %183, %180
%190 = and i1 %188, %189
%191 = or i1 %187, %190
%192 = icmp ult double* %181, %184
%193 = icmp ult double* %183, %182
%194 = and i1 %192, %193
%195 = or i1 %191, %194
br i1 %195, label %274, label %196
196: ; preds = %174
%197 = and i64 %172, 8589934588
%198 = add nsw i64 %197, %10
%199 = insertelement <2 x double> poison, double %6, i64 0
%200 = shufflevector <2 x double> %199, <2 x double> poison, <2 x i32> zeroinitializer
%201 = insertelement <2 x double> poison, double %6, i64 0
%202 = shufflevector <2 x double> %201, <2 x double> poison, <2 x i32> zeroinitializer
%203 = add nsw i64 %197, -4
%204 = lshr exact i64 %203, 2
%205 = add nuw nsw i64 %204, 1
%206 = and i64 %205, 1
%207 = icmp eq i64 %203, 0
br i1 %207, label %251, label %208
208: ; preds = %196
%209 = and i64 %205, 9223372036854775806
br label %210
210: ; preds = %210, %208
%211 = phi i64 [ 0, %208 ], [ %248, %210 ]
%212 = phi i64 [ 0, %208 ], [ %249, %210 ]
%213 = add i64 %211, %10
%214 = getelementptr inbounds double, double* %165, i64 %213
%215 = bitcast double* %214 to <2 x double>*
store <2 x double> %200, <2 x double>* %215
%216 = getelementptr inbounds double, double* %214, i64 2
%217 = bitcast double* %216 to <2 x double>*
store <2 x double> %202, <2 x double>* %217
%218 = getelementptr inbounds double, double* %167, i64 %213
%219 = bitcast double* %218 to <2 x double>*
%220 = load <2 x double>, <2 x double>* %219
%221 = getelementptr inbounds double, double* %218, i64 2
%222 = bitcast double* %221 to <2 x double>*
%223 = load <2 x double>, <2 x double>* %222
%224 = fneg <2 x double> %220
%225 = fneg <2 x double> %223
%226 = getelementptr inbounds double, double* %168, i64 %213
%227 = bitcast double* %226 to <2 x double>*
store <2 x double> %224, <2 x double>* %227
%228 = getelementptr inbounds double, double* %226, i64 2
%229 = bitcast double* %228 to <2 x double>*
store <2 x double> %225, <2 x double>* %229
%230 = or i64 %211, 4
%231 = add i64 %230, %10
%232 = getelementptr inbounds double, double* %165, i64 %231
%233 = bitcast double* %232 to <2 x double>*
store <2 x double> %200, <2 x double>* %233
%234 = getelementptr inbounds double, double* %232, i64 2
%235 = bitcast double* %234 to <2 x double>*
store <2 x double> %202, <2 x double>* %235
%236 = getelementptr inbounds double, double* %167, i64 %231
%237 = bitcast double* %236 to <2 x double>*
%238 = load <2 x double>, <2 x double>* %237
%239 = getelementptr inbounds double, double* %236, i64 2
%240 = bitcast double* %239 to <2 x double>*
%241 = load <2 x double>, <2 x double>* %240
%242 = fneg <2 x double> %238
%243 = fneg <2 x double> %241
%244 = getelementptr inbounds double, double* %168, i64 %231
%245 = bitcast double* %244 to <2 x double>*
store <2 x double> %242, <2 x double>* %245
%246 = getelementptr inbounds double, double* %244, i64 2
%247 = bitcast double* %246 to <2 x double>*
store <2 x double> %243, <2 x double>* %247
%248 = add nuw i64 %211, 8
%249 = add i64 %212, 2
%250 = icmp eq i64 %249, %209
br i1 %250, label %251, label %210
251: ; preds = %210, %196
%252 = phi i64 [ 0, %196 ], [ %248, %210 ]
%253 = icmp eq i64 %206, 0
br i1 %253, label %272, label %254
254: ; preds = %251
%255 = add i64 %252, %10
%256 = getelementptr inbounds double, double* %165, i64 %255
%257 = bitcast double* %256 to <2 x double>*
store <2 x double> %200, <2 x double>* %257
%258 = getelementptr inbounds double, double* %256, i64 2
%259 = bitcast double* %258 to <2 x double>*
store <2 x double> %202, <2 x double>* %259
%260 = getelementptr inbounds double, double* %167, i64 %255
%261 = bitcast double* %260 to <2 x double>*
%262 = load <2 x double>, <2 x double>* %261
%263 = getelementptr inbounds double, double* %260, i64 2
%264 = bitcast double* %263 to <2 x double>*
%265 = load <2 x double>, <2 x double>* %264
%266 = fneg <2 x double> %262
%267 = fneg <2 x double> %265
%268 = getelementptr inbounds double, double* %168, i64 %255
%269 = bitcast double* %268 to <2 x double>*
store <2 x double> %266, <2 x double>* %269
%270 = getelementptr inbounds double, double* %268, i64 2
%271 = bitcast double* %270 to <2 x double>*
store <2 x double> %267, <2 x double>* %271
br label %272
272: ; preds = %251, %254
%273 = icmp eq i64 %172, %197
br i1 %273, label %307, label %274
274: ; preds = %174, %164, %272
%275 = phi i64 [ %10, %174 ], [ %10, %164 ], [ %198, %272 ]
%276 = add i32 %2, 1
%277 = trunc i64 %275 to i32
%278 = sub i32 %276, %277
%279 = and i32 %278, 1
%280 = icmp eq i32 %279, 0
br i1 %280, label %288, label %281
281: ; preds = %274
%282 = getelementptr inbounds double, double* %165, i64 %275
store double %6, double* %282
%283 = getelementptr inbounds double, double* %167, i64 %275
%284 = load double, double* %283
%285 = fneg double %284
%286 = getelementptr inbounds double, double* %168, i64 %275
store double %285, double* %286
%287 = add nsw i64 %275, 1
br label %288
288: ; preds = %281, %274
%289 = phi i64 [ %275, %274 ], [ %287, %281 ]
%290 = icmp eq i32 %277, %2
br i1 %290, label %307, label %291
291: ; preds = %288, %291
%292 = phi i64 [ %304, %291 ], [ %289, %288 ]
%293 = getelementptr inbounds double, double* %165, i64 %292
store double %6, double* %293
%294 = getelementptr inbounds double, double* %167, i64 %292
%295 = load double, double* %294
%296 = fneg double %295
%297 = getelementptr inbounds double, double* %168, i64 %292
store double %296, double* %297
%298 = add nsw i64 %292, 1
%299 = getelementptr inbounds double, double* %165, i64 %298
store double %6, double* %299
%300 = getelementptr inbounds double, double* %167, i64 %298
%301 = load double, double* %300
%302 = fneg double %301
%303 = getelementptr inbounds double, double* %168, i64 %298
store double %302, double* %303
%304 = add nsw i64 %292, 2
%305 = trunc i64 %304 to i32
%306 = icmp eq i32 %169, %305
br i1 %306, label %307, label %291
307: ; preds = %140, %144, %288, %291, %126, %272, %21, %159, %7
%308 = icmp slt i32 %1, 1
br i1 %308, label %309, label %311
309: ; preds = %307
%310 = add nsw i32 %1, 1
br label %332
311: ; preds = %307
%312 = icmp slt i32 %2, 1
%313 = add i32 %2, 1
%314 = add nuw i32 %1, 1
%315 = zext i32 %314 to i64
%316 = zext i32 %313 to i64
br label %317
317: ; preds = %311, %341
%318 = phi i64 [ 1, %311 ], [ %342, %341 ]
br i1 %312, label %319, label %321
319: ; preds = %317
%320 = add nuw nsw i64 %318, 1
br label %341
321: ; preds = %317
%322 = getelementptr inbounds i32*, i32** %5, i64 %318
%323 = load i32*, i32** %322
%324 = getelementptr inbounds double*, double** %4, i64 %318
%325 = getelementptr inbounds double*, double** %3, i64 %318
%326 = add nsw i64 %318, -1
%327 = getelementptr inbounds double*, double** %3, i64 %326
%328 = getelementptr inbounds double*, double** %4, i64 %326
%329 = add nuw nsw i64 %318, 1
%330 = and i64 %329, 4294967295
%331 = getelementptr inbounds double*, double** %4, i64 %330
br label %344
332: ; preds = %341, %309
%333 = phi i32 [ %310, %309 ], [ %314, %341 ]
%334 = icmp slt i32 %1, -1
br i1 %334, label %481, label %335
335: ; preds = %332
%336 = add nsw i32 %2, 1
%337 = sext i32 %336 to i64
%338 = call i32 @llvm.smax.i32(i32 %333, i32 0)
%339 = add nuw i32 %338, 1
%340 = zext i32 %339 to i64
br label %492
341: ; preds = %478, %319
%342 = phi i64 [ %320, %319 ], [ %329, %478 ]
%343 = icmp eq i64 %342, %315
br i1 %343, label %332, label %317
344: ; preds = %321, %478
%345 = phi i64 [ 1, %321 ], [ %479, %478 ]
%346 = getelementptr inbounds i32, i32* %323, i64 %345
%347 = load i32, i32* %346
switch i32 %347, label %478 [
i32 1, label %348
i32 8, label %363
i32 2, label %377
i32 4, label %391
i32 9, label %405
i32 5, label %423
i32 12, label %441
i32 6, label %457
i32 0, label %473
]
348: ; preds = %344
%349 = load double*, double** %324
%350 = getelementptr inbounds double, double* %349, i64 %345
store double 0.000000e+00, double* %350
%351 = load double*, double** %327
%352 = add nuw i64 %345, 1
%353 = and i64 %352, 4294967295
%354 = getelementptr inbounds double, double* %351, i64 %353
%355 = load double, double* %354
%356 = fneg double %355
%357 = getelementptr inbounds double, double* %351, i64 %345
store double %356, double* %357
%358 = load double*, double** %325
%359 = getelementptr inbounds double, double* %358, i64 %353
%360 = load double, double* %359
%361 = fneg double %360
%362 = getelementptr inbounds double, double* %358, i64 %345
store double %361, double* %362
br label %478
363: ; preds = %344
%364 = load double*, double** %325
%365 = getelementptr inbounds double, double* %364, i64 %345
store double 0.000000e+00, double* %365
%366 = load double*, double** %331
%367 = add nsw i64 %345, -1
%368 = getelementptr inbounds double, double* %366, i64 %367
%369 = load double, double* %368
%370 = fneg double %369
%371 = load double*, double** %324
%372 = getelementptr inbounds double, double* %371, i64 %367
store double %370, double* %372
%373 = getelementptr inbounds double, double* %366, i64 %345
%374 = load double, double* %373
%375 = fneg double %374
%376 = getelementptr inbounds double, double* %371, i64 %345
store double %375, double* %376
br label %478
377: ; preds = %344
%378 = load double*, double** %324
%379 = add nsw i64 %345, -1
%380 = getelementptr inbounds double, double* %378, i64 %379
store double 0.000000e+00, double* %380
%381 = load double*, double** %327
%382 = getelementptr inbounds double, double* %381, i64 %379
%383 = load double, double* %382
%384 = fneg double %383
%385 = getelementptr inbounds double, double* %381, i64 %345
store double %384, double* %385
%386 = load double*, double** %325
%387 = getelementptr inbounds double, double* %386, i64 %379
%388 = load double, double* %387
%389 = fneg double %388
%390 = getelementptr inbounds double, double* %386, i64 %345
store double %389, double* %390
br label %478
391: ; preds = %344
%392 = load double*, double** %327
%393 = getelementptr inbounds double, double* %392, i64 %345
store double 0.000000e+00, double* %393
%394 = load double*, double** %328
%395 = add nsw i64 %345, -1
%396 = getelementptr inbounds double, double* %394, i64 %395
%397 = load double, double* %396
%398 = fneg double %397
%399 = load double*, double** %324
%400 = getelementptr inbounds double, double* %399, i64 %395
store double %398, double* %400
%401 = getelementptr inbounds double, double* %394, i64 %345
%402 = load double, double* %401
%403 = fneg double %402
%404 = getelementptr inbounds double, double* %399, i64 %345
store double %403, double* %404
br label %478
405: ; preds = %344
%406 = load double*, double** %324
%407 = getelementptr inbounds double, double* %406, i64 %345
store double 0.000000e+00, double* %407
%408 = load double*, double** %325
%409 = getelementptr inbounds double, double* %408, i64 %345
store double 0.000000e+00, double* %409
%410 = load double*, double** %327
%411 = add nuw i64 %345, 1
%412 = and i64 %411, 4294967295
%413 = getelementptr inbounds double, double* %410, i64 %412
%414 = load double, double* %413
%415 = fneg double %414
%416 = getelementptr inbounds double, double* %410, i64 %345
store double %415, double* %416
%417 = load double*, double** %331
%418 = add nsw i64 %345, -1
%419 = getelementptr inbounds double, double* %417, i64 %418
%420 = load double, double* %419
%421 = fneg double %420
%422 = getelementptr inbounds double, double* %406, i64 %418
store double %421, double* %422
br label %478
423: ; preds = %344
%424 = load double*, double** %324
%425 = getelementptr inbounds double, double* %424, i64 %345
store double 0.000000e+00, double* %425
%426 = load double*, double** %327
%427 = getelementptr inbounds double, double* %426, i64 %345
store double 0.000000e+00, double* %427
%428 = load double*, double** %325
%429 = add nuw i64 %345, 1
%430 = and i64 %429, 4294967295
%431 = getelementptr inbounds double, double* %428, i64 %430
%432 = load double, double* %431
%433 = fneg double %432
%434 = getelementptr inbounds double, double* %428, i64 %345
store double %433, double* %434
%435 = load double*, double** %328
%436 = add nsw i64 %345, -1
%437 = getelementptr inbounds double, double* %435, i64 %436
%438 = load double, double* %437
%439 = fneg double %438
%440 = getelementptr inbounds double, double* %424, i64 %436
store double %439, double* %440
br label %478
441: ; preds = %344
%442 = load double*, double** %324
%443 = add nsw i64 %345, -1
%444 = getelementptr inbounds double, double* %442, i64 %443
store double 0.000000e+00, double* %444
%445 = load double*, double** %325
%446 = getelementptr inbounds double, double* %445, i64 %345
store double 0.000000e+00, double* %446
%447 = load double*, double** %327
%448 = getelementptr inbounds double, double* %447, i64 %443
%449 = load double, double* %448
%450 = fneg double %449
%451 = getelementptr inbounds double, double* %447, i64 %345
store double %450, double* %451
%452 = load double*, double** %331
%453 = getelementptr inbounds double, double* %452, i64 %345
%454 = load double, double* %453
%455 = fneg double %454
%456 = getelementptr inbounds double, double* %442, i64 %345
store double %455, double* %456
br label %478
457: ; preds = %344
%458 = load double*, double** %324
%459 = add nsw i64 %345, -1
%460 = getelementptr inbounds double, double* %458, i64 %459
store double 0.000000e+00, double* %460
%461 = load double*, double** %327
%462 = getelementptr inbounds double, double* %461, i64 %345
store double 0.000000e+00, double* %462
%463 = load double*, double** %325
%464 = getelementptr inbounds double, double* %463, i64 %459
%465 = load double, double* %464
%466 = fneg double %465
%467 = getelementptr inbounds double, double* %463, i64 %345
store double %466, double* %467
%468 = load double*, double** %328
%469 = getelementptr inbounds double, double* %468, i64 %345
%470 = load double, double* %469
%471 = fneg double %470
%472 = getelementptr inbounds double, double* %458, i64 %345
store double %471, double* %472
br label %478
473: ; preds = %344
%474 = load double*, double** %324
%475 = getelementptr inbounds double, double* %474, i64 %345
store double 0.000000e+00, double* %475
%476 = load double*, double** %325
%477 = getelementptr inbounds double, double* %476, i64 %345
store double 0.000000e+00, double* %477
br label %478
478: ; preds = %348, %363, %377, %391, %405, %423, %441, %457, %473, %344
%479 = add nuw nsw i64 %345, 1
%480 = icmp eq i64 %479, %316
br i1 %480, label %341, label %344
481: ; preds = %516, %332
%482 = icmp slt i32 %2, -1
br i1 %482, label %519, label %483
483: ; preds = %481
%484 = load i32*, i32** %5
%485 = sext i32 %333 to i64
%486 = getelementptr inbounds i32*, i32** %5, i64 %485
%487 = load i32*, i32** %486
%488 = getelementptr inbounds double*, double** %4, i64 %485
%489 = getelementptr inbounds double*, double** %3, i64 %485
%490 = add i32 %2, 2
%491 = zext i32 %490 to i64
br label %520
492: ; preds = %335, %516
%493 = phi i64 [ 0, %335 ], [ %517, %516 ]
%494 = getelementptr inbounds i32*, i32** %5, i64 %493
%495 = load i32*, i32** %494
%496 = load i32, i32* %495
%497 = and i32 %496, 31
%498 = icmp eq i32 %497, 0
br i1 %498, label %499, label %504
499: ; preds = %492
%500 = getelementptr inbounds double*, double** %4, i64 %493
%501 = load double*, double** %500
store double 0.000000e+00, double* %501
%502 = getelementptr inbounds double*, double** %3, i64 %493
%503 = load double*, double** %502
store double 0.000000e+00, double* %503
br label %504
504: ; preds = %499, %492
%505 = getelementptr inbounds i32, i32* %495, i64 %337
%506 = load i32, i32* %505
%507 = and i32 %506, 31
%508 = icmp eq i32 %507, 0
br i1 %508, label %509, label %516
509: ; preds = %504
%510 = getelementptr inbounds double*, double** %4, i64 %493
%511 = load double*, double** %510
%512 = getelementptr inbounds double, double* %511, i64 %337
store double 0.000000e+00, double* %512
%513 = getelementptr inbounds double*, double** %3, i64 %493
%514 = load double*, double** %513
%515 = getelementptr inbounds double, double* %514, i64 %337
store double 0.000000e+00, double* %515
br label %516
516: ; preds = %504, %509
%517 = add nuw nsw i64 %493, 1
%518 = icmp eq i64 %517, %340
br i1 %518, label %481, label %492
519: ; preds = %539, %481
ret void
520: ; preds = %483, %539
%521 = phi i64 [ 0, %483 ], [ %540, %539 ]
%522 = getelementptr inbounds i32, i32* %484, i64 %521
%523 = load i32, i32* %522
%524 = icmp eq i32 %523, 0
br i1 %524, label %525, label %530
525: ; preds = %520
%526 = load double*, double** %4
%527 = getelementptr inbounds double, double* %526, i64 %521
store double 0.000000e+00, double* %527
%528 = load double*, double** %3
%529 = getelementptr inbounds double, double* %528, i64 %521
store double 0.000000e+00, double* %529
br label %530
530: ; preds = %525, %520
%531 = getelementptr inbounds i32, i32* %487, i64 %521
%532 = load i32, i32* %531
%533 = icmp eq i32 %532, 0
br i1 %533, label %534, label %539
534: ; preds = %530
%535 = load double*, double** %488
%536 = getelementptr inbounds double, double* %535, i64 %521
store double 0.000000e+00, double* %536
%537 = load double*, double** %489
%538 = getelementptr inbounds double, double* %537, i64 %521
store double 0.000000e+00, double* %538
br label %539
539: ; preds = %530, %534
%540 = add nuw nsw i64 %521, 1
%541 = icmp eq i64 %540, %491
br i1 %541, label %519, label %520
}