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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ spec_boundary_val(char *, int, int, double **, double **,
                                     int **, double);
void boundaryvalues(int imax, int jmax, double **U, double **V, double **P,
                    int wl, int wr, int wt, int wb, double **F, double **G,
                    char *problem, int **Flag, double vel) {
  switch (wl) {
  case 1:
    for (int j = 1; j <= jmax; j++) {
      U[0][j] = 0.0;
      V[0][j] = -V[1][j];
    }
    break;
  case 2:
    for (int j = 1; j <= jmax; j++) {
      U[0][j] = 0.0;
      V[0][j] = V[1][j];
    }
    break;
  case 3:
    for (int j = 1; j <= jmax; j++) {
      U[0][j] = U[1][j];
      V[0][j] = V[1][j];
    }
    break;
  }
  switch (wr) {
  case 1:
    for (int j = 1; j <= jmax; j++) {
      U[imax][j] = 0.0;
      V[imax + 1][j] = -V[imax][j];
    }
    break;
  case 2:
    for (int j = 1; j <= jmax; j++) {
      U[imax][j] = 0.0;
      V[imax + 1][j] = V[imax][j];
    }
    break;
  case 3:
    for (int j = 1; j <= jmax; j++) {
      U[imax][j] = U[imax - 1][j];
      V[imax + 1][j] = V[imax][j];
    }
    break;
  }
  switch (wt) {
  case 1:
    for (int i = 1; i <= imax; i++) {
      V[i][jmax] = 0.0;
      U[i][jmax + 1] = -U[i][jmax];
    }
    break;
  case 2:
    for (int i = 1; i <= imax; i++) {
      V[i][jmax] = 0.0;
      U[i][jmax + 1] = U[i][jmax];
    }
    break;
  case 3:
    for (int i = 1; i <= imax; i++) {
      V[i][jmax] = V[i][jmax - 1];
      U[i][jmax + 1] = U[i][jmax];
    }
    break;
  }
  switch (wb) {
  case 1:
    for (int i = 1; i <= imax; i++) {
      V[i][0] = 0.0;
      U[i][0] = -U[i][1];
    }
    break;
  case 2:
    for (int i = 1; i <= imax; i++) {
      V[i][0] = 0.0;
      U[i][0] = U[i][1];
    }
    break;
  case 3:
    for (int i = 1; i <= imax; i++) {
      V[i][0] = V[i][1];
      U[i][0] = U[i][1];
    }
    break;
  }
  spec_boundary_val(problem, imax, jmax, U, V, Flag, vel);
}


x86 assembly (clang, -O0):
<boundaryvalues>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movsd  %xmm0,-0x30(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x64(%rbp)
sub    $0x1,%eax
je     1182 <boundaryvalues+0x72>
jmp    1160 <boundaryvalues+0x50>
mov    -0x64(%rbp),%eax
sub    $0x2,%eax
je     11f3 <boundaryvalues+0xe3>
jmp    1171 <boundaryvalues+0x61>
mov    -0x64(%rbp),%eax
sub    $0x3,%eax
je     124d <boundaryvalues+0x13d>
jmp    12b5 <boundaryvalues+0x1a5>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     11ee <boundaryvalues+0xde>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%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    -0x18(%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    1189 <boundaryvalues+0x79>
jmp    12b5 <boundaryvalues+0x1a5>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1248 <boundaryvalues+0x138>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%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    11fa <boundaryvalues+0xea>
jmp    12b5 <boundaryvalues+0x1a5>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     12b0 <boundaryvalues+0x1a0>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1254 <boundaryvalues+0x144>
jmp    12b5 <boundaryvalues+0x1a5>
mov    0x10(%rbp),%eax
mov    %eax,-0x68(%rbp)
sub    $0x1,%eax
je     12eb <boundaryvalues+0x1db>
jmp    12c9 <boundaryvalues+0x1b9>
mov    -0x68(%rbp),%eax
sub    $0x2,%eax
je     136f <boundaryvalues+0x25f>
jmp    12da <boundaryvalues+0x1ca>
mov    -0x68(%rbp),%eax
sub    $0x3,%eax
je     13dc <boundaryvalues+0x2cc>
jmp    1460 <boundaryvalues+0x350>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     136a <boundaryvalues+0x25a>
mov    -0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x4(%rbp),%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    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    12f2 <boundaryvalues+0x1e2>
jmp    1460 <boundaryvalues+0x350>
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     13d7 <boundaryvalues+0x2c7>
mov    -0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1376 <boundaryvalues+0x266>
jmp    1460 <boundaryvalues+0x350>
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     145b <boundaryvalues+0x34b>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    13e3 <boundaryvalues+0x2d3>
jmp    1460 <boundaryvalues+0x350>
mov    0x18(%rbp),%eax
mov    %eax,-0x6c(%rbp)
sub    $0x1,%eax
je     1496 <boundaryvalues+0x386>
jmp    1474 <boundaryvalues+0x364>
mov    -0x6c(%rbp),%eax
sub    $0x2,%eax
je     151a <boundaryvalues+0x40a>
jmp    1485 <boundaryvalues+0x375>
mov    -0x6c(%rbp),%eax
sub    $0x3,%eax
je     1587 <boundaryvalues+0x477>
jmp    160b <boundaryvalues+0x4fb>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1515 <boundaryvalues+0x405>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    149d <boundaryvalues+0x38d>
jmp    160b <boundaryvalues+0x4fb>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1582 <boundaryvalues+0x472>
mov    -0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1521 <boundaryvalues+0x411>
jmp    160b <boundaryvalues+0x4fb>
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1606 <boundaryvalues+0x4f6>
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    158e <boundaryvalues+0x47e>
jmp    160b <boundaryvalues+0x4fb>
mov    0x20(%rbp),%eax
mov    %eax,-0x70(%rbp)
sub    $0x1,%eax
je     1641 <boundaryvalues+0x531>
jmp    161f <boundaryvalues+0x50f>
mov    -0x70(%rbp),%eax
sub    $0x2,%eax
je     16b2 <boundaryvalues+0x5a2>
jmp    1630 <boundaryvalues+0x520>
mov    -0x70(%rbp),%eax
sub    $0x3,%eax
je     170c <boundaryvalues+0x5fc>
jmp    1774 <boundaryvalues+0x664>
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     16ad <boundaryvalues+0x59d>
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1648 <boundaryvalues+0x538>
jmp    1774 <boundaryvalues+0x664>
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1707 <boundaryvalues+0x5f7>
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    16b9 <boundaryvalues+0x5a9>
jmp    1774 <boundaryvalues+0x664>
movl   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     176f <boundaryvalues+0x65f>
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1713 <boundaryvalues+0x603>
jmp    1774 <boundaryvalues+0x664>
mov    0x38(%rbp),%rdi
mov    -0x4(%rbp),%esi
mov    -0x8(%rbp),%edx
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%r8
mov    0x40(%rbp),%r9
movsd  -0x30(%rbp),%xmm0
call   1030 <spec_boundary_val@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<boundaryvalues>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r9d,%eax
mov    %rcx,%r8
mov    %rdx,%rcx
mov    %esi,%r11d
mov    0x68(%rsp),%r9
mov    0x60(%rsp),%r10
mov    0x48(%rsp),%edx
mov    %edx,-0x4(%rsp)
mov    0x40(%rsp),%r14d
mov    0x38(%rsp),%r15d
cmp    $0x1,%eax
mov    %edi,-0x2c(%rsp)
je     11fe <boundaryvalues+0xee>
cmp    $0x2,%eax
je     134b <boundaryvalues+0x23b>
cmp    $0x3,%eax
jne    186a <boundaryvalues+0x75a>
test   %r11d,%r11d
jle    186a <boundaryvalues+0x75a>
mov    (%rcx),%r13
mov    0x8(%rcx),%rsi
mov    (%r8),%rbp
mov    0x8(%r8),%rbx
mov    %r11d,%edi
lea    0x1(%rdi),%r12
mov    $0x1,%eax
cmp    $0x4,%r11d
jae    148f <boundaryvalues+0x37f>
mov    %rax,%rdi
not    %rdi
test   $0x1,%r12b
jne    11b5 <boundaryvalues+0xa5>
movsd  (%rsi,%rax,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
add    $0x1,%rax
add    %r12,%rdi
je     186a <boundaryvalues+0x75a>
xchg   %ax,%ax
movsd  (%rsi,%rax,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
movsd  0x8(%rsi,%rax,8),%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x8(%rbp,%rax,8)
add    $0x2,%rax
cmp    %rax,%r12
jne    11c0 <boundaryvalues+0xb0>
jmp    186a <boundaryvalues+0x75a>
test   %r11d,%r11d
jle    186a <boundaryvalues+0x75a>
mov    (%rcx),%r13
mov    (%r8),%rsi
mov    0x8(%r8),%rbx
mov    %r11d,%eax
lea    0x1(%rax),%r12
mov    $0x1,%ebp
cmp    $0x4,%r11d
jb     16b1 <boundaryvalues+0x5a1>
mov    %rax,-0x28(%rsp)
mov    %r15d,-0x38(%rsp)
mov    %r14d,-0x58(%rsp)
mov    %r10,-0x40(%rsp)
mov    %r11,-0x50(%rsp)
mov    %r9,-0x48(%rsp)
lea    0x8(%r13),%rax
lea    0x0(%r13,%r12,8),%rdx
lea    0x8(%rsi),%r15
lea    (%rsi,%r12,8),%r11
lea    0x8(%rbx),%r14
lea    (%rbx,%r12,8),%rdi
cmp    %r11,%rax
setb   %r10b
cmp    %rdx,%r15
setb   %r9b
cmp    %rdi,%rax
setb   %al
cmp    %rdx,%r14
setb   %dl
cmp    %rdi,%r15
setb   %dil
cmp    %r11,%r14
setb   %r11b
test   %r9b,%r10b
jne    1631 <boundaryvalues+0x521>
and    %dl,%al
jne    1631 <boundaryvalues+0x521>
and    %r11b,%dil
mov    -0x48(%rsp),%r9
mov    -0x50(%rsp),%r11
mov    -0x40(%rsp),%r10
mov    -0x58(%rsp),%r14d
mov    -0x38(%rsp),%r15d
jne    16b1 <boundaryvalues+0x5a1>
mov    -0x28(%rsp),%rbp
and    $0xfffffffc,%ebp
lea    -0x4(%rbp),%rax
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rax,%rax
je     1660 <boundaryvalues+0x550>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %eax,%eax
xorps  %xmm1,%xmm1
movaps 0x1d14(%rip),%xmm2
nopl   0x0(%rax)
movups %xmm1,0x8(%r13,%rax,8)
movups %xmm1,0x18(%r13,%rax,8)
movups 0x8(%rbx,%rax,8),%xmm3
movups 0x18(%rbx,%rax,8),%xmm4
xorps  %xmm2,%xmm3
xorps  %xmm2,%xmm4
movups %xmm3,0x8(%rsi,%rax,8)
movups %xmm4,0x18(%rsi,%rax,8)
movups %xmm1,0x28(%r13,%rax,8)
movups %xmm1,0x38(%r13,%rax,8)
movups 0x28(%rbx,%rax,8),%xmm3
movups 0x38(%rbx,%rax,8),%xmm4
xorps  %xmm2,%xmm3
xorps  %xmm2,%xmm4
movups %xmm3,0x28(%rsi,%rax,8)
movups %xmm4,0x38(%rsi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdi
jne    12f0 <boundaryvalues+0x1e0>
jmp    1662 <boundaryvalues+0x552>
test   %r11d,%r11d
jle    186a <boundaryvalues+0x75a>
mov    (%rcx),%r13
mov    (%r8),%rsi
mov    0x8(%r8),%rbx
mov    %r11d,%eax
lea    0x1(%rax),%r12
mov    $0x1,%ebp
cmp    $0x4,%r11d
jb     176e <boundaryvalues+0x65e>
mov    %rax,-0x28(%rsp)
mov    %r15d,-0x38(%rsp)
mov    %r14d,-0x58(%rsp)
mov    %r10,-0x40(%rsp)
mov    %r11,-0x50(%rsp)
mov    %r9,-0x48(%rsp)
lea    0x8(%r13),%rax
lea    0x0(%r13,%r12,8),%rdx
lea    0x8(%rsi),%r15
lea    (%rsi,%r12,8),%r11
lea    0x8(%rbx),%r14
lea    (%rbx,%r12,8),%rdi
cmp    %r11,%rax
setb   %r10b
cmp    %rdx,%r15
setb   %r9b
cmp    %rdi,%rax
setb   %al
cmp    %rdx,%r14
setb   %dl
cmp    %rdi,%r15
setb   %dil
cmp    %r11,%r14
setb   %r11b
test   %r9b,%r10b
jne    1613 <boundaryvalues+0x503>
and    %dl,%al
jne    1613 <boundaryvalues+0x503>
and    %r11b,%dil
mov    -0x48(%rsp),%r9
mov    -0x50(%rsp),%r11
mov    -0x40(%rsp),%r10
mov    -0x58(%rsp),%r14d
mov    -0x38(%rsp),%r15d
jne    176e <boundaryvalues+0x65e>
mov    -0x28(%rsp),%rbp
and    $0xfffffffc,%ebp
lea    -0x4(%rbp),%rax
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rax,%rax
je     172a <boundaryvalues+0x61a>
mov    %rdx,%rax
and    $0xfffffffffffffffe,%rax
xor    %edi,%edi
xorps  %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups %xmm1,0x8(%r13,%rdi,8)
movups %xmm1,0x18(%r13,%rdi,8)
movups 0x8(%rbx,%rdi,8),%xmm2
movups 0x18(%rbx,%rdi,8),%xmm3
movups %xmm2,0x8(%rsi,%rdi,8)
movups %xmm3,0x18(%rsi,%rdi,8)
movups %xmm1,0x28(%r13,%rdi,8)
movups %xmm1,0x38(%r13,%rdi,8)
movups 0x28(%rbx,%rdi,8),%xmm2
movups 0x38(%rbx,%rdi,8),%xmm3
movups %xmm2,0x28(%rsi,%rdi,8)
movups %xmm3,0x38(%rsi,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rax
jne    1440 <boundaryvalues+0x330>
jmp    172c <boundaryvalues+0x61c>
mov    %rdi,-0x28(%rsp)
mov    %r15d,-0x38(%rsp)
mov    %r14d,-0x58(%rsp)
mov    %r10,-0x40(%rsp)
mov    %r11,-0x50(%rsp)
mov    %r9,-0x48(%rsp)
lea    0x8(%r13),%rdi
lea    0x0(%r13,%r12,8),%r10
lea    0x8(%rbp),%r11
lea    0x0(%rbp,%r12,8),%r9
lea    0x8(%rsi),%rdx
mov    %rdx,-0x20(%rsp)
lea    (%rsi,%r12,8),%r14
lea    0x8(%rbx),%rdx
mov    %rdx,-0x18(%rsp)
lea    (%rbx,%r12,8),%r15
cmp    %r9,%rdi
setb   -0x51(%rsp)
cmp    %r10,%r11
setb   -0x10(%rsp)
cmp    %r14,%rdi
setb   -0x52(%rsp)
mov    -0x20(%rsp),%rdx
cmp    %r10,%rdx
setb   -0x53(%rsp)
cmp    %r15,%rdi
setb   -0x2d(%rsp)
mov    -0x18(%rsp),%rdi
cmp    %r10,%rdi
setb   -0x2e(%rsp)
cmp    %r14,%r11
setb   %r10b
cmp    %r9,%rdx
setb   %r14b
cmp    %r15,%r11
setb   %r11b
cmp    %r9,%rdi
setb   %r9b
mov    -0x10(%rsp),%dl
test   %dl,-0x51(%rsp)
jne    2432 <boundaryvalues+0x1322>
mov    %r14d,%edi
mov    -0x53(%rsp),%dl
and    %dl,-0x52(%rsp)
mov    -0x58(%rsp),%r14d
mov    -0x38(%rsp),%r15d
jne    164c <boundaryvalues+0x53c>
mov    -0x2e(%rsp),%dl
and    %dl,-0x2d(%rsp)
jne    164c <boundaryvalues+0x53c>
and    %dil,%r10b
jne    164c <boundaryvalues+0x53c>
and    %r9b,%r11b
mov    -0x48(%rsp),%r9
mov    -0x50(%rsp),%r11
mov    -0x40(%rsp),%r10
jne    118e <boundaryvalues+0x7e>
mov    -0x28(%rsp),%rax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rdx
mov    %rdx,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rdx,%rdx
je     181d <boundaryvalues+0x70d>
mov    %r10,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %edi,%edi
movups 0x8(%rsi,%rdi,8),%xmm1
movups 0x18(%rsi,%rdi,8),%xmm2
movups %xmm1,0x8(%r13,%rdi,8)
movups %xmm2,0x18(%r13,%rdi,8)
movups 0x8(%rbx,%rdi,8),%xmm1
movups 0x18(%rbx,%rdi,8),%xmm2
movups %xmm1,0x8(%rbp,%rdi,8)
movups %xmm2,0x18(%rbp,%rdi,8)
movups 0x28(%rsi,%rdi,8),%xmm1
movups 0x38(%rsi,%rdi,8),%xmm2
movups %xmm1,0x28(%r13,%rdi,8)
movups %xmm2,0x38(%r13,%rdi,8)
movups 0x28(%rbx,%rdi,8),%xmm1
movups 0x38(%rbx,%rdi,8),%xmm2
movups %xmm1,0x28(%rbp,%rdi,8)
movups %xmm2,0x38(%rbp,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rdx
jne    15b0 <boundaryvalues+0x4a0>
jmp    181f <boundaryvalues+0x70f>
mov    -0x48(%rsp),%r9
mov    -0x50(%rsp),%r11
mov    -0x40(%rsp),%r10
mov    -0x58(%rsp),%r14d
mov    -0x38(%rsp),%r15d
jmp    176e <boundaryvalues+0x65e>
mov    -0x48(%rsp),%r9
mov    -0x50(%rsp),%r11
mov    -0x40(%rsp),%r10
mov    -0x58(%rsp),%r14d
mov    -0x38(%rsp),%r15d
jmp    16b1 <boundaryvalues+0x5a1>
mov    -0x48(%rsp),%r9
mov    -0x50(%rsp),%r11
mov    -0x40(%rsp),%r10
jmp    118e <boundaryvalues+0x7e>
xor    %eax,%eax
test   $0x1,%dl
je     169d <boundaryvalues+0x58d>
shl    $0x3,%rax
or     $0x8,%rax
xorps  %xmm1,%xmm1
movups %xmm1,0x0(%r13,%rax,1)
movups %xmm1,0x10(%r13,%rax,1)
movups (%rbx,%rax,1),%xmm1
movups 0x10(%rbx,%rax,1),%xmm2
movaps 0x1972(%rip),%xmm3
xorps  %xmm3,%xmm1
xorps  %xmm3,%xmm2
movups %xmm1,(%rsi,%rax,1)
movups %xmm2,0x10(%rsi,%rax,1)
cmp    %rbp,-0x28(%rsp)
mov    -0x58(%rsp),%r14d
je     186a <boundaryvalues+0x75a>
or     $0x1,%rbp
mov    %rbp,%rax
not    %rax
test   $0x1,%r12b
jne    16da <boundaryvalues+0x5ca>
movq   $0x0,0x0(%r13,%rbp,8)
movsd  (%rbx,%rbp,8),%xmm1
xorps  0x192e(%rip),%xmm1
movlps %xmm1,(%rsi,%rbp,8)
add    $0x1,%rbp
add    %r12,%rax
je     186a <boundaryvalues+0x75a>
movaps 0x1916(%rip),%xmm1
nopw   0x0(%rax,%rax,1)
movq   $0x0,0x0(%r13,%rbp,8)
movsd  (%rbx,%rbp,8),%xmm2
xorps  %xmm1,%xmm2
movlps %xmm2,(%rsi,%rbp,8)
movq   $0x0,0x8(%r13,%rbp,8)
movsd  0x8(%rbx,%rbp,8),%xmm2
xorps  %xmm1,%xmm2
movlps %xmm2,0x8(%rsi,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%r12
jne    16f0 <boundaryvalues+0x5e0>
jmp    186a <boundaryvalues+0x75a>
xor    %edi,%edi
test   $0x1,%dl
je     175a <boundaryvalues+0x64a>
shl    $0x3,%rdi
or     $0x8,%rdi
xorps  %xmm1,%xmm1
movups %xmm1,0x0(%r13,%rdi,1)
movups %xmm1,0x10(%r13,%rdi,1)
movups (%rbx,%rdi,1),%xmm1
movups 0x10(%rbx,%rdi,1),%xmm2
movups %xmm1,(%rsi,%rdi,1)
movups %xmm2,0x10(%rsi,%rdi,1)
cmp    %rbp,-0x28(%rsp)
mov    -0x58(%rsp),%r14d
je     186a <boundaryvalues+0x75a>
or     $0x1,%rbp
mov    %r12d,%edi
sub    %ebp,%edi
mov    %rbp,%rax
not    %rax
add    %r12,%rax
and    $0x3,%rdi
je     17ad <boundaryvalues+0x69d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movq   $0x0,0x0(%r13,%rbp,8)
movsd  (%rbx,%rbp,8),%xmm1
movsd  %xmm1,(%rsi,%rbp,8)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdi
jne    1790 <boundaryvalues+0x680>
cmp    $0x3,%rax
jb     186a <boundaryvalues+0x75a>
nopw   0x0(%rax,%rax,1)
movq   $0x0,0x0(%r13,%rbp,8)
movsd  (%rbx,%rbp,8),%xmm1
movsd  %xmm1,(%rsi,%rbp,8)
movq   $0x0,0x8(%r13,%rbp,8)
movsd  0x8(%rbx,%rbp,8),%xmm1
movsd  %xmm1,0x8(%rsi,%rbp,8)
movq   $0x0,0x10(%r13,%rbp,8)
movsd  0x10(%rbx,%rbp,8),%xmm1
movsd  %xmm1,0x10(%rsi,%rbp,8)
movq   $0x0,0x18(%r13,%rbp,8)
movsd  0x18(%rbx,%rbp,8),%xmm1
movsd  %xmm1,0x18(%rsi,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%r12
jne    17c0 <boundaryvalues+0x6b0>
jmp    186a <boundaryvalues+0x75a>
xor    %edi,%edi
test   $0x1,%r10b
je     1855 <boundaryvalues+0x745>
shl    $0x3,%rdi
or     $0x8,%rdi
movups (%rsi,%rdi,1),%xmm1
movups 0x10(%rsi,%rdi,1),%xmm2
movups %xmm1,0x0(%r13,%rdi,1)
movups %xmm2,0x10(%r13,%rdi,1)
movups (%rbx,%rdi,1),%xmm1
movups 0x10(%rbx,%rdi,1),%xmm2
movups %xmm1,0x0(%rbp,%rdi,1)
movups %xmm2,0x10(%rbp,%rdi,1)
cmp    %rax,-0x28(%rsp)
mov    -0x40(%rsp),%r10
mov    -0x58(%rsp),%r14d
jne    1d60 <boundaryvalues+0xc50>
cmp    $0x1,%r15d
je     1930 <boundaryvalues+0x820>
cmp    $0x2,%r15d
je     1a8b <boundaryvalues+0x97b>
cmp    $0x3,%r15d
jne    1f7b <boundaryvalues+0xe6b>
test   %r11d,%r11d
jle    1f7b <boundaryvalues+0xe6b>
mov    -0x2c(%rsp),%eax
cltq
mov    -0x8(%rcx,%rax,8),%r12
mov    (%rcx,%rax,8),%r13
mov    (%r8,%rax,8),%rbx
mov    0x8(%r8,%rax,8),%rbp
mov    %r11d,%esi
lea    0x1(%rsi),%r15
mov    $0x1,%eax
cmp    $0x4,%r11d
jae    1bcf <boundaryvalues+0xabf>
mov    %rax,%rsi
not    %rsi
test   $0x1,%r15b
jne    18e7 <boundaryvalues+0x7d7>
movsd  (%r12,%rax,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
add    $0x1,%rax
add    %r15,%rsi
je     1f7b <boundaryvalues+0xe6b>
movsd  (%r12,%rax,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x8(%rbp,%rax,8)
add    $0x2,%rax
cmp    %rax,%r15
jne    18f0 <boundaryvalues+0x7e0>
jmp    1f7b <boundaryvalues+0xe6b>
test   %r11d,%r11d
jle    1f7b <boundaryvalues+0xe6b>
mov    -0x2c(%rsp),%edx
movslq %edx,%rax
mov    (%rcx,%rax,8),%r12
mov    (%r8,%rax,8),%rsi
mov    0x8(%r8,%rax,8),%rbx
mov    %r11d,%eax
lea    0x1(%rax),%r15
mov    $0x1,%ebp
cmp    $0x4,%r11d
jb     1dcd <boundaryvalues+0xcbd>
mov    %rax,-0x38(%rsp)
mov    %r14d,-0x58(%rsp)
mov    %r10,-0x40(%rsp)
mov    %r11,-0x50(%rsp)
mov    %r9,-0x48(%rsp)
lea    0x8(%r12),%rax
lea    (%r12,%r15,8),%rdx
lea    0x8(%rbx),%r13
lea    (%rbx,%r15,8),%r11
lea    0x8(%rsi),%r14
lea    (%rsi,%r15,8),%rdi
cmp    %r11,%rax
setb   %r10b
cmp    %rdx,%r13
setb   %r9b
cmp    %rdi,%rax
setb   %al
cmp    %rdx,%r14
setb   %dl
cmp    %rdi,%r13
setb   %dil
cmp    %r11,%r14
setb   %r11b
test   %r9b,%r10b
jne    1d69 <boundaryvalues+0xc59>
and    %dl,%al
jne    1d69 <boundaryvalues+0xc59>
and    %r11b,%dil
mov    -0x48(%rsp),%r9
mov    -0x50(%rsp),%r11
mov    -0x40(%rsp),%r10
mov    -0x58(%rsp),%r14d
jne    1dcd <boundaryvalues+0xcbd>
mov    -0x38(%rsp),%r13
mov    %r13d,%ebp
and    $0xfffffffc,%ebp
lea    -0x4(%rbp),%rax
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rax,%rax
je     1d7f <boundaryvalues+0xc6f>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %eax,%eax
xorps  %xmm1,%xmm1
movaps 0x15df(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups %xmm1,0x8(%r12,%rax,8)
movups %xmm1,0x18(%r12,%rax,8)
movups 0x8(%rsi,%rax,8),%xmm3
movups 0x18(%rsi,%rax,8),%xmm4
xorps  %xmm2,%xmm3
xorps  %xmm2,%xmm4
movups %xmm3,0x8(%rbx,%rax,8)
movups %xmm4,0x18(%rbx,%rax,8)
movups %xmm1,0x28(%r12,%rax,8)
movups %xmm1,0x38(%r12,%rax,8)
movups 0x28(%rsi,%rax,8),%xmm3
movups 0x38(%rsi,%rax,8),%xmm4
xorps  %xmm2,%xmm3
xorps  %xmm2,%xmm4
movups %xmm3,0x28(%rbx,%rax,8)
movups %xmm4,0x38(%rbx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdi
jne    1a30 <boundaryvalues+0x920>
jmp    1d81 <boundaryvalues+0xc71>
test   %r11d,%r11d
jle    1f7b <boundaryvalues+0xe6b>
mov    -0x2c(%rsp),%edx
movslq %edx,%rax
mov    (%rcx,%rax,8),%r12
mov    (%r8,%rax,8),%rsi
mov    0x8(%r8,%rax,8),%rbx
mov    %r11d,%eax
lea    0x1(%rax),%r15
mov    $0x1,%ebp
cmp    $0x4,%r11d
jb     1e8a <boundaryvalues+0xd7a>
mov    %rax,-0x38(%rsp)
mov    %r14d,-0x58(%rsp)
mov    %r10,-0x40(%rsp)
mov    %r11,-0x50(%rsp)
mov    %r9,-0x48(%rsp)
lea    0x8(%r12),%rax
lea    (%r12,%r15,8),%rdx
lea    0x8(%rbx),%r13
lea    (%rbx,%r15,8),%r11
lea    0x8(%rsi),%r14
lea    (%rsi,%r15,8),%rdi
cmp    %r11,%rax
setb   %r10b
cmp    %rdx,%r13
setb   %r9b
cmp    %rdi,%rax
setb   %al
cmp    %rdx,%r14
setb   %dl
cmp    %rdi,%r13
setb   %dil
cmp    %r11,%r14
setb   %r11b
test   %r9b,%r10b
jne    1d47 <boundaryvalues+0xc37>
and    %dl,%al
jne    1d47 <boundaryvalues+0xc37>
and    %r11b,%dil
mov    -0x48(%rsp),%r9
mov    -0x50(%rsp),%r11
mov    -0x40(%rsp),%r10
mov    -0x58(%rsp),%r14d
jne    1e8a <boundaryvalues+0xd7a>
mov    -0x38(%rsp),%r13
mov    %r13d,%ebp
and    $0xfffffffc,%ebp
lea    -0x4(%rbp),%rax
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rax,%rax
je     1e49 <boundaryvalues+0xd39>
mov    %rdx,%rax
and    $0xfffffffffffffffe,%rax
xor    %edi,%edi
xorps  %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movups %xmm1,0x8(%r12,%rdi,8)
movups %xmm1,0x18(%r12,%rdi,8)
movups 0x8(%rsi,%rdi,8),%xmm2
movups 0x18(%rsi,%rdi,8),%xmm3
movups %xmm2,0x8(%rbx,%rdi,8)
movups %xmm3,0x18(%rbx,%rdi,8)
movups %xmm1,0x28(%r12,%rdi,8)
movups %xmm1,0x38(%r12,%rdi,8)
movups 0x28(%rsi,%rdi,8),%xmm2
movups 0x38(%rsi,%rdi,8),%xmm3
movups %xmm2,0x28(%rbx,%rdi,8)
movups %xmm3,0x38(%rbx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rax
jne    1b80 <boundaryvalues+0xa70>
jmp    1e4b <boundaryvalues+0xd3b>
mov    %rsi,-0x38(%rsp)
mov    %r14d,-0x58(%rsp)
mov    %r10,-0x40(%rsp)
mov    %r11,-0x50(%rsp)
mov    %r9,-0x48(%rsp)
lea    0x8(%r13),%rdx
lea    0x0(%r13,%r15,8),%rdi
lea    0x8(%rbp),%r10
lea    0x0(%rbp,%r15,8),%r14
lea    0x8(%r12),%r11
lea    (%r12,%r15,8),%r9
lea    0x8(%rbx),%rsi
mov    %rsi,-0x10(%rsp)
lea    (%rbx,%r15,8),%rsi
cmp    %r14,%rdx
setb   -0x28(%rsp)
cmp    %rdi,%r10
setb   -0x51(%rsp)
cmp    %r9,%rdx
setb   -0x18(%rsp)
cmp    %rdi,%r11
setb   -0x20(%rsp)
cmp    %rsi,%rdx
setb   -0x52(%rsp)
mov    -0x10(%rsp),%rdx
cmp    %rdi,%rdx
setb   %dil
cmp    %r9,%r10
setb   %r9b
cmp    %r14,%r11
setb   -0x53(%rsp)
cmp    %rsi,%r10
setb   %r11b
cmp    %r14,%rdx
setb   %sil
mov    -0x51(%rsp),%dl
test   %dl,-0x28(%rsp)
jne    2450 <boundaryvalues+0x1340>
mov    -0x20(%rsp),%dl
and    %dl,-0x18(%rsp)
mov    -0x40(%rsp),%r10
jne    241e <boundaryvalues+0x130e>
and    %dil,-0x52(%rsp)
jne    241e <boundaryvalues+0x130e>
and    -0x53(%rsp),%r9b
mov    -0x58(%rsp),%r14d
jne    240f <boundaryvalues+0x12ff>
and    %sil,%r11b
mov    -0x48(%rsp),%r9
mov    -0x50(%rsp),%r11
jne    18bf <boundaryvalues+0x7af>
mov    -0x38(%rsp),%rax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rdx
mov    %rdx,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rdx,%rdx
je     1f2c <boundaryvalues+0xe1c>
mov    %r10,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movups 0x8(%r12,%rdi,8),%xmm1
movups 0x18(%r12,%rdi,8),%xmm2
movups %xmm1,0x8(%r13,%rdi,8)
movups %xmm2,0x18(%r13,%rdi,8)
movups 0x8(%rbx,%rdi,8),%xmm1
movups 0x18(%rbx,%rdi,8),%xmm2
movups %xmm1,0x8(%rbp,%rdi,8)
movups %xmm2,0x18(%rbp,%rdi,8)
movups 0x28(%r12,%rdi,8),%xmm1
movups 0x38(%r12,%rdi,8),%xmm2
movups %xmm1,0x28(%r13,%rdi,8)
movups %xmm2,0x38(%r13,%rdi,8)
movups 0x28(%rbx,%rdi,8),%xmm1
movups 0x38(%rbx,%rdi,8),%xmm2
movups %xmm1,0x28(%rbp,%rdi,8)
movups %xmm2,0x38(%rbp,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1ce0 <boundaryvalues+0xbd0>
jmp    1f2e <boundaryvalues+0xe1e>
mov    -0x48(%rsp),%r9
mov    -0x50(%rsp),%r11
mov    -0x40(%rsp),%r10
mov    -0x58(%rsp),%r14d
jmp    1e8a <boundaryvalues+0xd7a>
or     $0x1,%rax
jmp    118e <boundaryvalues+0x7e>
mov    -0x48(%rsp),%r9
mov    -0x50(%rsp),%r11
mov    -0x40(%rsp),%r10
mov    -0x58(%rsp),%r14d
jmp    1dcd <boundaryvalues+0xcbd>
xor    %eax,%eax
test   $0x1,%dl
je     1dbb <boundaryvalues+0xcab>
shl    $0x3,%rax
or     $0x8,%rax
xorps  %xmm1,%xmm1
movups %xmm1,(%r12,%rax,1)
movups %xmm1,0x10(%r12,%rax,1)
movups (%rsi,%rax,1),%xmm1
movups 0x10(%rsi,%rax,1),%xmm2
movaps 0x1254(%rip),%xmm3
xorps  %xmm3,%xmm1
xorps  %xmm3,%xmm2
movups %xmm1,(%rbx,%rax,1)
movups %xmm2,0x10(%rbx,%rax,1)
cmp    %rbp,%r13
mov    -0x58(%rsp),%r14d
je     1f7b <boundaryvalues+0xe6b>
or     $0x1,%rbp
mov    %rbp,%rax
not    %rax
test   $0x1,%r15b
jne    1df5 <boundaryvalues+0xce5>
movq   $0x0,(%r12,%rbp,8)
movsd  (%rsi,%rbp,8),%xmm1
xorps  0x1213(%rip),%xmm1
movlps %xmm1,(%rbx,%rbp,8)
add    $0x1,%rbp
add    %r15,%rax
je     1f7b <boundaryvalues+0xe6b>
movaps 0x11fb(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movq   $0x0,(%r12,%rbp,8)
movsd  (%rsi,%rbp,8),%xmm2
xorps  %xmm1,%xmm2
movlps %xmm2,(%rbx,%rbp,8)
movq   $0x0,0x8(%r12,%rbp,8)
movsd  0x8(%rsi,%rbp,8),%xmm2
xorps  %xmm1,%xmm2
movlps %xmm2,0x8(%rbx,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%r15
jne    1e10 <boundaryvalues+0xd00>
jmp    1f7b <boundaryvalues+0xe6b>
xor    %edi,%edi
test   $0x1,%dl
je     1e78 <boundaryvalues+0xd68>
shl    $0x3,%rdi
or     $0x8,%rdi
xorps  %xmm1,%xmm1
movups %xmm1,(%r12,%rdi,1)
movups %xmm1,0x10(%r12,%rdi,1)
movups (%rsi,%rdi,1),%xmm1
movups 0x10(%rsi,%rdi,1),%xmm2
movups %xmm1,(%rbx,%rdi,1)
movups %xmm2,0x10(%rbx,%rdi,1)
cmp    %rbp,%r13
mov    -0x58(%rsp),%r14d
je     1f7b <boundaryvalues+0xe6b>
or     $0x1,%rbp
mov    %r15d,%edi
sub    %ebp,%edi
mov    %rbp,%rax
not    %rax
add    %r15,%rax
and    $0x3,%rdi
je     1ebc <boundaryvalues+0xdac>
xchg   %ax,%ax
movq   $0x0,(%r12,%rbp,8)
movsd  (%rsi,%rbp,8),%xmm1
movsd  %xmm1,(%rbx,%rbp,8)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdi
jne    1ea0 <boundaryvalues+0xd90>
cmp    $0x3,%rax
jb     1f7b <boundaryvalues+0xe6b>
cs nopw 0x0(%rax,%rax,1)
movq   $0x0,(%r12,%rbp,8)
movsd  (%rsi,%rbp,8),%xmm1
movsd  %xmm1,(%rbx,%rbp,8)
movq   $0x0,0x8(%r12,%rbp,8)
movsd  0x8(%rsi,%rbp,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rbp,8)
movq   $0x0,0x10(%r12,%rbp,8)
movsd  0x10(%rsi,%rbp,8),%xmm1
movsd  %xmm1,0x10(%rbx,%rbp,8)
movq   $0x0,0x18(%r12,%rbp,8)
movsd  0x18(%rsi,%rbp,8),%xmm1
movsd  %xmm1,0x18(%rbx,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%r15
jne    1ed0 <boundaryvalues+0xdc0>
jmp    1f7b <boundaryvalues+0xe6b>
xor    %edi,%edi
test   $0x1,%r10b
mov    -0x58(%rsp),%r14d
je     1f6b <boundaryvalues+0xe5b>
shl    $0x3,%rdi
or     $0x8,%rdi
movups (%r12,%rdi,1),%xmm1
movups 0x10(%r12,%rdi,1),%xmm2
movups %xmm1,0x0(%r13,%rdi,1)
movups %xmm2,0x10(%r13,%rdi,1)
movups (%rbx,%rdi,1),%xmm1
movups 0x10(%rbx,%rdi,1),%xmm2
movups %xmm1,0x0(%rbp,%rdi,1)
movups %xmm2,0x10(%rbp,%rdi,1)
cmp    %rax,-0x38(%rsp)
mov    -0x40(%rsp),%r10
jne    2406 <boundaryvalues+0x12f6>
cmp    $0x1,%r14d
je     205a <boundaryvalues+0xf4a>
cmp    $0x2,%r14d
mov    -0x2c(%rsp),%esi
je     211b <boundaryvalues+0x100b>
cmp    $0x3,%r14d
jne    21b8 <boundaryvalues+0x10a8>
test   %esi,%esi
jle    21b8 <boundaryvalues+0x10a8>
mov    %r10,%r15
lea    -0x1(%r11),%eax
movslq %eax,%rbp
movslq %r11d,%rax
lea    0x1(%r11),%edx
movslq %edx,%rdi
mov    %esi,%r10d
mov    $0x1,%ebx
cmp    $0x1,%esi
je     202c <boundaryvalues+0xf1c>
mov    %r10d,%r14d
and    $0xfffffffe,%r14d
neg    %r14
mov    $0x1,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r8,%rbx,8),%rdx
movsd  (%rdx,%rbp,8),%xmm1
movsd  %xmm1,(%rdx,%rax,8)
mov    (%rcx,%rbx,8),%rdx
movsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,(%rdx,%rdi,8)
mov    0x8(%r8,%rbx,8),%rdx
movsd  (%rdx,%rbp,8),%xmm1
movsd  %xmm1,(%rdx,%rax,8)
mov    0x8(%rcx,%rbx,8),%rdx
movsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,(%rdx,%rdi,8)
lea    (%r14,%rbx,1),%rdx
add    $0x2,%rdx
add    $0x2,%rbx
cmp    $0x1,%rdx
jne    1fe0 <boundaryvalues+0xed0>
test   $0x1,%r10b
mov    %r15,%r10
je     21b8 <boundaryvalues+0x10a8>
mov    (%r8,%rbx,8),%rdx
movsd  (%rdx,%rbp,8),%xmm1
movsd  %xmm1,(%rdx,%rax,8)
mov    (%rcx,%rbx,8),%rdx
movsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,(%rdx,%rdi,8)
jmp    21b8 <boundaryvalues+0x10a8>
mov    -0x2c(%rsp),%esi
test   %esi,%esi
jle    21b8 <boundaryvalues+0x10a8>
movslq %r11d,%rax
lea    0x1(%r11),%edx
movslq %edx,%rbx
mov    %esi,%r14d
mov    $0x1,%ebp
cmp    $0x1,%esi
je     20ec <boundaryvalues+0xfdc>
mov    %r14d,%edi
and    $0xfffffffe,%edi
neg    %rdi
mov    $0x1,%ebp
movaps 0xf6e(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r8,%rbp,8),%rdx
movq   $0x0,(%rdx,%rax,8)
mov    (%rcx,%rbp,8),%rdx
movsd  (%rdx,%rax,8),%xmm2
xorps  %xmm1,%xmm2
movlps %xmm2,(%rdx,%rbx,8)
mov    0x8(%r8,%rbp,8),%rdx
movq   $0x0,(%rdx,%rax,8)
mov    0x8(%rcx,%rbp,8),%rdx
movsd  (%rdx,%rax,8),%xmm2
xorps  %xmm1,%xmm2
movlps %xmm2,(%rdx,%rbx,8)
lea    (%rdi,%rbp,1),%rdx
add    $0x2,%rdx
add    $0x2,%rbp
cmp    $0x1,%rdx
jne    20a0 <boundaryvalues+0xf90>
test   $0x1,%r14b
je     21b8 <boundaryvalues+0x10a8>
mov    (%r8,%rbp,8),%rdx
movq   $0x0,(%rdx,%rax,8)
mov    (%rcx,%rbp,8),%rdx
movsd  (%rdx,%rax,8),%xmm1
xorps  0xeee(%rip),%xmm1
movlps %xmm1,(%rdx,%rbx,8)
jmp    21b8 <boundaryvalues+0x10a8>
test   %esi,%esi
jle    21b8 <boundaryvalues+0x10a8>
movslq %r11d,%rax
lea    0x1(%r11),%edx
movslq %edx,%rbx
mov    %esi,%r14d
mov    $0x1,%ebp
cmp    $0x1,%esi
je     2198 <boundaryvalues+0x1088>
mov    %r14d,%edi
and    $0xfffffffe,%edi
neg    %rdi
mov    $0x1,%ebp
nopl   0x0(%rax,%rax,1)
mov    (%r8,%rbp,8),%rdx
movq   $0x0,(%rdx,%rax,8)
mov    (%rcx,%rbp,8),%rdx
movsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,(%rdx,%rbx,8)
mov    0x8(%r8,%rbp,8),%rdx
movq   $0x0,(%rdx,%rax,8)
mov    0x8(%rcx,%rbp,8),%rdx
movsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,(%rdx,%rbx,8)
lea    (%rdi,%rbp,1),%rdx
add    $0x2,%rdx
add    $0x2,%rbp
cmp    $0x1,%rdx
jne    2150 <boundaryvalues+0x1040>
test   $0x1,%r14b
je     21b8 <boundaryvalues+0x10a8>
mov    (%r8,%rbp,8),%rdx
movq   $0x0,(%rdx,%rax,8)
mov    (%rcx,%rbp,8),%rdx
movsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,(%rdx,%rbx,8)
mov    -0x4(%rsp),%eax
cmp    $0x1,%eax
je     226f <boundaryvalues+0x115f>
cmp    $0x2,%eax
je     2313 <boundaryvalues+0x1203>
cmp    $0x3,%eax
jne    23f1 <boundaryvalues+0x12e1>
test   %esi,%esi
jle    23f1 <boundaryvalues+0x12e1>
mov    %esi,%eax
mov    $0x1,%ebx
cmp    $0x1,%esi
je     2248 <boundaryvalues+0x1138>
mov    %eax,%edi
and    $0xfffffffe,%edi
neg    %rdi
mov    $0x1,%ebx
nopl   0x0(%rax,%rax,1)
mov    (%r8,%rbx,8),%rdx
movsd  0x8(%rdx),%xmm1
movsd  %xmm1,(%rdx)
mov    (%rcx,%rbx,8),%rdx
movsd  0x8(%rdx),%xmm1
movsd  %xmm1,(%rdx)
mov    0x8(%r8,%rbx,8),%rdx
movsd  0x8(%rdx),%xmm1
movsd  %xmm1,(%rdx)
mov    0x8(%rcx,%rbx,8),%rdx
movsd  0x8(%rdx),%xmm1
movsd  %xmm1,(%rdx)
lea    (%rdi,%rbx,1),%rdx
add    $0x2,%rdx
add    $0x2,%rbx
cmp    $0x1,%rdx
jne    2200 <boundaryvalues+0x10f0>
test   $0x1,%al
je     23f1 <boundaryvalues+0x12e1>
mov    (%r8,%rbx,8),%rax
movsd  0x8(%rax),%xmm1
movsd  %xmm1,(%rax)
mov    (%rcx,%rbx,8),%rax
movsd  0x8(%rax),%xmm1
movsd  %xmm1,(%rax)
jmp    23f1 <boundaryvalues+0x12e1>
test   %esi,%esi
jle    23f1 <boundaryvalues+0x12e1>
mov    %esi,%eax
mov    $0x1,%ebx
cmp    $0x1,%esi
je     22e8 <boundaryvalues+0x11d8>
mov    %eax,%edi
and    $0xfffffffe,%edi
neg    %rdi
mov    $0x1,%ebx
movaps 0xd69(%rip),%xmm1
nopw   0x0(%rax,%rax,1)
mov    (%r8,%rbx,8),%rdx
movq   $0x0,(%rdx)
mov    (%rcx,%rbx,8),%rdx
movsd  0x8(%rdx),%xmm2
xorps  %xmm1,%xmm2
movlps %xmm2,(%rdx)
mov    0x8(%r8,%rbx,8),%rdx
movq   $0x0,(%rdx)
mov    0x8(%rcx,%rbx,8),%rdx
movsd  0x8(%rdx),%xmm2
xorps  %xmm1,%xmm2
movlps %xmm2,(%rdx)
lea    (%rdi,%rbx,1),%rdx
add    $0x2,%rdx
add    $0x2,%rbx
cmp    $0x1,%rdx
jne    22a0 <boundaryvalues+0x1190>
test   $0x1,%al
je     23f1 <boundaryvalues+0x12e1>
mov    (%r8,%rbx,8),%rax
movq   $0x0,(%rax)
mov    (%rcx,%rbx,8),%rax
movsd  0x8(%rax),%xmm1
xorps  0xcf5(%rip),%xmm1
movlps %xmm1,(%rax)
jmp    23f1 <boundaryvalues+0x12e1>
test   %esi,%esi
jle    23f1 <boundaryvalues+0x12e1>
mov    %esi,%ebx
lea    -0x1(%rbx),%rdx
mov    %ebx,%eax
and    $0x3,%eax
mov    $0x1,%edi
cmp    $0x3,%rdx
jb     23b5 <boundaryvalues+0x12a5>
and    $0xfffffffc,%ebx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
mov    0x8(%r8,%rdi,8),%rdx
movq   $0x0,(%rdx)
mov    0x8(%rcx,%rdi,8),%rdx
movsd  0x8(%rdx),%xmm1
movsd  %xmm1,(%rdx)
mov    0x10(%r8,%rdi,8),%rdx
movq   $0x0,(%rdx)
mov    0x10(%rcx,%rdi,8),%rdx
movsd  0x8(%rdx),%xmm1
movsd  %xmm1,(%rdx)
mov    0x18(%r8,%rdi,8),%rdx
movq   $0x0,(%rdx)
mov    0x18(%rcx,%rdi,8),%rdx
movsd  0x8(%rdx),%xmm1
movsd  %xmm1,(%rdx)
mov    0x20(%r8,%rdi,8),%rdx
movq   $0x0,(%rdx)
mov    0x20(%rcx,%rdi,8),%rdx
movsd  0x8(%rdx),%xmm1
movsd  %xmm1,(%rdx)
add    $0x4,%rdi
cmp    %rdi,%rbx
jne    2340 <boundaryvalues+0x1230>
add    $0x1,%rdi
test   %rax,%rax
je     23f1 <boundaryvalues+0x12e1>
lea    (%rcx,%rdi,8),%rbx
lea    (%r8,%rdi,8),%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rdi,%rbp,8),%rdx
movq   $0x0,(%rdx)
mov    (%rbx,%rbp,8),%rdx
movsd  0x8(%rdx),%xmm1
movsd  %xmm1,(%rdx)
add    $0x1,%rbp
cmp    %rbp,%rax
jne    23d0 <boundaryvalues+0x12c0>
mov    %r10,%rdi
mov    %r11d,%edx
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <spec_boundary_val@plt>
or     $0x1,%rax
jmp    18bf <boundaryvalues+0x7af>
mov    -0x48(%rsp),%r9
mov    -0x50(%rsp),%r11
jmp    18bf <boundaryvalues+0x7af>
mov    -0x48(%rsp),%r9
mov    -0x50(%rsp),%r11
mov    -0x58(%rsp),%r14d
jmp    18bf <boundaryvalues+0x7af>
mov    -0x48(%rsp),%r9
mov    -0x50(%rsp),%r11
mov    -0x40(%rsp),%r10
mov    -0x58(%rsp),%r14d
mov    -0x38(%rsp),%r15d
jmp    118e <boundaryvalues+0x7e>
mov    -0x48(%rsp),%r9
mov    -0x50(%rsp),%r11
mov    -0x40(%rsp),%r10
mov    -0x58(%rsp),%r14d
jmp    18bf <boundaryvalues+0x7af>

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

LLVM IR (-O2):
define void @boundaryvalues(i32 %0, i32 %1, double** %2, double** %3, double** nocapture readnone %4, i32 %5, i32 %6, i32 %7, i32 %8, double** nocapture readnone %9, double** nocapture readnone %10, i8* %11, i32** %12, double %13) {
switch i32 %5, label %447 [
i32 1, label %274
i32 2, label %158
i32 3, label %15
]
15: ; preds = %14
%16 = icmp slt i32 %1, 1
br i1 %16, label %447, label %17
17: ; preds = %15
%18 = getelementptr inbounds double*, double** %2, i64 1
%19 = load double*, double** %18
%20 = load double*, double** %2
%21 = getelementptr inbounds double*, double** %3, i64 1
%22 = load double*, double** %21
%23 = load double*, double** %3
%24 = add nuw i32 %1, 1
%25 = zext i32 %24 to i64
%26 = add nsw i64 %25, -1
%27 = icmp ult i64 %26, 4
br i1 %27, label %141, label %28
28: ; preds = %17
%29 = getelementptr double, double* %20, i64 1
%30 = getelementptr double, double* %20, i64 %25
%31 = getelementptr double, double* %23, i64 1
%32 = getelementptr double, double* %23, i64 %25
%33 = getelementptr double, double* %19, i64 1
%34 = getelementptr double, double* %19, i64 %25
%35 = getelementptr double, double* %22, i64 1
%36 = getelementptr double, double* %22, i64 %25
%37 = icmp ult double* %29, %32
%38 = icmp ult double* %31, %30
%39 = and i1 %37, %38
%40 = icmp ult double* %29, %34
%41 = icmp ult double* %33, %30
%42 = and i1 %40, %41
%43 = or i1 %39, %42
%44 = icmp ult double* %29, %36
%45 = icmp ult double* %35, %30
%46 = and i1 %44, %45
%47 = or i1 %43, %46
%48 = icmp ult double* %31, %34
%49 = icmp ult double* %33, %32
%50 = and i1 %48, %49
%51 = or i1 %47, %50
%52 = icmp ult double* %31, %36
%53 = icmp ult double* %35, %32
%54 = and i1 %52, %53
%55 = or i1 %51, %54
br i1 %55, label %141, label %56
56: ; preds = %28
%57 = and i64 %26, -4
%58 = or i64 %57, 1
%59 = add nsw i64 %57, -4
%60 = lshr exact i64 %59, 2
%61 = add nuw nsw i64 %60, 1
%62 = and i64 %61, 1
%63 = icmp eq i64 %59, 0
br i1 %63, label %114, label %64
64: ; preds = %56
%65 = and i64 %61, 9223372036854775806
br label %66
66: ; preds = %66, %64
%67 = phi i64 [ 0, %64 ], [ %111, %66 ]
%68 = phi i64 [ 0, %64 ], [ %112, %66 ]
%69 = or i64 %67, 1
%70 = getelementptr inbounds double, double* %19, i64 %69
%71 = bitcast double* %70 to <2 x double>*
%72 = load <2 x double>, <2 x double>* %71
%73 = getelementptr inbounds double, double* %70, i64 2
%74 = bitcast double* %73 to <2 x double>*
%75 = load <2 x double>, <2 x double>* %74
%76 = getelementptr inbounds double, double* %20, i64 %69
%77 = bitcast double* %76 to <2 x double>*
store <2 x double> %72, <2 x double>* %77
%78 = getelementptr inbounds double, double* %76, i64 2
%79 = bitcast double* %78 to <2 x double>*
store <2 x double> %75, <2 x double>* %79
%80 = getelementptr inbounds double, double* %22, i64 %69
%81 = bitcast double* %80 to <2 x double>*
%82 = load <2 x double>, <2 x double>* %81
%83 = getelementptr inbounds double, double* %80, i64 2
%84 = bitcast double* %83 to <2 x double>*
%85 = load <2 x double>, <2 x double>* %84
%86 = getelementptr inbounds double, double* %23, i64 %69
%87 = bitcast double* %86 to <2 x double>*
store <2 x double> %82, <2 x double>* %87
%88 = getelementptr inbounds double, double* %86, i64 2
%89 = bitcast double* %88 to <2 x double>*
store <2 x double> %85, <2 x double>* %89
%90 = or i64 %67, 5
%91 = getelementptr inbounds double, double* %19, i64 %90
%92 = bitcast double* %91 to <2 x double>*
%93 = load <2 x double>, <2 x double>* %92
%94 = getelementptr inbounds double, double* %91, i64 2
%95 = bitcast double* %94 to <2 x double>*
%96 = load <2 x double>, <2 x double>* %95
%97 = getelementptr inbounds double, double* %20, i64 %90
%98 = bitcast double* %97 to <2 x double>*
store <2 x double> %93, <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 = getelementptr inbounds double, double* %22, i64 %90
%102 = bitcast double* %101 to <2 x double>*
%103 = load <2 x double>, <2 x double>* %102
%104 = getelementptr inbounds double, double* %101, i64 2
%105 = bitcast double* %104 to <2 x double>*
%106 = load <2 x double>, <2 x double>* %105
%107 = getelementptr inbounds double, double* %23, i64 %90
%108 = bitcast double* %107 to <2 x double>*
store <2 x double> %103, <2 x double>* %108
%109 = getelementptr inbounds double, double* %107, i64 2
%110 = bitcast double* %109 to <2 x double>*
store <2 x double> %106, <2 x double>* %110
%111 = add nuw i64 %67, 8
%112 = add i64 %68, 2
%113 = icmp eq i64 %112, %65
br i1 %113, label %114, label %66
114: ; preds = %66, %56
%115 = phi i64 [ 0, %56 ], [ %111, %66 ]
%116 = icmp eq i64 %62, 0
br i1 %116, label %139, label %117
117: ; preds = %114
%118 = or i64 %115, 1
%119 = getelementptr inbounds double, double* %19, i64 %118
%120 = bitcast double* %119 to <2 x double>*
%121 = load <2 x double>, <2 x double>* %120
%122 = getelementptr inbounds double, double* %119, i64 2
%123 = bitcast double* %122 to <2 x double>*
%124 = load <2 x double>, <2 x double>* %123
%125 = getelementptr inbounds double, double* %20, i64 %118
%126 = bitcast double* %125 to <2 x double>*
store <2 x double> %121, <2 x double>* %126
%127 = getelementptr inbounds double, double* %125, i64 2
%128 = bitcast double* %127 to <2 x double>*
store <2 x double> %124, <2 x double>* %128
%129 = getelementptr inbounds double, double* %22, i64 %118
%130 = bitcast double* %129 to <2 x double>*
%131 = load <2 x double>, <2 x double>* %130
%132 = getelementptr inbounds double, double* %129, i64 2
%133 = bitcast double* %132 to <2 x double>*
%134 = load <2 x double>, <2 x double>* %133
%135 = getelementptr inbounds double, double* %23, i64 %118
%136 = bitcast double* %135 to <2 x double>*
store <2 x double> %131, <2 x double>* %136
%137 = getelementptr inbounds double, double* %135, i64 2
%138 = bitcast double* %137 to <2 x double>*
store <2 x double> %134, <2 x double>* %138
br label %139
139: ; preds = %114, %117
%140 = icmp eq i64 %26, %57
br i1 %140, label %447, label %141
141: ; preds = %28, %17, %139
%142 = phi i64 [ 1, %28 ], [ 1, %17 ], [ %58, %139 ]
%143 = xor i64 %142, -1
%144 = and i64 %25, 1
%145 = icmp eq i64 %144, 0
br i1 %145, label %146, label %154
146: ; preds = %141
%147 = getelementptr inbounds double, double* %19, i64 %142
%148 = load double, double* %147
%149 = getelementptr inbounds double, double* %20, i64 %142
store double %148, double* %149
%150 = getelementptr inbounds double, double* %22, i64 %142
%151 = load double, double* %150
%152 = getelementptr inbounds double, double* %23, i64 %142
store double %151, double* %152
%153 = add nuw nsw i64 %142, 1
br label %154
154: ; preds = %146, %141
%155 = phi i64 [ %142, %141 ], [ %153, %146 ]
%156 = sub nsw i64 0, %25
%157 = icmp eq i64 %143, %156
br i1 %157, label %447, label %430
158: ; preds = %14
%159 = icmp slt i32 %1, 1
br i1 %159, label %447, label %160
160: ; preds = %158
%161 = load double*, double** %2
%162 = getelementptr inbounds double*, double** %3, i64 1
%163 = load double*, double** %162
%164 = load double*, double** %3
%165 = add nuw i32 %1, 1
%166 = zext i32 %165 to i64
%167 = add nsw i64 %166, -1
%168 = icmp ult i64 %167, 4
br i1 %168, label %254, label %169
169: ; preds = %160
%170 = getelementptr double, double* %161, i64 1
%171 = getelementptr double, double* %161, i64 %166
%172 = getelementptr double, double* %164, i64 1
%173 = getelementptr double, double* %164, i64 %166
%174 = getelementptr double, double* %163, i64 1
%175 = getelementptr double, double* %163, i64 %166
%176 = icmp ult double* %170, %173
%177 = icmp ult double* %172, %171
%178 = and i1 %176, %177
%179 = icmp ult double* %170, %175
%180 = icmp ult double* %174, %171
%181 = and i1 %179, %180
%182 = or i1 %178, %181
%183 = icmp ult double* %172, %175
%184 = icmp ult double* %174, %173
%185 = and i1 %183, %184
%186 = or i1 %182, %185
br i1 %186, label %254, label %187
187: ; preds = %169
%188 = and i64 %167, -4
%189 = or i64 %188, 1
%190 = add nsw i64 %188, -4
%191 = lshr exact i64 %190, 2
%192 = add nuw nsw i64 %191, 1
%193 = and i64 %192, 1
%194 = icmp eq i64 %190, 0
br i1 %194, label %233, label %195
195: ; preds = %187
%196 = and i64 %192, 9223372036854775806
br label %197
197: ; preds = %197, %195
%198 = phi i64 [ 0, %195 ], [ %230, %197 ]
%199 = phi i64 [ 0, %195 ], [ %231, %197 ]
%200 = or i64 %198, 1
%201 = getelementptr inbounds double, double* %161, i64 %200
%202 = bitcast double* %201 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %202
%203 = getelementptr inbounds double, double* %201, i64 2
%204 = bitcast double* %203 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %204
%205 = getelementptr inbounds double, double* %163, i64 %200
%206 = bitcast double* %205 to <2 x double>*
%207 = load <2 x double>, <2 x double>* %206
%208 = getelementptr inbounds double, double* %205, i64 2
%209 = bitcast double* %208 to <2 x double>*
%210 = load <2 x double>, <2 x double>* %209
%211 = getelementptr inbounds double, double* %164, i64 %200
%212 = bitcast double* %211 to <2 x double>*
store <2 x double> %207, <2 x double>* %212
%213 = getelementptr inbounds double, double* %211, i64 2
%214 = bitcast double* %213 to <2 x double>*
store <2 x double> %210, <2 x double>* %214
%215 = or i64 %198, 5
%216 = getelementptr inbounds double, double* %161, i64 %215
%217 = bitcast double* %216 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %217
%218 = getelementptr inbounds double, double* %216, i64 2
%219 = bitcast double* %218 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %219
%220 = getelementptr inbounds double, double* %163, i64 %215
%221 = bitcast double* %220 to <2 x double>*
%222 = load <2 x double>, <2 x double>* %221
%223 = getelementptr inbounds double, double* %220, i64 2
%224 = bitcast double* %223 to <2 x double>*
%225 = load <2 x double>, <2 x double>* %224
%226 = getelementptr inbounds double, double* %164, i64 %215
%227 = bitcast double* %226 to <2 x double>*
store <2 x double> %222, <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 = add nuw i64 %198, 8
%231 = add i64 %199, 2
%232 = icmp eq i64 %231, %196
br i1 %232, label %233, label %197
233: ; preds = %197, %187
%234 = phi i64 [ 0, %187 ], [ %230, %197 ]
%235 = icmp eq i64 %193, 0
br i1 %235, label %252, label %236
236: ; preds = %233
%237 = or i64 %234, 1
%238 = getelementptr inbounds double, double* %161, i64 %237
%239 = bitcast double* %238 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %239
%240 = getelementptr inbounds double, double* %238, i64 2
%241 = bitcast double* %240 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %241
%242 = getelementptr inbounds double, double* %163, i64 %237
%243 = bitcast double* %242 to <2 x double>*
%244 = load <2 x double>, <2 x double>* %243
%245 = getelementptr inbounds double, double* %242, i64 2
%246 = bitcast double* %245 to <2 x double>*
%247 = load <2 x double>, <2 x double>* %246
%248 = getelementptr inbounds double, double* %164, i64 %237
%249 = bitcast double* %248 to <2 x double>*
store <2 x double> %244, <2 x double>* %249
%250 = getelementptr inbounds double, double* %248, i64 2
%251 = bitcast double* %250 to <2 x double>*
store <2 x double> %247, <2 x double>* %251
br label %252
252: ; preds = %233, %236
%253 = icmp eq i64 %167, %188
br i1 %253, label %447, label %254
254: ; preds = %169, %160, %252
%255 = phi i64 [ 1, %169 ], [ 1, %160 ], [ %189, %252 ]
%256 = sub nsw i64 %166, %255
%257 = xor i64 %255, -1
%258 = add nsw i64 %257, %166
%259 = and i64 %256, 3
%260 = icmp eq i64 %259, 0
br i1 %260, label %271, label %261
261: ; preds = %254, %261
%262 = phi i64 [ %268, %261 ], [ %255, %254 ]
%263 = phi i64 [ %269, %261 ], [ 0, %254 ]
%264 = getelementptr inbounds double, double* %161, i64 %262
store double 0.000000e+00, double* %264
%265 = getelementptr inbounds double, double* %163, i64 %262
%266 = load double, double* %265
%267 = getelementptr inbounds double, double* %164, i64 %262
store double %266, double* %267
%268 = add nuw nsw i64 %262, 1
%269 = add i64 %263, 1
%270 = icmp eq i64 %269, %259
br i1 %270, label %271, label %261
271: ; preds = %261, %254
%272 = phi i64 [ %255, %254 ], [ %268, %261 ]
%273 = icmp ult i64 %258, 3
br i1 %273, label %447, label %407
274: ; preds = %14
%275 = icmp slt i32 %1, 1
br i1 %275, label %447, label %276
276: ; preds = %274
%277 = load double*, double** %2
%278 = getelementptr inbounds double*, double** %3, i64 1
%279 = load double*, double** %278
%280 = load double*, double** %3
%281 = add nuw i32 %1, 1
%282 = zext i32 %281 to i64
%283 = add nsw i64 %282, -1
%284 = icmp ult i64 %283, 4
br i1 %284, label %376, label %285
285: ; preds = %276
%286 = getelementptr double, double* %277, i64 1
%287 = getelementptr double, double* %277, i64 %282
%288 = getelementptr double, double* %280, i64 1
%289 = getelementptr double, double* %280, i64 %282
%290 = getelementptr double, double* %279, i64 1
%291 = getelementptr double, double* %279, i64 %282
%292 = icmp ult double* %286, %289
%293 = icmp ult double* %288, %287
%294 = and i1 %292, %293
%295 = icmp ult double* %286, %291
%296 = icmp ult double* %290, %287
%297 = and i1 %295, %296
%298 = or i1 %294, %297
%299 = icmp ult double* %288, %291
%300 = icmp ult double* %290, %289
%301 = and i1 %299, %300
%302 = or i1 %298, %301
br i1 %302, label %376, label %303
303: ; preds = %285
%304 = and i64 %283, -4
%305 = or i64 %304, 1
%306 = add nsw i64 %304, -4
%307 = lshr exact i64 %306, 2
%308 = add nuw nsw i64 %307, 1
%309 = and i64 %308, 1
%310 = icmp eq i64 %306, 0
br i1 %310, label %353, label %311
311: ; preds = %303
%312 = and i64 %308, 9223372036854775806
br label %313
313: ; preds = %313, %311
%314 = phi i64 [ 0, %311 ], [ %350, %313 ]
%315 = phi i64 [ 0, %311 ], [ %351, %313 ]
%316 = or i64 %314, 1
%317 = getelementptr inbounds double, double* %277, i64 %316
%318 = bitcast double* %317 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %318
%319 = getelementptr inbounds double, double* %317, i64 2
%320 = bitcast double* %319 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %320
%321 = getelementptr inbounds double, double* %279, i64 %316
%322 = bitcast double* %321 to <2 x double>*
%323 = load <2 x double>, <2 x double>* %322
%324 = getelementptr inbounds double, double* %321, i64 2
%325 = bitcast double* %324 to <2 x double>*
%326 = load <2 x double>, <2 x double>* %325
%327 = fneg <2 x double> %323
%328 = fneg <2 x double> %326
%329 = getelementptr inbounds double, double* %280, i64 %316
%330 = bitcast double* %329 to <2 x double>*
store <2 x double> %327, <2 x double>* %330
%331 = getelementptr inbounds double, double* %329, i64 2
%332 = bitcast double* %331 to <2 x double>*
store <2 x double> %328, <2 x double>* %332
%333 = or i64 %314, 5
%334 = getelementptr inbounds double, double* %277, i64 %333
%335 = bitcast double* %334 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %335
%336 = getelementptr inbounds double, double* %334, i64 2
%337 = bitcast double* %336 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %337
%338 = getelementptr inbounds double, double* %279, i64 %333
%339 = bitcast double* %338 to <2 x double>*
%340 = load <2 x double>, <2 x double>* %339
%341 = getelementptr inbounds double, double* %338, i64 2
%342 = bitcast double* %341 to <2 x double>*
%343 = load <2 x double>, <2 x double>* %342
%344 = fneg <2 x double> %340
%345 = fneg <2 x double> %343
%346 = getelementptr inbounds double, double* %280, i64 %333
%347 = bitcast double* %346 to <2 x double>*
store <2 x double> %344, <2 x double>* %347
%348 = getelementptr inbounds double, double* %346, i64 2
%349 = bitcast double* %348 to <2 x double>*
store <2 x double> %345, <2 x double>* %349
%350 = add nuw i64 %314, 8
%351 = add i64 %315, 2
%352 = icmp eq i64 %351, %312
br i1 %352, label %353, label %313
353: ; preds = %313, %303
%354 = phi i64 [ 0, %303 ], [ %350, %313 ]
%355 = icmp eq i64 %309, 0
br i1 %355, label %374, label %356
356: ; preds = %353
%357 = or i64 %354, 1
%358 = getelementptr inbounds double, double* %277, i64 %357
%359 = bitcast double* %358 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %359
%360 = getelementptr inbounds double, double* %358, i64 2
%361 = bitcast double* %360 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %361
%362 = getelementptr inbounds double, double* %279, i64 %357
%363 = bitcast double* %362 to <2 x double>*
%364 = load <2 x double>, <2 x double>* %363
%365 = getelementptr inbounds double, double* %362, i64 2
%366 = bitcast double* %365 to <2 x double>*
%367 = load <2 x double>, <2 x double>* %366
%368 = fneg <2 x double> %364
%369 = fneg <2 x double> %367
%370 = getelementptr inbounds double, double* %280, i64 %357
%371 = bitcast double* %370 to <2 x double>*
store <2 x double> %368, <2 x double>* %371
%372 = getelementptr inbounds double, double* %370, i64 2
%373 = bitcast double* %372 to <2 x double>*
store <2 x double> %369, <2 x double>* %373
br label %374
374: ; preds = %353, %356
%375 = icmp eq i64 %283, %304
br i1 %375, label %447, label %376
376: ; preds = %285, %276, %374
%377 = phi i64 [ 1, %285 ], [ 1, %276 ], [ %305, %374 ]
%378 = xor i64 %377, -1
%379 = and i64 %282, 1
%380 = icmp eq i64 %379, 0
br i1 %380, label %381, label %388
381: ; preds = %376
%382 = getelementptr inbounds double, double* %277, i64 %377
store double 0.000000e+00, double* %382
%383 = getelementptr inbounds double, double* %279, i64 %377
%384 = load double, double* %383
%385 = fneg double %384
%386 = getelementptr inbounds double, double* %280, i64 %377
store double %385, double* %386
%387 = add nuw nsw i64 %377, 1
br label %388
388: ; preds = %381, %376
%389 = phi i64 [ %377, %376 ], [ %387, %381 ]
%390 = sub nsw i64 0, %282
%391 = icmp eq i64 %378, %390
br i1 %391, label %447, label %392
392: ; preds = %388, %392
%393 = phi i64 [ %405, %392 ], [ %389, %388 ]
%394 = getelementptr inbounds double, double* %277, i64 %393
store double 0.000000e+00, double* %394
%395 = getelementptr inbounds double, double* %279, i64 %393
%396 = load double, double* %395
%397 = fneg double %396
%398 = getelementptr inbounds double, double* %280, i64 %393
store double %397, double* %398
%399 = add nuw nsw i64 %393, 1
%400 = getelementptr inbounds double, double* %277, i64 %399
store double 0.000000e+00, double* %400
%401 = getelementptr inbounds double, double* %279, i64 %399
%402 = load double, double* %401
%403 = fneg double %402
%404 = getelementptr inbounds double, double* %280, i64 %399
store double %403, double* %404
%405 = add nuw nsw i64 %393, 2
%406 = icmp eq i64 %405, %282
br i1 %406, label %447, label %392
407: ; preds = %271, %407
%408 = phi i64 [ %428, %407 ], [ %272, %271 ]
%409 = getelementptr inbounds double, double* %161, i64 %408
store double 0.000000e+00, double* %409
%410 = getelementptr inbounds double, double* %163, i64 %408
%411 = load double, double* %410
%412 = getelementptr inbounds double, double* %164, i64 %408
store double %411, double* %412
%413 = add nuw nsw i64 %408, 1
%414 = getelementptr inbounds double, double* %161, i64 %413
store double 0.000000e+00, double* %414
%415 = getelementptr inbounds double, double* %163, i64 %413
%416 = load double, double* %415
%417 = getelementptr inbounds double, double* %164, i64 %413
store double %416, double* %417
%418 = add nuw nsw i64 %408, 2
%419 = getelementptr inbounds double, double* %161, i64 %418
store double 0.000000e+00, double* %419
%420 = getelementptr inbounds double, double* %163, i64 %418
%421 = load double, double* %420
%422 = getelementptr inbounds double, double* %164, i64 %418
store double %421, double* %422
%423 = add nuw nsw i64 %408, 3
%424 = getelementptr inbounds double, double* %161, i64 %423
store double 0.000000e+00, double* %424
%425 = getelementptr inbounds double, double* %163, i64 %423
%426 = load double, double* %425
%427 = getelementptr inbounds double, double* %164, i64 %423
store double %426, double* %427
%428 = add nuw nsw i64 %408, 4
%429 = icmp eq i64 %428, %166
br i1 %429, label %447, label %407
430: ; preds = %154, %430
%431 = phi i64 [ %445, %430 ], [ %155, %154 ]
%432 = getelementptr inbounds double, double* %19, i64 %431
%433 = load double, double* %432
%434 = getelementptr inbounds double, double* %20, i64 %431
store double %433, double* %434
%435 = getelementptr inbounds double, double* %22, i64 %431
%436 = load double, double* %435
%437 = getelementptr inbounds double, double* %23, i64 %431
store double %436, double* %437
%438 = add nuw nsw i64 %431, 1
%439 = getelementptr inbounds double, double* %19, i64 %438
%440 = load double, double* %439
%441 = getelementptr inbounds double, double* %20, i64 %438
store double %440, double* %441
%442 = getelementptr inbounds double, double* %22, i64 %438
%443 = load double, double* %442
%444 = getelementptr inbounds double, double* %23, i64 %438
store double %443, double* %444
%445 = add nuw nsw i64 %431, 2
%446 = icmp eq i64 %445, %25
br i1 %446, label %447, label %430
447: ; preds = %154, %430, %271, %407, %388, %392, %139, %252, %374, %15, %158, %274, %14
switch i32 %6, label %897 [
i32 1, label %719
i32 2, label %598
i32 3, label %448
]
448: ; preds = %447
%449 = icmp slt i32 %1, 1
br i1 %449, label %897, label %450
450: ; preds = %448
%451 = add nsw i32 %0, -1
%452 = sext i32 %451 to i64
%453 = getelementptr inbounds double*, double** %2, i64 %452
%454 = load double*, double** %453
%455 = sext i32 %0 to i64
%456 = getelementptr inbounds double*, double** %2, i64 %455
%457 = load double*, double** %456
%458 = getelementptr inbounds double*, double** %3, i64 %455
%459 = load double*, double** %458
%460 = add nsw i32 %0, 1
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds double*, double** %3, i64 %461
%463 = load double*, double** %462
%464 = add nuw i32 %1, 1
%465 = zext i32 %464 to i64
%466 = add nsw i64 %465, -1
%467 = icmp ult i64 %466, 4
br i1 %467, label %581, label %468
468: ; preds = %450
%469 = getelementptr double, double* %457, i64 1
%470 = getelementptr double, double* %457, i64 %465
%471 = getelementptr double, double* %463, i64 1
%472 = getelementptr double, double* %463, i64 %465
%473 = getelementptr double, double* %454, i64 1
%474 = getelementptr double, double* %454, i64 %465
%475 = getelementptr double, double* %459, i64 1
%476 = getelementptr double, double* %459, i64 %465
%477 = icmp ult double* %469, %472
%478 = icmp ult double* %471, %470
%479 = and i1 %477, %478
%480 = icmp ult double* %469, %474
%481 = icmp ult double* %473, %470
%482 = and i1 %480, %481
%483 = or i1 %479, %482
%484 = icmp ult double* %469, %476
%485 = icmp ult double* %475, %470
%486 = and i1 %484, %485
%487 = or i1 %483, %486
%488 = icmp ult double* %471, %474
%489 = icmp ult double* %473, %472
%490 = and i1 %488, %489
%491 = or i1 %487, %490
%492 = icmp ult double* %471, %476
%493 = icmp ult double* %475, %472
%494 = and i1 %492, %493
%495 = or i1 %491, %494
br i1 %495, label %581, label %496
496: ; preds = %468
%497 = and i64 %466, -4
%498 = or i64 %497, 1
%499 = add nsw i64 %497, -4
%500 = lshr exact i64 %499, 2
%501 = add nuw nsw i64 %500, 1
%502 = and i64 %501, 1
%503 = icmp eq i64 %499, 0
br i1 %503, label %554, label %504
504: ; preds = %496
%505 = and i64 %501, 9223372036854775806
br label %506
506: ; preds = %506, %504
%507 = phi i64 [ 0, %504 ], [ %551, %506 ]
%508 = phi i64 [ 0, %504 ], [ %552, %506 ]
%509 = or i64 %507, 1
%510 = getelementptr inbounds double, double* %454, i64 %509
%511 = bitcast double* %510 to <2 x double>*
%512 = load <2 x double>, <2 x double>* %511
%513 = getelementptr inbounds double, double* %510, i64 2
%514 = bitcast double* %513 to <2 x double>*
%515 = load <2 x double>, <2 x double>* %514
%516 = getelementptr inbounds double, double* %457, i64 %509
%517 = bitcast double* %516 to <2 x double>*
store <2 x double> %512, <2 x double>* %517
%518 = getelementptr inbounds double, double* %516, i64 2
%519 = bitcast double* %518 to <2 x double>*
store <2 x double> %515, <2 x double>* %519
%520 = getelementptr inbounds double, double* %459, i64 %509
%521 = bitcast double* %520 to <2 x double>*
%522 = load <2 x double>, <2 x double>* %521
%523 = getelementptr inbounds double, double* %520, i64 2
%524 = bitcast double* %523 to <2 x double>*
%525 = load <2 x double>, <2 x double>* %524
%526 = getelementptr inbounds double, double* %463, i64 %509
%527 = bitcast double* %526 to <2 x double>*
store <2 x double> %522, <2 x double>* %527
%528 = getelementptr inbounds double, double* %526, i64 2
%529 = bitcast double* %528 to <2 x double>*
store <2 x double> %525, <2 x double>* %529
%530 = or i64 %507, 5
%531 = getelementptr inbounds double, double* %454, i64 %530
%532 = bitcast double* %531 to <2 x double>*
%533 = load <2 x double>, <2 x double>* %532
%534 = getelementptr inbounds double, double* %531, i64 2
%535 = bitcast double* %534 to <2 x double>*
%536 = load <2 x double>, <2 x double>* %535
%537 = getelementptr inbounds double, double* %457, i64 %530
%538 = bitcast double* %537 to <2 x double>*
store <2 x double> %533, <2 x double>* %538
%539 = getelementptr inbounds double, double* %537, i64 2
%540 = bitcast double* %539 to <2 x double>*
store <2 x double> %536, <2 x double>* %540
%541 = getelementptr inbounds double, double* %459, i64 %530
%542 = bitcast double* %541 to <2 x double>*
%543 = load <2 x double>, <2 x double>* %542
%544 = getelementptr inbounds double, double* %541, i64 2
%545 = bitcast double* %544 to <2 x double>*
%546 = load <2 x double>, <2 x double>* %545
%547 = getelementptr inbounds double, double* %463, i64 %530
%548 = bitcast double* %547 to <2 x double>*
store <2 x double> %543, <2 x double>* %548
%549 = getelementptr inbounds double, double* %547, i64 2
%550 = bitcast double* %549 to <2 x double>*
store <2 x double> %546, <2 x double>* %550
%551 = add nuw i64 %507, 8
%552 = add i64 %508, 2
%553 = icmp eq i64 %552, %505
br i1 %553, label %554, label %506
554: ; preds = %506, %496
%555 = phi i64 [ 0, %496 ], [ %551, %506 ]
%556 = icmp eq i64 %502, 0
br i1 %556, label %579, label %557
557: ; preds = %554
%558 = or i64 %555, 1
%559 = getelementptr inbounds double, double* %454, i64 %558
%560 = bitcast double* %559 to <2 x double>*
%561 = load <2 x double>, <2 x double>* %560
%562 = getelementptr inbounds double, double* %559, i64 2
%563 = bitcast double* %562 to <2 x double>*
%564 = load <2 x double>, <2 x double>* %563
%565 = getelementptr inbounds double, double* %457, i64 %558
%566 = bitcast double* %565 to <2 x double>*
store <2 x double> %561, <2 x double>* %566
%567 = getelementptr inbounds double, double* %565, i64 2
%568 = bitcast double* %567 to <2 x double>*
store <2 x double> %564, <2 x double>* %568
%569 = getelementptr inbounds double, double* %459, i64 %558
%570 = bitcast double* %569 to <2 x double>*
%571 = load <2 x double>, <2 x double>* %570
%572 = getelementptr inbounds double, double* %569, i64 2
%573 = bitcast double* %572 to <2 x double>*
%574 = load <2 x double>, <2 x double>* %573
%575 = getelementptr inbounds double, double* %463, i64 %558
%576 = bitcast double* %575 to <2 x double>*
store <2 x double> %571, <2 x double>* %576
%577 = getelementptr inbounds double, double* %575, i64 2
%578 = bitcast double* %577 to <2 x double>*
store <2 x double> %574, <2 x double>* %578
br label %579
579: ; preds = %554, %557
%580 = icmp eq i64 %466, %497
br i1 %580, label %897, label %581
581: ; preds = %468, %450, %579
%582 = phi i64 [ 1, %468 ], [ 1, %450 ], [ %498, %579 ]
%583 = xor i64 %582, -1
%584 = and i64 %465, 1
%585 = icmp eq i64 %584, 0
br i1 %585, label %586, label %594
586: ; preds = %581
%587 = getelementptr inbounds double, double* %454, i64 %582
%588 = load double, double* %587
%589 = getelementptr inbounds double, double* %457, i64 %582
store double %588, double* %589
%590 = getelementptr inbounds double, double* %459, i64 %582
%591 = load double, double* %590
%592 = getelementptr inbounds double, double* %463, i64 %582
store double %591, double* %592
%593 = add nuw nsw i64 %582, 1
br label %594
594: ; preds = %586, %581
%595 = phi i64 [ %582, %581 ], [ %593, %586 ]
%596 = sub nsw i64 0, %465
%597 = icmp eq i64 %583, %596
br i1 %597, label %897, label %880
598: ; preds = %447
%599 = icmp slt i32 %1, 1
br i1 %599, label %897, label %600
600: ; preds = %598
%601 = sext i32 %0 to i64
%602 = getelementptr inbounds double*, double** %2, i64 %601
%603 = load double*, double** %602
%604 = getelementptr inbounds double*, double** %3, i64 %601
%605 = load double*, double** %604
%606 = add nsw i32 %0, 1
%607 = sext i32 %606 to i64
%608 = getelementptr inbounds double*, double** %3, i64 %607
%609 = load double*, double** %608
%610 = add nuw i32 %1, 1
%611 = zext i32 %610 to i64
%612 = add nsw i64 %611, -1
%613 = icmp ult i64 %612, 4
br i1 %613, label %699, label %614
614: ; preds = %600
%615 = getelementptr double, double* %603, i64 1
%616 = getelementptr double, double* %603, i64 %611
%617 = getelementptr double, double* %609, i64 1
%618 = getelementptr double, double* %609, i64 %611
%619 = getelementptr double, double* %605, i64 1
%620 = getelementptr double, double* %605, i64 %611
%621 = icmp ult double* %615, %618
%622 = icmp ult double* %617, %616
%623 = and i1 %621, %622
%624 = icmp ult double* %615, %620
%625 = icmp ult double* %619, %616
%626 = and i1 %624, %625
%627 = or i1 %623, %626
%628 = icmp ult double* %617, %620
%629 = icmp ult double* %619, %618
%630 = and i1 %628, %629
%631 = or i1 %627, %630
br i1 %631, label %699, label %632
632: ; preds = %614
%633 = and i64 %612, -4
%634 = or i64 %633, 1
%635 = add nsw i64 %633, -4
%636 = lshr exact i64 %635, 2
%637 = add nuw nsw i64 %636, 1
%638 = and i64 %637, 1
%639 = icmp eq i64 %635, 0
br i1 %639, label %678, label %640
640: ; preds = %632
%641 = and i64 %637, 9223372036854775806
br label %642
642: ; preds = %642, %640
%643 = phi i64 [ 0, %640 ], [ %675, %642 ]
%644 = phi i64 [ 0, %640 ], [ %676, %642 ]
%645 = or i64 %643, 1
%646 = getelementptr inbounds double, double* %603, i64 %645
%647 = bitcast double* %646 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %647
%648 = getelementptr inbounds double, double* %646, i64 2
%649 = bitcast double* %648 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %649
%650 = getelementptr inbounds double, double* %605, i64 %645
%651 = bitcast double* %650 to <2 x double>*
%652 = load <2 x double>, <2 x double>* %651
%653 = getelementptr inbounds double, double* %650, i64 2
%654 = bitcast double* %653 to <2 x double>*
%655 = load <2 x double>, <2 x double>* %654
%656 = getelementptr inbounds double, double* %609, i64 %645
%657 = bitcast double* %656 to <2 x double>*
store <2 x double> %652, <2 x double>* %657
%658 = getelementptr inbounds double, double* %656, i64 2
%659 = bitcast double* %658 to <2 x double>*
store <2 x double> %655, <2 x double>* %659
%660 = or i64 %643, 5
%661 = getelementptr inbounds double, double* %603, i64 %660
%662 = bitcast double* %661 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %662
%663 = getelementptr inbounds double, double* %661, i64 2
%664 = bitcast double* %663 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %664
%665 = getelementptr inbounds double, double* %605, i64 %660
%666 = bitcast double* %665 to <2 x double>*
%667 = load <2 x double>, <2 x double>* %666
%668 = getelementptr inbounds double, double* %665, i64 2
%669 = bitcast double* %668 to <2 x double>*
%670 = load <2 x double>, <2 x double>* %669
%671 = getelementptr inbounds double, double* %609, i64 %660
%672 = bitcast double* %671 to <2 x double>*
store <2 x double> %667, <2 x double>* %672
%673 = getelementptr inbounds double, double* %671, i64 2
%674 = bitcast double* %673 to <2 x double>*
store <2 x double> %670, <2 x double>* %674
%675 = add nuw i64 %643, 8
%676 = add i64 %644, 2
%677 = icmp eq i64 %676, %641
br i1 %677, label %678, label %642
678: ; preds = %642, %632
%679 = phi i64 [ 0, %632 ], [ %675, %642 ]
%680 = icmp eq i64 %638, 0
br i1 %680, label %697, label %681
681: ; preds = %678
%682 = or i64 %679, 1
%683 = getelementptr inbounds double, double* %603, i64 %682
%684 = bitcast double* %683 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %684
%685 = getelementptr inbounds double, double* %683, i64 2
%686 = bitcast double* %685 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %686
%687 = getelementptr inbounds double, double* %605, i64 %682
%688 = bitcast double* %687 to <2 x double>*
%689 = load <2 x double>, <2 x double>* %688
%690 = getelementptr inbounds double, double* %687, i64 2
%691 = bitcast double* %690 to <2 x double>*
%692 = load <2 x double>, <2 x double>* %691
%693 = getelementptr inbounds double, double* %609, i64 %682
%694 = bitcast double* %693 to <2 x double>*
store <2 x double> %689, <2 x double>* %694
%695 = getelementptr inbounds double, double* %693, i64 2
%696 = bitcast double* %695 to <2 x double>*
store <2 x double> %692, <2 x double>* %696
br label %697
697: ; preds = %678, %681
%698 = icmp eq i64 %612, %633
br i1 %698, label %897, label %699
699: ; preds = %614, %600, %697
%700 = phi i64 [ 1, %614 ], [ 1, %600 ], [ %634, %697 ]
%701 = sub nsw i64 %611, %700
%702 = xor i64 %700, -1
%703 = add nsw i64 %702, %611
%704 = and i64 %701, 3
%705 = icmp eq i64 %704, 0
br i1 %705, label %716, label %706
706: ; preds = %699, %706
%707 = phi i64 [ %713, %706 ], [ %700, %699 ]
%708 = phi i64 [ %714, %706 ], [ 0, %699 ]
%709 = getelementptr inbounds double, double* %603, i64 %707
store double 0.000000e+00, double* %709
%710 = getelementptr inbounds double, double* %605, i64 %707
%711 = load double, double* %710
%712 = getelementptr inbounds double, double* %609, i64 %707
store double %711, double* %712
%713 = add nuw nsw i64 %707, 1
%714 = add i64 %708, 1
%715 = icmp eq i64 %714, %704
br i1 %715, label %716, label %706
716: ; preds = %706, %699
%717 = phi i64 [ %700, %699 ], [ %713, %706 ]
%718 = icmp ult i64 %703, 3
br i1 %718, label %897, label %857
719: ; preds = %447
%720 = icmp slt i32 %1, 1
br i1 %720, label %897, label %721
721: ; preds = %719
%722 = sext i32 %0 to i64
%723 = getelementptr inbounds double*, double** %2, i64 %722
%724 = load double*, double** %723
%725 = getelementptr inbounds double*, double** %3, i64 %722
%726 = load double*, double** %725
%727 = add nsw i32 %0, 1
%728 = sext i32 %727 to i64
%729 = getelementptr inbounds double*, double** %3, i64 %728
%730 = load double*, double** %729
%731 = add nuw i32 %1, 1
%732 = zext i32 %731 to i64
%733 = add nsw i64 %732, -1
%734 = icmp ult i64 %733, 4
br i1 %734, label %826, label %735
735: ; preds = %721
%736 = getelementptr double, double* %724, i64 1
%737 = getelementptr double, double* %724, i64 %732
%738 = getelementptr double, double* %730, i64 1
%739 = getelementptr double, double* %730, i64 %732
%740 = getelementptr double, double* %726, i64 1
%741 = getelementptr double, double* %726, i64 %732
%742 = icmp ult double* %736, %739
%743 = icmp ult double* %738, %737
%744 = and i1 %742, %743
%745 = icmp ult double* %736, %741
%746 = icmp ult double* %740, %737
%747 = and i1 %745, %746
%748 = or i1 %744, %747
%749 = icmp ult double* %738, %741
%750 = icmp ult double* %740, %739
%751 = and i1 %749, %750
%752 = or i1 %748, %751
br i1 %752, label %826, label %753
753: ; preds = %735
%754 = and i64 %733, -4
%755 = or i64 %754, 1
%756 = add nsw i64 %754, -4
%757 = lshr exact i64 %756, 2
%758 = add nuw nsw i64 %757, 1
%759 = and i64 %758, 1
%760 = icmp eq i64 %756, 0
br i1 %760, label %803, label %761
761: ; preds = %753
%762 = and i64 %758, 9223372036854775806
br label %763
763: ; preds = %763, %761
%764 = phi i64 [ 0, %761 ], [ %800, %763 ]
%765 = phi i64 [ 0, %761 ], [ %801, %763 ]
%766 = or i64 %764, 1
%767 = getelementptr inbounds double, double* %724, i64 %766
%768 = bitcast double* %767 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %768
%769 = getelementptr inbounds double, double* %767, i64 2
%770 = bitcast double* %769 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %770
%771 = getelementptr inbounds double, double* %726, i64 %766
%772 = bitcast double* %771 to <2 x double>*
%773 = load <2 x double>, <2 x double>* %772
%774 = getelementptr inbounds double, double* %771, i64 2
%775 = bitcast double* %774 to <2 x double>*
%776 = load <2 x double>, <2 x double>* %775
%777 = fneg <2 x double> %773
%778 = fneg <2 x double> %776
%779 = getelementptr inbounds double, double* %730, i64 %766
%780 = bitcast double* %779 to <2 x double>*
store <2 x double> %777, <2 x double>* %780
%781 = getelementptr inbounds double, double* %779, i64 2
%782 = bitcast double* %781 to <2 x double>*
store <2 x double> %778, <2 x double>* %782
%783 = or i64 %764, 5
%784 = getelementptr inbounds double, double* %724, i64 %783
%785 = bitcast double* %784 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %785
%786 = getelementptr inbounds double, double* %784, i64 2
%787 = bitcast double* %786 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %787
%788 = getelementptr inbounds double, double* %726, i64 %783
%789 = bitcast double* %788 to <2 x double>*
%790 = load <2 x double>, <2 x double>* %789
%791 = getelementptr inbounds double, double* %788, i64 2
%792 = bitcast double* %791 to <2 x double>*
%793 = load <2 x double>, <2 x double>* %792
%794 = fneg <2 x double> %790
%795 = fneg <2 x double> %793
%796 = getelementptr inbounds double, double* %730, i64 %783
%797 = bitcast double* %796 to <2 x double>*
store <2 x double> %794, <2 x double>* %797
%798 = getelementptr inbounds double, double* %796, i64 2
%799 = bitcast double* %798 to <2 x double>*
store <2 x double> %795, <2 x double>* %799
%800 = add nuw i64 %764, 8
%801 = add i64 %765, 2
%802 = icmp eq i64 %801, %762
br i1 %802, label %803, label %763
803: ; preds = %763, %753
%804 = phi i64 [ 0, %753 ], [ %800, %763 ]
%805 = icmp eq i64 %759, 0
br i1 %805, label %824, label %806
806: ; preds = %803
%807 = or i64 %804, 1
%808 = getelementptr inbounds double, double* %724, i64 %807
%809 = bitcast double* %808 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %809
%810 = getelementptr inbounds double, double* %808, i64 2
%811 = bitcast double* %810 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %811
%812 = getelementptr inbounds double, double* %726, i64 %807
%813 = bitcast double* %812 to <2 x double>*
%814 = load <2 x double>, <2 x double>* %813
%815 = getelementptr inbounds double, double* %812, i64 2
%816 = bitcast double* %815 to <2 x double>*
%817 = load <2 x double>, <2 x double>* %816
%818 = fneg <2 x double> %814
%819 = fneg <2 x double> %817
%820 = getelementptr inbounds double, double* %730, i64 %807
%821 = bitcast double* %820 to <2 x double>*
store <2 x double> %818, <2 x double>* %821
%822 = getelementptr inbounds double, double* %820, i64 2
%823 = bitcast double* %822 to <2 x double>*
store <2 x double> %819, <2 x double>* %823
br label %824
824: ; preds = %803, %806
%825 = icmp eq i64 %733, %754
br i1 %825, label %897, label %826
826: ; preds = %735, %721, %824
%827 = phi i64 [ 1, %735 ], [ 1, %721 ], [ %755, %824 ]
%828 = xor i64 %827, -1
%829 = and i64 %732, 1
%830 = icmp eq i64 %829, 0
br i1 %830, label %831, label %838
831: ; preds = %826
%832 = getelementptr inbounds double, double* %724, i64 %827
store double 0.000000e+00, double* %832
%833 = getelementptr inbounds double, double* %726, i64 %827
%834 = load double, double* %833
%835 = fneg double %834
%836 = getelementptr inbounds double, double* %730, i64 %827
store double %835, double* %836
%837 = add nuw nsw i64 %827, 1
br label %838
838: ; preds = %831, %826
%839 = phi i64 [ %827, %826 ], [ %837, %831 ]
%840 = sub nsw i64 0, %732
%841 = icmp eq i64 %828, %840
br i1 %841, label %897, label %842
842: ; preds = %838, %842
%843 = phi i64 [ %855, %842 ], [ %839, %838 ]
%844 = getelementptr inbounds double, double* %724, i64 %843
store double 0.000000e+00, double* %844
%845 = getelementptr inbounds double, double* %726, i64 %843
%846 = load double, double* %845
%847 = fneg double %846
%848 = getelementptr inbounds double, double* %730, i64 %843
store double %847, double* %848
%849 = add nuw nsw i64 %843, 1
%850 = getelementptr inbounds double, double* %724, i64 %849
store double 0.000000e+00, double* %850
%851 = getelementptr inbounds double, double* %726, i64 %849
%852 = load double, double* %851
%853 = fneg double %852
%854 = getelementptr inbounds double, double* %730, i64 %849
store double %853, double* %854
%855 = add nuw nsw i64 %843, 2
%856 = icmp eq i64 %855, %732
br i1 %856, label %897, label %842
857: ; preds = %716, %857
%858 = phi i64 [ %878, %857 ], [ %717, %716 ]
%859 = getelementptr inbounds double, double* %603, i64 %858
store double 0.000000e+00, double* %859
%860 = getelementptr inbounds double, double* %605, i64 %858
%861 = load double, double* %860
%862 = getelementptr inbounds double, double* %609, i64 %858
store double %861, double* %862
%863 = add nuw nsw i64 %858, 1
%864 = getelementptr inbounds double, double* %603, i64 %863
store double 0.000000e+00, double* %864
%865 = getelementptr inbounds double, double* %605, i64 %863
%866 = load double, double* %865
%867 = getelementptr inbounds double, double* %609, i64 %863
store double %866, double* %867
%868 = add nuw nsw i64 %858, 2
%869 = getelementptr inbounds double, double* %603, i64 %868
store double 0.000000e+00, double* %869
%870 = getelementptr inbounds double, double* %605, i64 %868
%871 = load double, double* %870
%872 = getelementptr inbounds double, double* %609, i64 %868
store double %871, double* %872
%873 = add nuw nsw i64 %858, 3
%874 = getelementptr inbounds double, double* %603, i64 %873
store double 0.000000e+00, double* %874
%875 = getelementptr inbounds double, double* %605, i64 %873
%876 = load double, double* %875
%877 = getelementptr inbounds double, double* %609, i64 %873
store double %876, double* %877
%878 = add nuw nsw i64 %858, 4
%879 = icmp eq i64 %878, %611
br i1 %879, label %897, label %857
880: ; preds = %594, %880
%881 = phi i64 [ %895, %880 ], [ %595, %594 ]
%882 = getelementptr inbounds double, double* %454, i64 %881
%883 = load double, double* %882
%884 = getelementptr inbounds double, double* %457, i64 %881
store double %883, double* %884
%885 = getelementptr inbounds double, double* %459, i64 %881
%886 = load double, double* %885
%887 = getelementptr inbounds double, double* %463, i64 %881
store double %886, double* %887
%888 = add nuw nsw i64 %881, 1
%889 = getelementptr inbounds double, double* %454, i64 %888
%890 = load double, double* %889
%891 = getelementptr inbounds double, double* %457, i64 %888
store double %890, double* %891
%892 = getelementptr inbounds double, double* %459, i64 %888
%893 = load double, double* %892
%894 = getelementptr inbounds double, double* %463, i64 %888
store double %893, double* %894
%895 = add nuw nsw i64 %881, 2
%896 = icmp eq i64 %895, %465
br i1 %896, label %897, label %880
897: ; preds = %594, %880, %716, %857, %838, %842, %579, %697, %824, %448, %598, %719, %447
switch i32 %7, label %1047 [
i32 1, label %922
i32 2, label %911
i32 3, label %898
]
898: ; preds = %897
%899 = icmp slt i32 %0, 1
br i1 %899, label %1047, label %900
900: ; preds = %898
%901 = add nsw i32 %1, -1
%902 = sext i32 %901 to i64
%903 = sext i32 %1 to i64
%904 = add nsw i32 %1, 1
%905 = sext i32 %904 to i64
%906 = zext i32 %0 to i64
%907 = and i64 %906, 1
%908 = icmp eq i32 %0, 1
br i1 %908, label %1033, label %909
909: ; preds = %900
%910 = and i64 %906, 4294967294
br label %981
911: ; preds = %897
%912 = icmp slt i32 %0, 1
br i1 %912, label %1047, label %913
913: ; preds = %911
%914 = sext i32 %1 to i64
%915 = add nsw i32 %1, 1
%916 = sext i32 %915 to i64
%917 = zext i32 %0 to i64
%918 = and i64 %917, 1
%919 = icmp eq i32 %0, 1
br i1 %919, label %1021, label %920
920: ; preds = %913
%921 = and i64 %917, 4294967294
br label %958
922: ; preds = %897
%923 = icmp slt i32 %0, 1
br i1 %923, label %1047, label %924
924: ; preds = %922
%925 = sext i32 %1 to i64
%926 = add nsw i32 %1, 1
%927 = sext i32 %926 to i64
%928 = zext i32 %0 to i64
%929 = and i64 %928, 1
%930 = icmp eq i32 %0, 1
br i1 %930, label %1008, label %931
931: ; preds = %924
%932 = and i64 %928, 4294967294
br label %933
933: ; preds = %933, %931
%934 = phi i64 [ 1, %931 ], [ %955, %933 ]
%935 = phi i64 [ 0, %931 ], [ %956, %933 ]
%936 = getelementptr inbounds double*, double** %3, i64 %934
%937 = load double*, double** %936
%938 = getelementptr inbounds double, double* %937, i64 %925
store double 0.000000e+00, double* %938
%939 = getelementptr inbounds double*, double** %2, i64 %934
%940 = load double*, double** %939
%941 = getelementptr inbounds double, double* %940, i64 %925
%942 = load double, double* %941
%943 = fneg double %942
%944 = getelementptr inbounds double, double* %940, i64 %927
store double %943, double* %944
%945 = add nuw nsw i64 %934, 1
%946 = getelementptr inbounds double*, double** %3, i64 %945
%947 = load double*, double** %946
%948 = getelementptr inbounds double, double* %947, i64 %925
store double 0.000000e+00, double* %948
%949 = getelementptr inbounds double*, double** %2, i64 %945
%950 = load double*, double** %949
%951 = getelementptr inbounds double, double* %950, i64 %925
%952 = load double, double* %951
%953 = fneg double %952
%954 = getelementptr inbounds double, double* %950, i64 %927
store double %953, double* %954
%955 = add nuw nsw i64 %934, 2
%956 = add i64 %935, 2
%957 = icmp eq i64 %956, %932
br i1 %957, label %1008, label %933
958: ; preds = %958, %920
%959 = phi i64 [ 1, %920 ], [ %978, %958 ]
%960 = phi i64 [ 0, %920 ], [ %979, %958 ]
%961 = getelementptr inbounds double*, double** %3, i64 %959
%962 = load double*, double** %961
%963 = getelementptr inbounds double, double* %962, i64 %914
store double 0.000000e+00, double* %963
%964 = getelementptr inbounds double*, double** %2, i64 %959
%965 = load double*, double** %964
%966 = getelementptr inbounds double, double* %965, i64 %914
%967 = load double, double* %966
%968 = getelementptr inbounds double, double* %965, i64 %916
store double %967, double* %968
%969 = add nuw nsw i64 %959, 1
%970 = getelementptr inbounds double*, double** %3, i64 %969
%971 = load double*, double** %970
%972 = getelementptr inbounds double, double* %971, i64 %914
store double 0.000000e+00, double* %972
%973 = getelementptr inbounds double*, double** %2, i64 %969
%974 = load double*, double** %973
%975 = getelementptr inbounds double, double* %974, i64 %914
%976 = load double, double* %975
%977 = getelementptr inbounds double, double* %974, i64 %916
store double %976, double* %977
%978 = add nuw nsw i64 %959, 2
%979 = add i64 %960, 2
%980 = icmp eq i64 %979, %921
br i1 %980, label %1021, label %958
981: ; preds = %981, %909
%982 = phi i64 [ 1, %909 ], [ %1005, %981 ]
%983 = phi i64 [ 0, %909 ], [ %1006, %981 ]
%984 = getelementptr inbounds double*, double** %3, i64 %982
%985 = load double*, double** %984
%986 = getelementptr inbounds double, double* %985, i64 %902
%987 = load double, double* %986
%988 = getelementptr inbounds double, double* %985, i64 %903
store double %987, double* %988
%989 = getelementptr inbounds double*, double** %2, i64 %982
%990 = load double*, double** %989
%991 = getelementptr inbounds double, double* %990, i64 %903
%992 = load double, double* %991
%993 = getelementptr inbounds double, double* %990, i64 %905
store double %992, double* %993
%994 = add nuw nsw i64 %982, 1
%995 = getelementptr inbounds double*, double** %3, i64 %994
%996 = load double*, double** %995
%997 = getelementptr inbounds double, double* %996, i64 %902
%998 = load double, double* %997
%999 = getelementptr inbounds double, double* %996, i64 %903
store double %998, double* %999
%1000 = getelementptr inbounds double*, double** %2, i64 %994
%1001 = load double*, double** %1000
%1002 = getelementptr inbounds double, double* %1001, i64 %903
%1003 = load double, double* %1002
%1004 = getelementptr inbounds double, double* %1001, i64 %905
store double %1003, double* %1004
%1005 = add nuw nsw i64 %982, 2
%1006 = add i64 %983, 2
%1007 = icmp eq i64 %1006, %910
br i1 %1007, label %1033, label %981
1008: ; preds = %933, %924
%1009 = phi i64 [ 1, %924 ], [ %955, %933 ]
%1010 = icmp eq i64 %929, 0
br i1 %1010, label %1047, label %1011
1011: ; preds = %1008
%1012 = getelementptr inbounds double*, double** %3, i64 %1009
%1013 = load double*, double** %1012
%1014 = getelementptr inbounds double, double* %1013, i64 %925
store double 0.000000e+00, double* %1014
%1015 = getelementptr inbounds double*, double** %2, i64 %1009
%1016 = load double*, double** %1015
%1017 = getelementptr inbounds double, double* %1016, i64 %925
%1018 = load double, double* %1017
%1019 = fneg double %1018
%1020 = getelementptr inbounds double, double* %1016, i64 %927
store double %1019, double* %1020
br label %1047
1021: ; preds = %958, %913
%1022 = phi i64 [ 1, %913 ], [ %978, %958 ]
%1023 = icmp eq i64 %918, 0
br i1 %1023, label %1047, label %1024
1024: ; preds = %1021
%1025 = getelementptr inbounds double*, double** %3, i64 %1022
%1026 = load double*, double** %1025
%1027 = getelementptr inbounds double, double* %1026, i64 %914
store double 0.000000e+00, double* %1027
%1028 = getelementptr inbounds double*, double** %2, i64 %1022
%1029 = load double*, double** %1028
%1030 = getelementptr inbounds double, double* %1029, i64 %914
%1031 = load double, double* %1030
%1032 = getelementptr inbounds double, double* %1029, i64 %916
store double %1031, double* %1032
br label %1047
1033: ; preds = %981, %900
%1034 = phi i64 [ 1, %900 ], [ %1005, %981 ]
%1035 = icmp eq i64 %907, 0
br i1 %1035, label %1047, label %1036
1036: ; preds = %1033
%1037 = getelementptr inbounds double*, double** %3, i64 %1034
%1038 = load double*, double** %1037
%1039 = getelementptr inbounds double, double* %1038, i64 %902
%1040 = load double, double* %1039
%1041 = getelementptr inbounds double, double* %1038, i64 %903
store double %1040, double* %1041
%1042 = getelementptr inbounds double*, double** %2, i64 %1034
%1043 = load double*, double** %1042
%1044 = getelementptr inbounds double, double* %1043, i64 %903
%1045 = load double, double* %1044
%1046 = getelementptr inbounds double, double* %1043, i64 %905
store double %1045, double* %1046
br label %1047
1047: ; preds = %1036, %1033, %1024, %1021, %1011, %1008, %898, %911, %922, %897
switch i32 %8, label %1190 [
i32 1, label %1067
i32 2, label %1056
i32 3, label %1048
]
1048: ; preds = %1047
%1049 = icmp slt i32 %0, 1
br i1 %1049, label %1190, label %1050
1050: ; preds = %1048
%1051 = zext i32 %0 to i64
%1052 = and i64 %1051, 1
%1053 = icmp eq i32 %0, 1
br i1 %1053, label %1178, label %1054
1054: ; preds = %1050
%1055 = and i64 %1051, 4294967294
br label %1129
1056: ; preds = %1047
%1057 = icmp slt i32 %0, 1
br i1 %1057, label %1190, label %1058
1058: ; preds = %1056
%1059 = add nuw i32 %0, 1
%1060 = zext i32 %1059 to i64
%1061 = add nsw i64 %1060, -1
%1062 = add nsw i64 %1060, -2
%1063 = and i64 %1061, 3
%1064 = icmp ult i64 %1062, 3
br i1 %1064, label %1163, label %1065
1065: ; preds = %1058
%1066 = and i64 %1061, -4
br label %1096
1067: ; preds = %1047
%1068 = icmp slt i32 %0, 1
br i1 %1068, label %1190, label %1069
1069: ; preds = %1067
%1070 = zext i32 %0 to i64
%1071 = and i64 %1070, 1
%1072 = icmp eq i32 %0, 1
br i1 %1072, label %1152, label %1073
1073: ; preds = %1069
%1074 = and i64 %1070, 4294967294
br label %1075
1075: ; preds = %1075, %1073
%1076 = phi i64 [ 1, %1073 ], [ %1093, %1075 ]
%1077 = phi i64 [ 0, %1073 ], [ %1094, %1075 ]
%1078 = getelementptr inbounds double*, double** %3, i64 %1076
%1079 = load double*, double** %1078
store double 0.000000e+00, double* %1079
%1080 = getelementptr inbounds double*, double** %2, i64 %1076
%1081 = load double*, double** %1080
%1082 = getelementptr inbounds double, double* %1081, i64 1
%1083 = load double, double* %1082
%1084 = fneg double %1083
store double %1084, double* %1081
%1085 = add nuw nsw i64 %1076, 1
%1086 = getelementptr inbounds double*, double** %3, i64 %1085
%1087 = load double*, double** %1086
store double 0.000000e+00, double* %1087
%1088 = getelementptr inbounds double*, double** %2, i64 %1085
%1089 = load double*, double** %1088
%1090 = getelementptr inbounds double, double* %1089, i64 1
%1091 = load double, double* %1090
%1092 = fneg double %1091
store double %1092, double* %1089
%1093 = add nuw nsw i64 %1076, 2
%1094 = add i64 %1077, 2
%1095 = icmp eq i64 %1094, %1074
br i1 %1095, label %1152, label %1075
1096: ; preds = %1096, %1065
%1097 = phi i64 [ 1, %1065 ], [ %1126, %1096 ]
%1098 = phi i64 [ 0, %1065 ], [ %1127, %1096 ]
%1099 = getelementptr inbounds double*, double** %3, i64 %1097
%1100 = load double*, double** %1099
store double 0.000000e+00, double* %1100
%1101 = getelementptr inbounds double*, double** %2, i64 %1097
%1102 = load double*, double** %1101
%1103 = getelementptr inbounds double, double* %1102, i64 1
%1104 = load double, double* %1103
store double %1104, double* %1102
%1105 = add nuw nsw i64 %1097, 1
%1106 = getelementptr inbounds double*, double** %3, i64 %1105
%1107 = load double*, double** %1106
store double 0.000000e+00, double* %1107
%1108 = getelementptr inbounds double*, double** %2, i64 %1105
%1109 = load double*, double** %1108
%1110 = getelementptr inbounds double, double* %1109, i64 1
%1111 = load double, double* %1110
store double %1111, double* %1109
%1112 = add nuw nsw i64 %1097, 2
%1113 = getelementptr inbounds double*, double** %3, i64 %1112
%1114 = load double*, double** %1113
store double 0.000000e+00, double* %1114
%1115 = getelementptr inbounds double*, double** %2, i64 %1112
%1116 = load double*, double** %1115
%1117 = getelementptr inbounds double, double* %1116, i64 1
%1118 = load double, double* %1117
store double %1118, double* %1116
%1119 = add nuw nsw i64 %1097, 3
%1120 = getelementptr inbounds double*, double** %3, i64 %1119
%1121 = load double*, double** %1120
store double 0.000000e+00, double* %1121
%1122 = getelementptr inbounds double*, double** %2, i64 %1119
%1123 = load double*, double** %1122
%1124 = getelementptr inbounds double, double* %1123, i64 1
%1125 = load double, double* %1124
store double %1125, double* %1123
%1126 = add nuw nsw i64 %1097, 4
%1127 = add i64 %1098, 4
%1128 = icmp eq i64 %1127, %1066
br i1 %1128, label %1163, label %1096
1129: ; preds = %1129, %1054
%1130 = phi i64 [ 1, %1054 ], [ %1149, %1129 ]
%1131 = phi i64 [ 0, %1054 ], [ %1150, %1129 ]
%1132 = getelementptr inbounds double*, double** %3, i64 %1130
%1133 = load double*, double** %1132
%1134 = getelementptr inbounds double, double* %1133, i64 1
%1135 = load double, double* %1134
store double %1135, double* %1133
%1136 = getelementptr inbounds double*, double** %2, i64 %1130
%1137 = load double*, double** %1136
%1138 = getelementptr inbounds double, double* %1137, i64 1
%1139 = load double, double* %1138
store double %1139, double* %1137
%1140 = add nuw nsw i64 %1130, 1
%1141 = getelementptr inbounds double*, double** %3, i64 %1140
%1142 = load double*, double** %1141
%1143 = getelementptr inbounds double, double* %1142, i64 1
%1144 = load double, double* %1143
store double %1144, double* %1142
%1145 = getelementptr inbounds double*, double** %2, i64 %1140
%1146 = load double*, double** %1145
%1147 = getelementptr inbounds double, double* %1146, i64 1
%1148 = load double, double* %1147
store double %1148, double* %1146
%1149 = add nuw nsw i64 %1130, 2
%1150 = add i64 %1131, 2
%1151 = icmp eq i64 %1150, %1055
br i1 %1151, label %1178, label %1129
1152: ; preds = %1075, %1069
%1153 = phi i64 [ 1, %1069 ], [ %1093, %1075 ]
%1154 = icmp eq i64 %1071, 0
br i1 %1154, label %1190, label %1155
1155: ; preds = %1152
%1156 = getelementptr inbounds double*, double** %3, i64 %1153
%1157 = load double*, double** %1156
store double 0.000000e+00, double* %1157
%1158 = getelementptr inbounds double*, double** %2, i64 %1153
%1159 = load double*, double** %1158
%1160 = getelementptr inbounds double, double* %1159, i64 1
%1161 = load double, double* %1160
%1162 = fneg double %1161
store double %1162, double* %1159
br label %1190
1163: ; preds = %1096, %1058
%1164 = phi i64 [ 1, %1058 ], [ %1126, %1096 ]
%1165 = icmp eq i64 %1063, 0
br i1 %1165, label %1190, label %1166
1166: ; preds = %1163, %1166
%1167 = phi i64 [ %1175, %1166 ], [ %1164, %1163 ]
%1168 = phi i64 [ %1176, %1166 ], [ 0, %1163 ]
%1169 = getelementptr inbounds double*, double** %3, i64 %1167
%1170 = load double*, double** %1169
store double 0.000000e+00, double* %1170
%1171 = getelementptr inbounds double*, double** %2, i64 %1167
%1172 = load double*, double** %1171
%1173 = getelementptr inbounds double, double* %1172, i64 1
%1174 = load double, double* %1173
store double %1174, double* %1172
%1175 = add nuw nsw i64 %1167, 1
%1176 = add i64 %1168, 1
%1177 = icmp eq i64 %1176, %1063
br i1 %1177, label %1190, label %1166
1178: ; preds = %1129, %1050
%1179 = phi i64 [ 1, %1050 ], [ %1149, %1129 ]
%1180 = icmp eq i64 %1052, 0
br i1 %1180, label %1190, label %1181
1181: ; preds = %1178
%1182 = getelementptr inbounds double*, double** %3, i64 %1179
%1183 = load double*, double** %1182
%1184 = getelementptr inbounds double, double* %1183, i64 1
%1185 = load double, double* %1184
store double %1185, double* %1183
%1186 = getelementptr inbounds double*, double** %2, i64 %1179
%1187 = load double*, double** %1186
%1188 = getelementptr inbounds double, double* %1187, i64 1
%1189 = load double, double* %1188
store double %1189, double* %1187
br label %1190
1190: ; preds = %1181, %1178, %1163, %1166, %1155, %1152, %1048, %1056, %1067, %1047
%1191 = tail call i32 @spec_boundary_val(i8* %11, i32 %0, i32 %1, double** %2, double** %3, i32** %12, double %13)
ret void
}