void apply_boundary_conditions(double **u, double **v, char **flag, int imax,
                               int jmax, double ui, double vi) {
  int i, j;
  for (j = 0; j <= jmax + 1; j++) {
    u[0][j] = u[1][j];
    v[0][j] = v[1][j];
    u[imax][j] = u[imax - 1][j];
    v[imax + 1][j] = v[imax][j];
  }
  for (i = 0; i <= imax + 1; i++) {
    v[i][jmax] = 0.0;
    u[i][jmax + 1] = u[i][jmax];
    v[i][0] = 0.0;
    u[i][0] = u[i][1];
  }
  for (i = 1; i <= imax; i++) {
    for (j = 1; j <= jmax; j++) {
      if (flag[i][j] & (0x0001 | 0x0002 | 0x0008 | 0x0004)) {
        switch (flag[i][j]) {
        case 0x0001:
          u[i][j] = -u[i][j + 1];
          break;
        case 0x0008:
          u[i][j] = 0.0;
          break;
        case (0x0001 | 0x0008):
          u[i][j] = 0.0;
          break;
        case (0x0002 | 0x0008):
          u[i][j] = 0.0;
          break;
        case (0x0001 | 0x0004):
          u[i][j] = -u[i][j + 1];
          break;
        case 0x0002:
          u[i][j] = -u[i][j - 1];
          break;
        case (0x0002 | 0x0004):
          u[i][j] = -u[i][j - 1];
          break;
        }
      }
    }
  }
  for (i = 0; i <= (imax - 1); i++) {
    for (j = 1; j <= jmax; j++) {
      if (flag[i + 1][j] & (0x0001 | 0x0002 | 0x0008 | 0x0004)) {
        switch (flag[i + 1][j]) {
        case 0x0001:
          u[i][j] = -u[i][j + 1];
          break;
        case 0x0004:
          u[i][j] = 0.0;
          break;
        case (0x0001 | 0x0008):
          u[i][j] = -u[i][j + 1];
          break;
        case (0x0002 | 0x0004):
          u[i][j] = 0.0;
          break;
        case (0x0001 | 0x0004):
          u[i][j] = 0.0;
          break;
        case 0x0002:
          u[i][j] = -u[i][j - 1];
          break;
        case (0x0002 | 0x0008):
          u[i][j] = -u[i][j - 1];
          break;
        }
      }
    }
  }
  for (i = 1; i <= imax; i++) {
    for (j = 1; j <= jmax; j++) {
      if (flag[i][j] & (0x0001 | 0x0002 | 0x0008 | 0x0004)) {
        switch (flag[i][j]) {
        case 0x0001:
          v[i][j] = 0.0;
          break;
        case 0x0008:
          v[i][j] = -v[i + 1][j];
          break;
        case (0x0001 | 0x0008):
          v[i][j] = 0.0;
          break;
        case (0x0002 | 0x0008):
          v[i][j] = -v[i + 1][j];
          break;
        case (0x0001 | 0x0004):
          v[i][j] = 0.0;
          break;
        case 0x0004:
          v[i][j] = -v[i - 1][j];
          break;
        case (0x0002 | 0x0004):
          v[i][j] = -v[i - 1][j];
          break;
        }
      }
    }
  }
  for (i = 1; i <= imax; i++) {
    for (j = 0; j <= (jmax - 1); j++) {
      if (flag[i][j + 1] & (0x0001 | 0x0002 | 0x0008 | 0x0004)) {
        switch (flag[i][j + 1]) {
        case 0x0008:
          v[i][j] = -v[i + 1][j];
          break;
        case 0x0002:
          v[i][j] = 0.0;
          break;
        case (0x0001 | 0x0008):
          v[i][j] = -v[i + 1][j];
          break;
        case (0x0002 | 0x0008):
          v[i][j] = 0.0;
          break;
        case (0x0002 | 0x0004):
          v[i][j] = 0.0;
          break;
        case 0x0004:
          v[i][j] = -v[i - 1][j];
          break;
        case (0x0001 | 0x0004):
          v[i][j] = -v[i - 1][j];
          break;
        }
      }
    }
  }
  v[0][0] = 2 * vi - v[1][0];
  for (j = 1; j <= jmax; j++) {
    u[0][j] = ui;
    v[0][j] = 2 * vi - v[1][j];
  }
}


x86 assembly (clang, -O0):
<apply_boundary_conditions>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
movsd  %xmm0,-0x28(%rbp)
movsd  %xmm1,-0x30(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     11e7 <apply_boundary_conditions+0xe7>
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1128 <apply_boundary_conditions+0x28>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1288 <apply_boundary_conditions+0x188>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11ee <apply_boundary_conditions+0xee>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     14b1 <apply_boundary_conditions+0x3b1>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     149e <apply_boundary_conditions+0x39e>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
and    $0xf,%eax
cmp    $0x0,%eax
je     148b <apply_boundary_conditions+0x38b>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0x40(%rbp)
sub    $0x9,%eax
ja     1486 <apply_boundary_conditions+0x386>
mov    -0x40(%rbp),%rax
lea    0xd75(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1486 <apply_boundary_conditions+0x386>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1486 <apply_boundary_conditions+0x386>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1486 <apply_boundary_conditions+0x386>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1486 <apply_boundary_conditions+0x386>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1486 <apply_boundary_conditions+0x386>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1486 <apply_boundary_conditions+0x386>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    148b <apply_boundary_conditions+0x38b>
jmp    1490 <apply_boundary_conditions+0x390>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12a2 <apply_boundary_conditions+0x1a2>
jmp    14a3 <apply_boundary_conditions+0x3a3>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    128f <apply_boundary_conditions+0x18f>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     16e5 <apply_boundary_conditions+0x5e5>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     16d2 <apply_boundary_conditions+0x5d2>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
and    $0xf,%eax
cmp    $0x0,%eax
je     16bf <apply_boundary_conditions+0x5bf>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    0x8(%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0x48(%rbp)
sub    $0x9,%eax
ja     16ba <apply_boundary_conditions+0x5ba>
mov    -0x48(%rbp),%rax
lea    0xb19(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    16ba <apply_boundary_conditions+0x5ba>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    16ba <apply_boundary_conditions+0x5ba>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    16ba <apply_boundary_conditions+0x5ba>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    16ba <apply_boundary_conditions+0x5ba>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    16ba <apply_boundary_conditions+0x5ba>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    16ba <apply_boundary_conditions+0x5ba>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    16bf <apply_boundary_conditions+0x5bf>
jmp    16c4 <apply_boundary_conditions+0x5c4>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    14d0 <apply_boundary_conditions+0x3d0>
jmp    16d7 <apply_boundary_conditions+0x5d7>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14b8 <apply_boundary_conditions+0x3b8>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     190e <apply_boundary_conditions+0x80e>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     18fb <apply_boundary_conditions+0x7fb>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
and    $0xf,%eax
cmp    $0x0,%eax
je     18e8 <apply_boundary_conditions+0x7e8>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0x50(%rbp)
sub    $0x9,%eax
ja     18e3 <apply_boundary_conditions+0x7e3>
mov    -0x50(%rbp),%rax
lea    0x8c8(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    18e3 <apply_boundary_conditions+0x7e3>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    18e3 <apply_boundary_conditions+0x7e3>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    18e3 <apply_boundary_conditions+0x7e3>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    18e3 <apply_boundary_conditions+0x7e3>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    18e3 <apply_boundary_conditions+0x7e3>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    18e3 <apply_boundary_conditions+0x7e3>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    18e8 <apply_boundary_conditions+0x7e8>
jmp    18ed <apply_boundary_conditions+0x7ed>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    16ff <apply_boundary_conditions+0x5ff>
jmp    1900 <apply_boundary_conditions+0x800>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    16ec <apply_boundary_conditions+0x5ec>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1b42 <apply_boundary_conditions+0xa42>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1b2f <apply_boundary_conditions+0xa2f>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
and    $0xf,%eax
cmp    $0x0,%eax
je     1b1c <apply_boundary_conditions+0xa1c>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
movslq -0x38(%rbp),%rax
movsbl 0x1(%rax,%rcx,1),%eax
add    $0xfffffffe,%eax
mov    %eax,%ecx
mov    %rcx,-0x58(%rbp)
sub    $0x8,%eax
ja     1b17 <apply_boundary_conditions+0xa17>
mov    -0x58(%rbp),%rax
lea    0x670(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b17 <apply_boundary_conditions+0xa17>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b17 <apply_boundary_conditions+0xa17>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b17 <apply_boundary_conditions+0xa17>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b17 <apply_boundary_conditions+0xa17>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b17 <apply_boundary_conditions+0xa17>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b17 <apply_boundary_conditions+0xa17>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b1c <apply_boundary_conditions+0xa1c>
jmp    1b21 <apply_boundary_conditions+0xa21>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1928 <apply_boundary_conditions+0x828>
jmp    1b34 <apply_boundary_conditions+0xa34>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1915 <apply_boundary_conditions+0x815>
movsd  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
movsd  (%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1bf8 <apply_boundary_conditions+0xaf8>
movsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%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    1b84 <apply_boundary_conditions+0xa84>
pop    %rbp
ret

x86 assembly (clang, -O2):
<apply_boundary_conditions>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rdx,-0x8(%rsp)
lea    0x1(%r8),%eax
mov    %eax,-0x14(%rsp)
cmp    $0xffffffff,%r8d
mov    %rcx,-0x10(%rsp)
jl     1219 <apply_boundary_conditions+0x119>
mov    (%rdi),%r10
mov    0x8(%rdi),%rbx
mov    (%rsi),%r11
mov    0x8(%rsi),%r13
movslq %ecx,%rax
mov    -0x8(%rdi,%rax,8),%rbp
mov    (%rdi,%rax,8),%r14
mov    (%rsi,%rax,8),%r15
mov    0x8(%rsi,%rax,8),%r12
xor    %eax,%eax
mov    -0x14(%rsp),%edx
test   %edx,%edx
mov    $0x0,%ecx
cmovg  %edx,%ecx
add    $0x1,%ecx
cmp    $0x7ffffffe,%r8d
ja     11df <apply_boundary_conditions+0xdf>
mov    %ecx,%r9d
and    $0xfffffffe,%r9d
xor    %eax,%eax
xchg   %ax,%ax
movsd  (%rbx,%rax,8),%xmm2
movsd  %xmm2,(%r10,%rax,8)
movsd  0x0(%r13,%rax,8),%xmm2
movsd  %xmm2,(%r11,%rax,8)
movsd  0x0(%rbp,%rax,8),%xmm2
movsd  %xmm2,(%r14,%rax,8)
movsd  (%r15,%rax,8),%xmm2
movsd  %xmm2,(%r12,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm2
movsd  %xmm2,0x8(%r10,%rax,8)
movsd  0x8(%r13,%rax,8),%xmm2
movsd  %xmm2,0x8(%r11,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm2
movsd  %xmm2,0x8(%r14,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm2
movsd  %xmm2,0x8(%r12,%rax,8)
add    $0x2,%rax
cmp    %rax,%r9
jne    1170 <apply_boundary_conditions+0x70>
test   $0x1,%cl
mov    -0x10(%rsp),%rcx
je     1219 <apply_boundary_conditions+0x119>
movsd  (%rbx,%rax,8),%xmm2
movsd  %xmm2,(%r10,%rax,8)
movsd  0x0(%r13,%rax,8),%xmm2
movsd  %xmm2,(%r11,%rax,8)
movsd  0x0(%rbp,%rax,8),%xmm2
movsd  %xmm2,(%r14,%rax,8)
movsd  (%r15,%rax,8),%xmm2
movsd  %xmm2,(%r12,%rax,8)
cmp    $0xffffffff,%ecx
jl     156c <apply_boundary_conditions+0x46c>
movslq %r8d,%rax
movslq -0x14(%rsp),%r11
lea    0x2(%rcx),%r9d
cmp    $0x1,%r9d
jne    1238 <apply_boundary_conditions+0x138>
xor    %ebx,%ebx
jmp    12b7 <apply_boundary_conditions+0x1b7>
mov    %r9d,%r10d
and    $0xfffffffe,%r10d
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rsi,%rbx,8),%rcx
movq   $0x0,(%rcx,%rax,8)
mov    (%rdi,%rbx,8),%rbp
movsd  0x0(%rbp,%rax,8),%xmm2
movsd  %xmm2,0x0(%rbp,%r11,8)
movq   $0x0,(%rcx)
movsd  0x8(%rbp),%xmm2
movsd  %xmm2,0x0(%rbp)
mov    0x8(%rsi,%rbx,8),%rcx
movq   $0x0,(%rcx,%rax,8)
mov    0x8(%rdi,%rbx,8),%rbp
movsd  0x0(%rbp,%rax,8),%xmm2
movsd  %xmm2,0x0(%rbp,%r11,8)
movq   $0x0,(%rcx)
movsd  0x8(%rbp),%xmm2
movsd  %xmm2,0x0(%rbp)
add    $0x2,%rbx
cmp    %rbx,%r10
jne    1250 <apply_boundary_conditions+0x150>
test   $0x1,%r9b
mov    -0x8(%rsp),%r10
je     12ed <apply_boundary_conditions+0x1ed>
mov    (%rsi,%rbx,8),%rcx
movq   $0x0,(%rcx,%rax,8)
mov    (%rdi,%rbx,8),%rbx
movsd  (%rbx,%rax,8),%xmm2
movsd  %xmm2,(%rbx,%r11,8)
movq   $0x0,(%rcx)
movsd  0x8(%rbx),%xmm2
movsd  %xmm2,(%rbx)
mov    -0x10(%rsp),%rax
test   %eax,%eax
jle    156c <apply_boundary_conditions+0x46c>
lea    0x1(%rax),%edx
mov    -0x14(%rsp),%r14d
lea    -0x1(%r14),%r12
mov    $0x1,%r15d
lea    0xcfd(%rip),%r11
movaps 0xce6(%rip),%xmm2
jmp    1329 <apply_boundary_conditions+0x229>
nopl   0x0(%rax)
add    $0x1,%r15
cmp    %rdx,%r15
je     1382 <apply_boundary_conditions+0x282>
test   %r8d,%r8d
jle    1320 <apply_boundary_conditions+0x220>
mov    (%r10,%r15,8),%rbx
xor    %eax,%eax
jmp    1352 <apply_boundary_conditions+0x252>
mov    (%rdi,%r15,8),%rbp
movsd  0x0(%rbp,%rax,8),%xmm3
xorps  %xmm2,%xmm3
movsd  %xmm3,0x8(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r12
je     1320 <apply_boundary_conditions+0x220>
movsbl 0x1(%rbx,%rax,1),%ecx
test   $0xf,%cl
je     1349 <apply_boundary_conditions+0x249>
add    $0xffffffff,%ecx
cmp    $0x9,%ecx
ja     1349 <apply_boundary_conditions+0x249>
movslq (%r11,%rcx,4),%rcx
add    %r11,%rcx
jmp    *%rcx
mov    (%rdi,%r15,8),%rbp
xorps  %xmm3,%xmm3
jmp    1343 <apply_boundary_conditions+0x243>
mov    (%rdi,%r15,8),%rbp
movsd  0x10(%rbp,%rax,8),%xmm3
jmp    1340 <apply_boundary_conditions+0x240>
cmpl   $0x0,-0x10(%rsp)
jle    1407 <apply_boundary_conditions+0x307>
mov    -0x10(%rsp),%r11d
lea    -0x1(%r14),%rax
xor    %r13d,%r13d
lea    0xc9c(%rip),%r15
jmp    13a8 <apply_boundary_conditions+0x2a8>
xchg   %ax,%ax
mov    %r12,%r13
cmp    %r11,%r12
je     1407 <apply_boundary_conditions+0x307>
lea    0x1(%r13),%r12
test   %r8d,%r8d
jle    13a0 <apply_boundary_conditions+0x2a0>
mov    (%r10,%r12,8),%rbx
xor    %ebp,%ebp
jmp    13d6 <apply_boundary_conditions+0x2d6>
mov    (%rdi,%r13,8),%r9
movsd  (%r9,%rbp,8),%xmm3
xorps  %xmm2,%xmm3
movsd  %xmm3,0x8(%r9,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rax
je     13a0 <apply_boundary_conditions+0x2a0>
movsbl 0x1(%rbx,%rbp,1),%ecx
test   $0xf,%cl
je     13cd <apply_boundary_conditions+0x2cd>
add    $0xffffffff,%ecx
cmp    $0x9,%ecx
ja     13cd <apply_boundary_conditions+0x2cd>
movslq (%r15,%rcx,4),%rcx
add    %r15,%rcx
jmp    *%rcx
mov    (%rdi,%r13,8),%r9
xorps  %xmm3,%xmm3
jmp    13c6 <apply_boundary_conditions+0x2c6>
mov    (%rdi,%r13,8),%r9
movsd  0x10(%r9,%rbp,8),%xmm3
jmp    13c3 <apply_boundary_conditions+0x2c3>
cmpl   $0x0,-0x10(%rsp)
jle    156c <apply_boundary_conditions+0x46c>
mov    $0x1,%r12d
lea    0xc41(%rip),%r15
jmp    143c <apply_boundary_conditions+0x33c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r11,%r12
cmp    %rdx,%r11
je     14c0 <apply_boundary_conditions+0x3c0>
test   %r8d,%r8d
jle    14b0 <apply_boundary_conditions+0x3b0>
mov    (%r10,%r12,8),%rbx
lea    (%rsi,%r12,8),%r9
add    $0xfffffffffffffff8,%r9
lea    0x1(%r12),%r11
mov    %r11d,%eax
lea    (%rsi,%rax,8),%r13
mov    $0x1,%ecx
jmp    147d <apply_boundary_conditions+0x37d>
mov    (%rax),%rax
movsd  (%rax,%rcx,8),%xmm3
xorps  %xmm2,%xmm3
mov    (%rsi,%r12,8),%rax
movsd  %xmm3,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r14
je     1430 <apply_boundary_conditions+0x330>
movsbl (%rbx,%rcx,1),%eax
test   $0xf,%al
je     1474 <apply_boundary_conditions+0x374>
add    $0xffffffff,%eax
cmp    $0x9,%eax
ja     1474 <apply_boundary_conditions+0x374>
xorps  %xmm3,%xmm3
movslq (%r15,%rax,4),%rbp
add    %r15,%rbp
mov    %r13,%rax
jmp    *%rbp
mov    %r9,%rax
jmp    1460 <apply_boundary_conditions+0x360>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
mov    %r12,%r11
cmp    %rdx,%r11
jne    143c <apply_boundary_conditions+0x33c>
mov    %r8d,%r13d
mov    $0x1,%r15d
lea    0xbb8(%rip),%r14
jmp    14ed <apply_boundary_conditions+0x3ed>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r11,%r15
mov    -0x8(%rsp),%r10
cmp    %rdx,%r11
je     156c <apply_boundary_conditions+0x46c>
test   %r8d,%r8d
jle    1560 <apply_boundary_conditions+0x460>
mov    (%r10,%r15,8),%rbx
lea    (%rsi,%r15,8),%r9
add    $0xfffffffffffffff8,%r9
lea    0x1(%r15),%r11
mov    %r11d,%eax
lea    (%rsi,%rax,8),%r12
xor    %ebp,%ebp
jmp    1529 <apply_boundary_conditions+0x429>
nopl   (%rax)
mov    (%rax),%rax
movsd  (%rax,%rcx,8),%xmm3
xorps  %xmm2,%xmm3
mov    (%rsi,%r15,8),%rax
movsd  %xmm3,(%rax,%rcx,8)
cmp    %rbp,%r13
je     14e0 <apply_boundary_conditions+0x3e0>
mov    %rbp,%rcx
add    $0x1,%rbp
movsbl 0x1(%rbx,%rcx,1),%eax
test   $0xf,%al
je     1524 <apply_boundary_conditions+0x424>
add    $0xfffffffe,%eax
cmp    $0x8,%eax
ja     1524 <apply_boundary_conditions+0x424>
xorps  %xmm3,%xmm3
movslq (%r14,%rax,4),%r10
add    %r14,%r10
mov    %r12,%rax
jmp    *%r10
mov    %r9,%rax
jmp    1510 <apply_boundary_conditions+0x410>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r15
mov    %r15,%r11
cmp    %rdx,%r11
jne    14ed <apply_boundary_conditions+0x3ed>
mov    (%rsi),%rax
mov    0x8(%rsi),%rcx
movapd %xmm1,%xmm2
addsd  %xmm1,%xmm2
movapd %xmm2,%xmm3
subsd  (%rcx),%xmm3
movsd  %xmm3,(%rax)
test   %r8d,%r8d
jle    16c2 <apply_boundary_conditions+0x5c2>
mov    (%rdi),%rdx
mov    -0x14(%rsp),%esi
lea    -0x1(%rsi),%r8
mov    $0x1,%edi
cmp    $0x4,%r8
jb     1662 <apply_boundary_conditions+0x562>
lea    0x8(%rdx),%rbp
lea    (%rdx,%rsi,8),%r10
lea    0x8(%rax),%r9
lea    (%rax,%rsi,8),%r11
lea    0x8(%rcx),%r14
lea    (%rcx,%rsi,8),%rbx
cmp    %r11,%rbp
setb   %r15b
cmp    %r10,%r9
setb   %r12b
cmp    %rbx,%rbp
setb   %bpl
cmp    %r10,%r14
setb   %r10b
cmp    %rbx,%r9
setb   %r9b
cmp    %r11,%r14
setb   %r11b
test   %r12b,%r15b
jne    1662 <apply_boundary_conditions+0x562>
and    %r10b,%bpl
jne    1662 <apply_boundary_conditions+0x562>
and    %r11b,%r9b
jne    1662 <apply_boundary_conditions+0x562>
mov    %r8,%rbp
and    $0xfffffffffffffffc,%rbp
lea    0x1(%rbp),%rdi
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
unpcklpd %xmm1,%xmm1
xor    %ebx,%ebx
addpd  %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
movupd %xmm3,0x8(%rdx,%rbx,8)
movupd %xmm3,0x18(%rdx,%rbx,8)
movupd 0x8(%rcx,%rbx,8),%xmm4
movupd 0x18(%rcx,%rbx,8),%xmm5
movapd %xmm1,%xmm6
subpd  %xmm4,%xmm6
movapd %xmm1,%xmm4
subpd  %xmm5,%xmm4
movupd %xmm6,0x8(%rax,%rbx,8)
movupd %xmm4,0x18(%rax,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%rbp
jne    1620 <apply_boundary_conditions+0x520>
cmp    %rbp,%r8
je     16c2 <apply_boundary_conditions+0x5c2>
mov    %rdi,%rbp
not    %rbp
test   $0x1,%sil
jne    1685 <apply_boundary_conditions+0x585>
movsd  %xmm0,(%rdx,%rdi,8)
movapd %xmm2,%xmm1
subsd  (%rcx,%rdi,8),%xmm1
movsd  %xmm1,(%rax,%rdi,8)
add    $0x1,%rdi
add    %rsi,%rbp
je     16c2 <apply_boundary_conditions+0x5c2>
nopw   0x0(%rax,%rax,1)
movsd  %xmm0,(%rdx,%rdi,8)
movapd %xmm2,%xmm1
subsd  (%rcx,%rdi,8),%xmm1
movsd  %xmm1,(%rax,%rdi,8)
movsd  %xmm0,0x8(%rdx,%rdi,8)
movapd %xmm2,%xmm1
subsd  0x8(%rcx,%rdi,8),%xmm1
movsd  %xmm1,0x8(%rax,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rsi
jne    1690 <apply_boundary_conditions+0x590>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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