#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*/ printf(char *, int, int, int, int, int, double);
int test_dist_t(double array_t[6][8][10][12], int lst, int ust, int lsx,
                int usx, int lsy, int usy, int lsz, int usz, int lwt, int uwt) {
  int it, ix, iy, iz;
  int err = 0;
#pragma xmp align array_t[iz][iy][ix][it] with tt[iz][iy][ix][it]
#pragma xmp shadow array_t[lsz : usz][lsy : usy][lsx : usx][lst : ust]
#pragma xmp task on pt[0][0][0][0]
  for (iz = 0; iz < 6; iz++) {
    for (iy = 0; iy < 8; iy++) {
      for (ix = 0; ix < 10; ix++) {
        for (it = 0; it < 12 / 2 + uwt; it++) {
          array_t[iz][iy][ix][it] = 1.0;
        }
      }
    }
  }
#pragma xmp task on pt[0][0][0][1]
  for (iz = 0; iz < 6; iz++) {
    for (iy = 0; iy < 8; iy++) {
      for (ix = 0; ix < 10; ix++) {
        for (it = 12 / 2 - lwt; it < 12; it++) {
          array_t[iz][iy][ix][it] = 2.0;
        }
      }
    }
  }
#pragma acc data copy(array_t)
  {
#pragma xmp reflect(array_t) width(0, 0, 0, lwt : uwt) acc
  }
#pragma xmp task on pt[0][0][0][0]
  for (iz = 0; iz < 6; iz++) {
    for (iy = 0; iy < 8; iy++) {
      for (ix = 0; ix < 10; ix++) {
        for (it = 0; it < 12 / 2 + uwt; it++) {
          if (0 <= it && it < 12 / 2) {
            if (array_t[iz][iy][ix][it] != 1.0)
              err++;
          } else {
            if (array_t[iz][iy][ix][it] != 2.0)
              err++;
          }
        }
      }
    }
  }
#pragma xmp task on pt[0][0][0][1]
  for (iz = 0; iz < 6; iz++) {
    for (iy = 0; iy < 8; iy++) {
      for (ix = 0; ix < 10; ix++) {
        for (it = 12 / 2 - lwt; it < 12; it++) {
          if (12 / 2 <= it && it < 12) {
            if (array_t[iz][iy][ix][it] != 2.0)
              err++;
          } else {
            if (array_t[iz][iy][ix][it] != 1.0)
              err++;
          }
        }
      }
    }
  }
#pragma xmp reduction(+ : err)
  if (err == 0)
    return 0;
#pragma xmp task on pt[0][0][0][0]
  for (iz = 0; iz < 6; iz++) {
    for (iy = 0; iy < 8; iy++) {
      for (ix = 0; ix < 10; ix++) {
        for (it = 0; it < 12 / 2 + uwt; it++) {
          printf("node(%d) array[%2d][%2d][%2d][%2d] = %f\n", 1, iz, iy, ix, it,
                 array_t[iz][iy][ix][it]);
        }
      }
    }
  }
#pragma xmp task on pt[0][0][0][1]
  for (iz = 0; iz < 6; iz++) {
    for (iy = 0; iy < 8; iy++) {
      for (ix = 0; ix < 10; ix++) {
        for (it = 12 / 2 - lwt; it < 12; it++) {
          printf("node(%d) array[%2d][%2d][%2d][%2d] = %f\n", 2, iz, iy, ix, it,
                 array_t[iz][iy][ix][it]);
        }
      }
    }
  }
  return 1;
}


x86 assembly (clang, -O0):
<test_dist_t>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x6,-0x34(%rbp)
jge    1211 <test_dist_t+0x101>
movl   $0x0,-0x30(%rbp)
cmpl   $0x8,-0x30(%rbp)
jge    11fe <test_dist_t+0xee>
movl   $0x0,-0x2c(%rbp)
cmpl   $0xa,-0x2c(%rbp)
jge    11eb <test_dist_t+0xdb>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    0x30(%rbp),%ecx
add    $0x6,%ecx
cmp    %ecx,%eax
jge    11d8 <test_dist_t+0xc8>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x1e00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
imul   $0x60,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  0xe3b(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    117d <test_dist_t+0x6d>
jmp    11dd <test_dist_t+0xcd>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    116c <test_dist_t+0x5c>
jmp    11f0 <test_dist_t+0xe0>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    115b <test_dist_t+0x4b>
jmp    1203 <test_dist_t+0xf3>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    114a <test_dist_t+0x3a>
movl   $0x0,-0x34(%rbp)
cmpl   $0x6,-0x34(%rbp)
jge    12dc <test_dist_t+0x1cc>
movl   $0x0,-0x30(%rbp)
cmpl   $0x8,-0x30(%rbp)
jge    12c9 <test_dist_t+0x1b9>
movl   $0x0,-0x2c(%rbp)
cmpl   $0xa,-0x2c(%rbp)
jge    12b6 <test_dist_t+0x1a6>
mov    $0x6,%eax
sub    0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0xc,-0x28(%rbp)
jge    12a3 <test_dist_t+0x193>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x1e00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
imul   $0x60,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  0xd78(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    124f <test_dist_t+0x13f>
jmp    12a8 <test_dist_t+0x198>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    123a <test_dist_t+0x12a>
jmp    12bb <test_dist_t+0x1ab>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1229 <test_dist_t+0x119>
jmp    12ce <test_dist_t+0x1be>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1218 <test_dist_t+0x108>
movl   $0x0,-0x34(%rbp)
cmpl   $0x6,-0x34(%rbp)
jge    1446 <test_dist_t+0x336>
movl   $0x0,-0x30(%rbp)
cmpl   $0x8,-0x30(%rbp)
jge    1433 <test_dist_t+0x323>
movl   $0x0,-0x2c(%rbp)
cmpl   $0xa,-0x2c(%rbp)
jge    1420 <test_dist_t+0x310>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    0x30(%rbp),%ecx
add    $0x6,%ecx
cmp    %ecx,%eax
jge    140d <test_dist_t+0x2fd>
xor    %eax,%eax
cmp    -0x28(%rbp),%eax
jg     139b <test_dist_t+0x28b>
cmpl   $0x6,-0x28(%rbp)
jge    139b <test_dist_t+0x28b>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x1e00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
imul   $0x60,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xc88(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    138d <test_dist_t+0x27d>
jp     138d <test_dist_t+0x27d>
jmp    1396 <test_dist_t+0x286>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13fa <test_dist_t+0x2ea>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x1e00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
imul   $0x60,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xc31(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    13ec <test_dist_t+0x2dc>
jp     13ec <test_dist_t+0x2dc>
jmp    13f5 <test_dist_t+0x2e5>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13fa <test_dist_t+0x2ea>
jmp    13ff <test_dist_t+0x2ef>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1316 <test_dist_t+0x206>
jmp    1412 <test_dist_t+0x302>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1305 <test_dist_t+0x1f5>
jmp    1425 <test_dist_t+0x315>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12f4 <test_dist_t+0x1e4>
jmp    1438 <test_dist_t+0x328>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12e3 <test_dist_t+0x1d3>
movl   $0x0,-0x34(%rbp)
cmpl   $0x6,-0x34(%rbp)
jge    15b0 <test_dist_t+0x4a0>
movl   $0x0,-0x30(%rbp)
cmpl   $0x8,-0x30(%rbp)
jge    159d <test_dist_t+0x48d>
movl   $0x0,-0x2c(%rbp)
cmpl   $0xa,-0x2c(%rbp)
jge    158a <test_dist_t+0x47a>
mov    $0x6,%eax
sub    0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0xc,-0x28(%rbp)
jge    1577 <test_dist_t+0x467>
mov    $0x6,%eax
cmp    -0x28(%rbp),%eax
jg     1505 <test_dist_t+0x3f5>
cmpl   $0xc,-0x28(%rbp)
jge    1505 <test_dist_t+0x3f5>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x1e00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
imul   $0x60,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xb26(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    14f7 <test_dist_t+0x3e7>
jp     14f7 <test_dist_t+0x3e7>
jmp    1500 <test_dist_t+0x3f0>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1564 <test_dist_t+0x454>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x1e00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x3c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
imul   $0x60,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xabf(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1556 <test_dist_t+0x446>
jp     1556 <test_dist_t+0x446>
jmp    155f <test_dist_t+0x44f>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1564 <test_dist_t+0x454>
jmp    1569 <test_dist_t+0x459>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1484 <test_dist_t+0x374>
jmp    157c <test_dist_t+0x46c>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    146f <test_dist_t+0x35f>
jmp    158f <test_dist_t+0x47f>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    145e <test_dist_t+0x34e>
jmp    15a2 <test_dist_t+0x492>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    144d <test_dist_t+0x33d>
cmpl   $0x0,-0x38(%rbp)
jne    15c6 <test_dist_t+0x4b6>
movl   $0x0,-0x4(%rbp)
jmp    1794 <test_dist_t+0x684>
movl   $0x0,-0x34(%rbp)
cmpl   $0x6,-0x34(%rbp)
jge    16ab <test_dist_t+0x59b>
movl   $0x0,-0x30(%rbp)
cmpl   $0x8,-0x30(%rbp)
jge    1698 <test_dist_t+0x588>
movl   $0x0,-0x2c(%rbp)
cmpl   $0xa,-0x2c(%rbp)
jge    1685 <test_dist_t+0x575>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    0x30(%rbp),%ecx
add    $0x6,%ecx
cmp    %ecx,%eax
jge    1672 <test_dist_t+0x562>
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%ecx
mov    -0x2c(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rsi
imul   $0x1e00,%rsi,%rsi
add    %rsi,%rax
movslq -0x30(%rbp),%rsi
imul   $0x3c0,%rsi,%rsi
add    %rsi,%rax
movslq -0x2c(%rbp),%rsi
imul   $0x60,%rsi,%rsi
add    %rsi,%rax
movslq -0x28(%rbp),%rsi
movsd  (%rax,%rsi,8),%xmm0
lea    0x9b6(%rip),%rdi
mov    $0x1,%esi
call   1030 <printf@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1600 <test_dist_t+0x4f0>
jmp    1677 <test_dist_t+0x567>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    15ef <test_dist_t+0x4df>
jmp    168a <test_dist_t+0x57a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15de <test_dist_t+0x4ce>
jmp    169d <test_dist_t+0x58d>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15cd <test_dist_t+0x4bd>
movl   $0x0,-0x34(%rbp)
cmpl   $0x6,-0x34(%rbp)
jge    178d <test_dist_t+0x67d>
movl   $0x0,-0x30(%rbp)
cmpl   $0x8,-0x30(%rbp)
jge    177a <test_dist_t+0x66a>
movl   $0x0,-0x2c(%rbp)
cmpl   $0xa,-0x2c(%rbp)
jge    1767 <test_dist_t+0x657>
mov    $0x6,%eax
sub    0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0xc,-0x28(%rbp)
jge    1754 <test_dist_t+0x644>
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%ecx
mov    -0x2c(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rsi
imul   $0x1e00,%rsi,%rsi
add    %rsi,%rax
movslq -0x30(%rbp),%rsi
imul   $0x3c0,%rsi,%rsi
add    %rsi,%rax
movslq -0x2c(%rbp),%rsi
imul   $0x60,%rsi,%rsi
add    %rsi,%rax
movslq -0x28(%rbp),%rsi
movsd  (%rax,%rsi,8),%xmm0
lea    0x8d4(%rip),%rdi
mov    $0x2,%esi
call   1030 <printf@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    16e9 <test_dist_t+0x5d9>
jmp    1759 <test_dist_t+0x649>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    16d4 <test_dist_t+0x5c4>
jmp    176c <test_dist_t+0x65c>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    16c3 <test_dist_t+0x5b3>
jmp    177f <test_dist_t+0x66f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    16b2 <test_dist_t+0x5a2>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<test_dist_t>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    0x130(%rsp),%eax
add    $0x5,%eax
xor    %r14d,%r14d
test   %eax,%eax
mov    $0x0,%esi
mov    %eax,0x64(%rsp)
cmovg  %eax,%esi
lea    0x1(%rsi),%r13
mov    %r13d,%r9d
and    $0xfffffffc,%r9d
lea    -0x4(%r9),%r12
mov    %r12,%r11
shr    $0x2,%r11
add    $0x1,%r11
mov    %r11d,%r15d
and    $0x3,%r15d
mov    %r11,%r10
and    $0xfffffffffffffffc,%r10
lea    0x70(%rdi),%rax
mov    %r15,%rdx
shl    $0x5,%rdx
movaps 0x1e8a(%rip),%xmm0
movabs $0x3ff0000000000000,%rbx
mov    %rdi,0x50(%rsp)
mov    %rdi,%rbp
mov    %r10,(%rsp)
jmp    11b5 <test_dist_t+0xa5>
xchg   %ax,%ax
add    $0x1,%r14
mov    0x40(%rsp),%rax
add    $0x1e00,%rax
mov    0x70(%rsp),%rbp
add    $0x1e00,%rbp
cmp    $0x6,%r14
je     19e6 <test_dist_t+0x8d6>
mov    %rbp,0x70(%rsp)
mov    %rax,0x40(%rsp)
mov    %rax,%rdi
xor    %r8d,%r8d
jmp    11e8 <test_dist_t+0xd8>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r8
add    $0x3c0,%rdi
add    $0x3c0,%rbp
cmp    $0x8,%r8
je     1190 <test_dist_t+0x80>
mov    0x130(%rsp),%eax
cmp    $0xfffffffb,%eax
jl     11d0 <test_dist_t+0xc0>
cmp    $0x3,%esi
jae    1200 <test_dist_t+0xf0>
xor    %eax,%eax
jmp    1280 <test_dist_t+0x170>
cmp    $0xc,%r12
jae    120a <test_dist_t+0xfa>
xor    %ecx,%ecx
jmp    1241 <test_dist_t+0x131>
mov    %r10,%rax
xor    %ecx,%ecx
nop
movups %xmm0,-0x70(%rdi,%rcx,8)
movups %xmm0,-0x60(%rdi,%rcx,8)
movups %xmm0,-0x50(%rdi,%rcx,8)
movups %xmm0,-0x40(%rdi,%rcx,8)
movups %xmm0,-0x30(%rdi,%rcx,8)
movups %xmm0,-0x20(%rdi,%rcx,8)
movups %xmm0,-0x10(%rdi,%rcx,8)
movups %xmm0,(%rdi,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rax
jne    1210 <test_dist_t+0x100>
test   %r15,%r15
je     1272 <test_dist_t+0x162>
lea    0x0(,%rcx,8),%rax
add    %rbp,%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups %xmm0,(%rax,%rcx,1)
movups %xmm0,0x10(%rax,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rdx
jne    1260 <test_dist_t+0x150>
mov    %r9,%rax
cmp    %r13,%r9
je     128e <test_dist_t+0x17e>
nopw   0x0(%rax,%rax,1)
mov    %rbx,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r13
jne    1280 <test_dist_t+0x170>
mov    0x130(%rsp),%eax
cmp    $0xfffffffb,%eax
jl     11d0 <test_dist_t+0xc0>
cmp    $0x3,%esi
jae    12aa <test_dist_t+0x19a>
xor    %eax,%eax
jmp    133f <test_dist_t+0x22f>
cmp    $0xc,%r12
jae    12b5 <test_dist_t+0x1a5>
xor    %r10d,%r10d
jmp    130c <test_dist_t+0x1fc>
mov    %r10,%rax
xor    %r10d,%r10d
nopl   0x0(%rax,%rax,1)
movups %xmm0,0x60(%rbp,%r10,8)
movups %xmm0,0x70(%rbp,%r10,8)
movups %xmm0,0x80(%rbp,%r10,8)
movups %xmm0,0x90(%rbp,%r10,8)
movups %xmm0,0xa0(%rbp,%r10,8)
movups %xmm0,0xb0(%rbp,%r10,8)
movups %xmm0,0xc0(%rbp,%r10,8)
movups %xmm0,0xd0(%rbp,%r10,8)
add    $0x10,%r10
add    $0xfffffffffffffffc,%rax
jne    12c0 <test_dist_t+0x1b0>
test   $0x3,%r11b
je     1333 <test_dist_t+0x223>
lea    0x0(,%r10,8),%rax
add    %rbp,%rax
xor    %ecx,%ecx
nop
movups %xmm0,0x60(%rax,%rcx,1)
movups %xmm0,0x70(%rax,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rdx
jne    1320 <test_dist_t+0x210>
mov    %r9,%rax
cmp    %r13,%r9
mov    (%rsp),%r10
je     135e <test_dist_t+0x24e>
add    $0xffffffffffffffff,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rbx,0x68(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    1350 <test_dist_t+0x240>
mov    0x130(%rsp),%eax
cmp    $0xfffffffb,%eax
jl     11d0 <test_dist_t+0xc0>
cmp    $0x3,%esi
jae    137a <test_dist_t+0x26a>
xor    %eax,%eax
jmp    1411 <test_dist_t+0x301>
cmp    $0xc,%r12
jae    1384 <test_dist_t+0x274>
xor    %ecx,%ecx
jmp    13da <test_dist_t+0x2ca>
mov    %r10,%rax
xor    %ecx,%ecx
nopl   0x0(%rax)
movups %xmm0,0xc0(%rbp,%rcx,8)
movups %xmm0,0xd0(%rbp,%rcx,8)
movups %xmm0,0xe0(%rbp,%rcx,8)
movups %xmm0,0xf0(%rbp,%rcx,8)
movups %xmm0,0x100(%rbp,%rcx,8)
movups %xmm0,0x110(%rbp,%rcx,8)
movups %xmm0,0x120(%rbp,%rcx,8)
movups %xmm0,0x130(%rbp,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rax
jne    1390 <test_dist_t+0x280>
test   $0x3,%r11b
je     1409 <test_dist_t+0x2f9>
lea    0x0(,%rcx,8),%rax
add    %rbp,%rax
xor    %ecx,%ecx
nopl   (%rax)
movups %xmm0,0xc0(%rax,%rcx,1)
movups %xmm0,0xd0(%rax,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rdx
jne    13f0 <test_dist_t+0x2e0>
mov    %r9,%rax
cmp    %r13,%r9
je     1431 <test_dist_t+0x321>
add    $0xffffffffffffffff,%rax
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbx,0xc8(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    1420 <test_dist_t+0x310>
mov    0x130(%rsp),%eax
cmp    $0xfffffffb,%eax
jl     11d0 <test_dist_t+0xc0>
cmp    $0x3,%esi
jae    144d <test_dist_t+0x33d>
xor    %eax,%eax
jmp    14e1 <test_dist_t+0x3d1>
cmp    $0xc,%r12
jae    1457 <test_dist_t+0x347>
xor    %ecx,%ecx
jmp    14aa <test_dist_t+0x39a>
mov    %r10,%rax
xor    %ecx,%ecx
nopl   0x0(%rax)
movups %xmm0,0x120(%rbp,%rcx,8)
movups %xmm0,0x130(%rbp,%rcx,8)
movups %xmm0,0x140(%rbp,%rcx,8)
movups %xmm0,0x150(%rbp,%rcx,8)
movups %xmm0,0x160(%rbp,%rcx,8)
movups %xmm0,0x170(%rbp,%rcx,8)
movups %xmm0,0x180(%rbp,%rcx,8)
movups %xmm0,0x190(%rbp,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rax
jne    1460 <test_dist_t+0x350>
test   $0x3,%r11b
je     14d9 <test_dist_t+0x3c9>
lea    0x0(,%rcx,8),%rax
add    %rbp,%rax
xor    %ecx,%ecx
nopl   (%rax)
movups %xmm0,0x120(%rax,%rcx,1)
movups %xmm0,0x130(%rax,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rdx
jne    14c0 <test_dist_t+0x3b0>
mov    %r9,%rax
cmp    %r13,%r9
je     1501 <test_dist_t+0x3f1>
add    $0xffffffffffffffff,%rax
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbx,0x128(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    14f0 <test_dist_t+0x3e0>
mov    0x130(%rsp),%eax
cmp    $0xfffffffb,%eax
jl     11d0 <test_dist_t+0xc0>
cmp    $0x3,%esi
jae    151d <test_dist_t+0x40d>
xor    %eax,%eax
jmp    15b1 <test_dist_t+0x4a1>
cmp    $0xc,%r12
jae    1527 <test_dist_t+0x417>
xor    %ecx,%ecx
jmp    157a <test_dist_t+0x46a>
mov    %r10,%rax
xor    %ecx,%ecx
nopl   0x0(%rax)
movups %xmm0,0x180(%rbp,%rcx,8)
movups %xmm0,0x190(%rbp,%rcx,8)
movups %xmm0,0x1a0(%rbp,%rcx,8)
movups %xmm0,0x1b0(%rbp,%rcx,8)
movups %xmm0,0x1c0(%rbp,%rcx,8)
movups %xmm0,0x1d0(%rbp,%rcx,8)
movups %xmm0,0x1e0(%rbp,%rcx,8)
movups %xmm0,0x1f0(%rbp,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rax
jne    1530 <test_dist_t+0x420>
test   $0x3,%r11b
je     15a9 <test_dist_t+0x499>
lea    0x0(,%rcx,8),%rax
add    %rbp,%rax
xor    %ecx,%ecx
nopl   (%rax)
movups %xmm0,0x180(%rax,%rcx,1)
movups %xmm0,0x190(%rax,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rdx
jne    1590 <test_dist_t+0x480>
mov    %r9,%rax
cmp    %r13,%r9
je     15d1 <test_dist_t+0x4c1>
add    $0xffffffffffffffff,%rax
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbx,0x188(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    15c0 <test_dist_t+0x4b0>
mov    0x130(%rsp),%eax
cmp    $0xfffffffb,%eax
jl     11d0 <test_dist_t+0xc0>
cmp    $0x3,%esi
jae    15ed <test_dist_t+0x4dd>
xor    %eax,%eax
jmp    1681 <test_dist_t+0x571>
cmp    $0xc,%r12
jae    15f7 <test_dist_t+0x4e7>
xor    %ecx,%ecx
jmp    164a <test_dist_t+0x53a>
mov    %r10,%rax
xor    %ecx,%ecx
nopl   0x0(%rax)
movups %xmm0,0x1e0(%rbp,%rcx,8)
movups %xmm0,0x1f0(%rbp,%rcx,8)
movups %xmm0,0x200(%rbp,%rcx,8)
movups %xmm0,0x210(%rbp,%rcx,8)
movups %xmm0,0x220(%rbp,%rcx,8)
movups %xmm0,0x230(%rbp,%rcx,8)
movups %xmm0,0x240(%rbp,%rcx,8)
movups %xmm0,0x250(%rbp,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rax
jne    1600 <test_dist_t+0x4f0>
test   $0x3,%r11b
je     1679 <test_dist_t+0x569>
lea    0x0(,%rcx,8),%rax
add    %rbp,%rax
xor    %ecx,%ecx
nopl   (%rax)
movups %xmm0,0x1e0(%rax,%rcx,1)
movups %xmm0,0x1f0(%rax,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rdx
jne    1660 <test_dist_t+0x550>
mov    %r9,%rax
cmp    %r13,%r9
je     16a1 <test_dist_t+0x591>
add    $0xffffffffffffffff,%rax
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbx,0x1e8(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    1690 <test_dist_t+0x580>
mov    0x130(%rsp),%eax
cmp    $0xfffffffb,%eax
jl     11d0 <test_dist_t+0xc0>
cmp    $0x3,%esi
jae    16bd <test_dist_t+0x5ad>
xor    %eax,%eax
jmp    1751 <test_dist_t+0x641>
cmp    $0xc,%r12
jae    16c7 <test_dist_t+0x5b7>
xor    %ecx,%ecx
jmp    171a <test_dist_t+0x60a>
mov    %r10,%rax
xor    %ecx,%ecx
nopl   0x0(%rax)
movups %xmm0,0x240(%rbp,%rcx,8)
movups %xmm0,0x250(%rbp,%rcx,8)
movups %xmm0,0x260(%rbp,%rcx,8)
movups %xmm0,0x270(%rbp,%rcx,8)
movups %xmm0,0x280(%rbp,%rcx,8)
movups %xmm0,0x290(%rbp,%rcx,8)
movups %xmm0,0x2a0(%rbp,%rcx,8)
movups %xmm0,0x2b0(%rbp,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rax
jne    16d0 <test_dist_t+0x5c0>
test   $0x3,%r11b
je     1749 <test_dist_t+0x639>
lea    0x0(,%rcx,8),%rax
add    %rbp,%rax
xor    %ecx,%ecx
nopl   (%rax)
movups %xmm0,0x240(%rax,%rcx,1)
movups %xmm0,0x250(%rax,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rdx
jne    1730 <test_dist_t+0x620>
mov    %r9,%rax
cmp    %r13,%r9
je     1771 <test_dist_t+0x661>
add    $0xffffffffffffffff,%rax
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbx,0x248(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    1760 <test_dist_t+0x650>
mov    0x130(%rsp),%eax
cmp    $0xfffffffb,%eax
jl     11d0 <test_dist_t+0xc0>
cmp    $0x3,%esi
jae    178d <test_dist_t+0x67d>
xor    %eax,%eax
jmp    1821 <test_dist_t+0x711>
cmp    $0xc,%r12
jae    1797 <test_dist_t+0x687>
xor    %ecx,%ecx
jmp    17ea <test_dist_t+0x6da>
mov    %r10,%rax
xor    %ecx,%ecx
nopl   0x0(%rax)
movups %xmm0,0x2a0(%rbp,%rcx,8)
movups %xmm0,0x2b0(%rbp,%rcx,8)
movups %xmm0,0x2c0(%rbp,%rcx,8)
movups %xmm0,0x2d0(%rbp,%rcx,8)
movups %xmm0,0x2e0(%rbp,%rcx,8)
movups %xmm0,0x2f0(%rbp,%rcx,8)
movups %xmm0,0x300(%rbp,%rcx,8)
movups %xmm0,0x310(%rbp,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rax
jne    17a0 <test_dist_t+0x690>
test   $0x3,%r11b
je     1819 <test_dist_t+0x709>
lea    0x0(,%rcx,8),%rax
add    %rbp,%rax
xor    %ecx,%ecx
nopl   (%rax)
movups %xmm0,0x2a0(%rax,%rcx,1)
movups %xmm0,0x2b0(%rax,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rdx
jne    1800 <test_dist_t+0x6f0>
mov    %r9,%rax
cmp    %r13,%r9
je     1841 <test_dist_t+0x731>
add    $0xffffffffffffffff,%rax
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbx,0x2a8(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    1830 <test_dist_t+0x720>
mov    0x130(%rsp),%eax
cmp    $0xfffffffb,%eax
jl     11d0 <test_dist_t+0xc0>
cmp    $0x3,%esi
jae    185d <test_dist_t+0x74d>
xor    %eax,%eax
jmp    18f1 <test_dist_t+0x7e1>
cmp    $0xc,%r12
jae    1867 <test_dist_t+0x757>
xor    %ecx,%ecx
jmp    18ba <test_dist_t+0x7aa>
mov    %r10,%rax
xor    %ecx,%ecx
nopl   0x0(%rax)
movups %xmm0,0x300(%rbp,%rcx,8)
movups %xmm0,0x310(%rbp,%rcx,8)
movups %xmm0,0x320(%rbp,%rcx,8)
movups %xmm0,0x330(%rbp,%rcx,8)
movups %xmm0,0x340(%rbp,%rcx,8)
movups %xmm0,0x350(%rbp,%rcx,8)
movups %xmm0,0x360(%rbp,%rcx,8)
movups %xmm0,0x370(%rbp,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rax
jne    1870 <test_dist_t+0x760>
test   $0x3,%r11b
je     18e9 <test_dist_t+0x7d9>
lea    0x0(,%rcx,8),%rax
add    %rbp,%rax
xor    %ecx,%ecx
nopl   (%rax)
movups %xmm0,0x300(%rax,%rcx,1)
movups %xmm0,0x310(%rax,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rdx
jne    18d0 <test_dist_t+0x7c0>
mov    %r9,%rax
cmp    %r13,%r9
je     1911 <test_dist_t+0x801>
add    $0xffffffffffffffff,%rax
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbx,0x308(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    1900 <test_dist_t+0x7f0>
mov    0x130(%rsp),%eax
cmp    $0xfffffffb,%eax
jl     11d0 <test_dist_t+0xc0>
cmp    $0x3,%esi
jae    192d <test_dist_t+0x81d>
xor    %eax,%eax
jmp    19c5 <test_dist_t+0x8b5>
cmp    $0xc,%r12
jae    1937 <test_dist_t+0x827>
xor    %ecx,%ecx
jmp    198a <test_dist_t+0x87a>
mov    %r10,%rax
xor    %ecx,%ecx
nopl   0x0(%rax)
movups %xmm0,0x360(%rbp,%rcx,8)
movups %xmm0,0x370(%rbp,%rcx,8)
movups %xmm0,0x380(%rbp,%rcx,8)
movups %xmm0,0x390(%rbp,%rcx,8)
movups %xmm0,0x3a0(%rbp,%rcx,8)
movups %xmm0,0x3b0(%rbp,%rcx,8)
movups %xmm0,0x3c0(%rbp,%rcx,8)
movups %xmm0,0x3d0(%rbp,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rax
jne    1940 <test_dist_t+0x830>
test   $0x3,%r11b
je     19b9 <test_dist_t+0x8a9>
lea    0x0(,%rcx,8),%rax
add    %rbp,%rax
xor    %ecx,%ecx
nopl   (%rax)
movups %xmm0,0x360(%rax,%rcx,1)
movups %xmm0,0x370(%rax,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rdx
jne    19a0 <test_dist_t+0x890>
mov    %r9,%rax
cmp    %r13,%r9
je     11d0 <test_dist_t+0xc0>
add    $0xffffffffffffffff,%rax
nopl   0x0(%rax)
mov    %rbx,0x368(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    19d0 <test_dist_t+0x8c0>
jmp    11d0 <test_dist_t+0xc0>
mov    $0x6,%ecx
mov    0x128(%rsp),%eax
sub    %eax,%ecx
mov    %ecx,0x70(%rsp)
movslq %ecx,%rdx
lea    0x5(%rax),%r11d
lea    0x1(%r11),%rax
mov    %rax,0x28(%rsp)
and    $0xfffffffffffffffc,%rax
lea    -0x4(%rax),%rcx
mov    %rcx,0x18(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rax,0x20(%rsp)
add    %rdx,%rax
mov    %rax,0x38(%rsp)
mov    %ecx,%r14d
and    $0x3,%r14d
mov    %rcx,%rax
mov    %rcx,0x48(%rsp)
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
and    %rax,%rcx
mov    %rcx,0x30(%rsp)
mov    0x50(%rsp),%rdi
mov    %rdx,%rax
lea    (%rdi,%rdx,8),%r15
add    $0x70,%r15
mov    %r14,0xd0(%rsp)
shl    $0x5,%r14
lea    (%rdi,%rdx,8),%r8
add    $0xd0,%r8
lea    0x130(%rdi,%rdx,8),%rsi
lea    0x190(%rdi,%rdx,8),%rbx
movapd 0x1585(%rip),%xmm8
lea    0x1f0(%rdi,%rdx,8),%r12
lea    0x250(%rdi,%rdx,8),%r9
lea    0x2b0(%rdi,%rdx,8),%r10
lea    0x310(%rdi,%rdx,8),%rbp
lea    (%rdi,%rdx,8),%rdx
add    $0x370,%rdx
mov    %rax,(%rsp)
lea    (%rdi,%rax,8),%rcx
add    $0x3d0,%rcx
xor    %eax,%eax
mov    %rax,0x78(%rsp)
movabs $0x4000000000000000,%rax
mov    %rdi,0x8(%rsp)
mov    %r11,0x10(%rsp)
jmp    1bad <test_dist_t+0xa9d>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x78(%rsp),%r11
add    $0x1,%r11
mov    0xc8(%rsp),%r15
add    $0x1e00,%r15
add    $0x1e00,%rbp
mov    %rbp,0x8(%rsp)
mov    0xc0(%rsp),%r8
add    $0x1e00,%r8
mov    0xb8(%rsp),%rsi
add    $0x1e00,%rsi
mov    0xb0(%rsp),%rbx
add    $0x1e00,%rbx
mov    0xa8(%rsp),%r12
add    $0x1e00,%r12
mov    0xa0(%rsp),%r9
add    $0x1e00,%r9
mov    0x98(%rsp),%r10
add    $0x1e00,%r10
mov    0x90(%rsp),%rbp
add    $0x1e00,%rbp
mov    0x88(%rsp),%rdx
add    $0x1e00,%rdx
mov    0x80(%rsp),%rcx
add    $0x1e00,%rcx
mov    %r11,%rdi
mov    %r11,0x78(%rsp)
cmp    $0x6,%r11
je     25a6 <test_dist_t+0x1496>
mov    %rcx,0x80(%rsp)
mov    %rdx,0x88(%rsp)
mov    %rdx,0x58(%rsp)
mov    %rbp,0x90(%rsp)
mov    %rbp,%r11
mov    %r10,0x98(%rsp)
mov    %r9,0xa0(%rsp)
mov    %r12,0xa8(%rsp)
mov    %rbx,0xb0(%rsp)
mov    %rsi,0xb8(%rsp)
mov    %rsi,%rdx
mov    %r8,0xc0(%rsp)
mov    %r8,%rdi
mov    0x8(%rsp),%rbp
mov    %rbp,%rsi
mov    %r15,0xc8(%rsp)
xor    %r8d,%r8d
jmp    1c82 <test_dist_t+0xb72>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r8
add    $0x3c0,%r15
add    $0x3c0,%rsi
add    $0x3c0,%rdi
add    $0x3c0,%rdx
add    $0x3c0,%rbx
add    $0x3c0,%r12
add    $0x3c0,%r9
add    $0x3c0,%r10
add    $0x3c0,%r11
addq   $0x3c0,0x58(%rsp)
mov    0x40(%rsp),%rcx
add    $0x3c0,%rcx
cmp    $0x8,%r8
je     1af0 <test_dist_t+0x9e0>
mov    %rcx,0x40(%rsp)
mov    0x128(%rsp),%ecx
cmp    $0xfffffffb,%ecx
jl     1c20 <test_dist_t+0xb10>
mov    (%rsp),%rcx
cmpl   $0x3,0x10(%rsp)
jb     1d50 <test_dist_t+0xc40>
cmpq   $0xc,0x18(%rsp)
jae    1cb1 <test_dist_t+0xba1>
mov    %r11,%rbp
xor    %ecx,%ecx
jmp    1d01 <test_dist_t+0xbf1>
mov    %r11,%rbp
mov    0x30(%rsp),%r11
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movupd %xmm8,-0x70(%r15,%rcx,8)
movupd %xmm8,-0x60(%r15,%rcx,8)
movupd %xmm8,-0x50(%r15,%rcx,8)
movupd %xmm8,-0x40(%r15,%rcx,8)
movupd %xmm8,-0x30(%r15,%rcx,8)
movupd %xmm8,-0x20(%r15,%rcx,8)
movupd %xmm8,-0x10(%r15,%rcx,8)
movupd %xmm8,(%r15,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%r11
jne    1cc0 <test_dist_t+0xbb0>
cmpq   $0x0,0xd0(%rsp)
mov    %rbp,%r11
je     1d36 <test_dist_t+0xc26>
add    (%rsp),%rcx
lea    (%rsi,%rcx,8),%rcx
xor    %ebp,%ebp
nopl   0x0(%rax)
movupd %xmm8,(%rcx,%rbp,1)
movupd %xmm8,0x10(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r14
jne    1d20 <test_dist_t+0xc10>
mov    0x38(%rsp),%rcx
mov    0x20(%rsp),%rbp
cmp    %rbp,0x28(%rsp)
mov    0x8(%rsp),%rbp
je     1d5d <test_dist_t+0xc4d>
nopl   0x0(%rax)
mov    %rax,(%rsi,%rcx,8)
add    $0x1,%rcx
cmp    $0xc,%ecx
jne    1d50 <test_dist_t+0xc40>
mov    0x128(%rsp),%ecx
cmp    $0xfffffffb,%ecx
jl     1c20 <test_dist_t+0xb10>
mov    (%rsp),%rcx
cmpl   $0x3,0x10(%rsp)
jb     1e20 <test_dist_t+0xd10>
cmpq   $0xc,0x18(%rsp)
jae    1d88 <test_dist_t+0xc78>
xor    %ecx,%ecx
jmp    1dd1 <test_dist_t+0xcc1>
mov    0x30(%rsp),%rbp
xor    %ecx,%ecx
nop
movupd %xmm8,-0x70(%rdi,%rcx,8)
movupd %xmm8,-0x60(%rdi,%rcx,8)
movupd %xmm8,-0x50(%rdi,%rcx,8)
movupd %xmm8,-0x40(%rdi,%rcx,8)
movupd %xmm8,-0x30(%rdi,%rcx,8)
movupd %xmm8,-0x20(%rdi,%rcx,8)
movupd %xmm8,-0x10(%rdi,%rcx,8)
movupd %xmm8,(%rdi,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rbp
jne    1d90 <test_dist_t+0xc80>
testb  $0x3,0x48(%rsp)
je     1e07 <test_dist_t+0xcf7>
add    (%rsp),%rcx
lea    (%rsi,%rcx,8),%rcx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd %xmm8,0x60(%rcx,%rbp,1)
movupd %xmm8,0x70(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r14
jne    1df0 <test_dist_t+0xce0>
mov    0x38(%rsp),%rcx
mov    0x20(%rsp),%rbp
cmp    %rbp,0x28(%rsp)
mov    0x8(%rsp),%rbp
je     1e2e <test_dist_t+0xd1e>
nopl   (%rax)
mov    %rax,0x60(%rsi,%rcx,8)
add    $0x1,%rcx
cmp    $0xc,%ecx
jne    1e20 <test_dist_t+0xd10>
mov    0x128(%rsp),%ecx
cmp    $0xfffffffb,%ecx
jl     1c20 <test_dist_t+0xb10>
mov    (%rsp),%rcx
cmpl   $0x3,0x10(%rsp)
jb     1f00 <test_dist_t+0xdf0>
cmpq   $0xc,0x18(%rsp)
jae    1e59 <test_dist_t+0xd49>
xor    %ecx,%ecx
jmp    1ea1 <test_dist_t+0xd91>
mov    0x30(%rsp),%rbp
xor    %ecx,%ecx
movupd %xmm8,-0x70(%rdx,%rcx,8)
movupd %xmm8,-0x60(%rdx,%rcx,8)
movupd %xmm8,-0x50(%rdx,%rcx,8)
movupd %xmm8,-0x40(%rdx,%rcx,8)
movupd %xmm8,-0x30(%rdx,%rcx,8)
movupd %xmm8,-0x20(%rdx,%rcx,8)
movupd %xmm8,-0x10(%rdx,%rcx,8)
movupd %xmm8,(%rdx,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rbp
jne    1e60 <test_dist_t+0xd50>
testb  $0x3,0x48(%rsp)
je     1edd <test_dist_t+0xdcd>
add    (%rsp),%rcx
lea    (%rsi,%rcx,8),%rcx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd %xmm8,0xc0(%rcx,%rbp,1)
movupd %xmm8,0xd0(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r14
jne    1ec0 <test_dist_t+0xdb0>
mov    0x38(%rsp),%rcx
mov    0x20(%rsp),%rbp
cmp    %rbp,0x28(%rsp)
mov    0x8(%rsp),%rbp
je     1f11 <test_dist_t+0xe01>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rax,0xc0(%rsi,%rcx,8)
add    $0x1,%rcx
cmp    $0xc,%ecx
jne    1f00 <test_dist_t+0xdf0>
mov    0x128(%rsp),%ecx
cmp    $0xfffffffb,%ecx
jl     1c20 <test_dist_t+0xb10>
mov    (%rsp),%rcx
cmpl   $0x3,0x10(%rsp)
jb     1ff0 <test_dist_t+0xee0>
cmpq   $0xc,0x18(%rsp)
jae    1f3c <test_dist_t+0xe2c>
xor    %ecx,%ecx
jmp    1f91 <test_dist_t+0xe81>
mov    0x30(%rsp),%rbp
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd %xmm8,-0x70(%rbx,%rcx,8)
movupd %xmm8,-0x60(%rbx,%rcx,8)
movupd %xmm8,-0x50(%rbx,%rcx,8)
movupd %xmm8,-0x40(%rbx,%rcx,8)
movupd %xmm8,-0x30(%rbx,%rcx,8)
movupd %xmm8,-0x20(%rbx,%rcx,8)
movupd %xmm8,-0x10(%rbx,%rcx,8)
movupd %xmm8,(%rbx,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rbp
jne    1f50 <test_dist_t+0xe40>
testb  $0x3,0x48(%rsp)
je     1fcd <test_dist_t+0xebd>
add    (%rsp),%rcx
lea    (%rsi,%rcx,8),%rcx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd %xmm8,0x120(%rcx,%rbp,1)
movupd %xmm8,0x130(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r14
jne    1fb0 <test_dist_t+0xea0>
mov    0x38(%rsp),%rcx
mov    0x20(%rsp),%rbp
cmp    %rbp,0x28(%rsp)
mov    0x8(%rsp),%rbp
je     2001 <test_dist_t+0xef1>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rax,0x120(%rsi,%rcx,8)
add    $0x1,%rcx
cmp    $0xc,%ecx
jne    1ff0 <test_dist_t+0xee0>
mov    0x128(%rsp),%ecx
cmp    $0xfffffffb,%ecx
jl     1c20 <test_dist_t+0xb10>
mov    (%rsp),%rcx
cmpl   $0x3,0x10(%rsp)
jb     20e0 <test_dist_t+0xfd0>
cmpq   $0xc,0x18(%rsp)
jae    202c <test_dist_t+0xf1c>
xor    %ecx,%ecx
jmp    2081 <test_dist_t+0xf71>
mov    0x30(%rsp),%rbp
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd %xmm8,-0x70(%r12,%rcx,8)
movupd %xmm8,-0x60(%r12,%rcx,8)
movupd %xmm8,-0x50(%r12,%rcx,8)
movupd %xmm8,-0x40(%r12,%rcx,8)
movupd %xmm8,-0x30(%r12,%rcx,8)
movupd %xmm8,-0x20(%r12,%rcx,8)
movupd %xmm8,-0x10(%r12,%rcx,8)
movupd %xmm8,(%r12,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rbp
jne    2040 <test_dist_t+0xf30>
testb  $0x3,0x48(%rsp)
je     20bd <test_dist_t+0xfad>
add    (%rsp),%rcx
lea    (%rsi,%rcx,8),%rcx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd %xmm8,0x180(%rcx,%rbp,1)
movupd %xmm8,0x190(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r14
jne    20a0 <test_dist_t+0xf90>
mov    0x38(%rsp),%rcx
mov    0x20(%rsp),%rbp
cmp    %rbp,0x28(%rsp)
mov    0x8(%rsp),%rbp
je     20f1 <test_dist_t+0xfe1>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rax,0x180(%rsi,%rcx,8)
add    $0x1,%rcx
cmp    $0xc,%ecx
jne    20e0 <test_dist_t+0xfd0>
mov    0x128(%rsp),%ecx
cmp    $0xfffffffb,%ecx
jl     1c20 <test_dist_t+0xb10>
mov    (%rsp),%rcx
cmpl   $0x3,0x10(%rsp)
jb     21d0 <test_dist_t+0x10c0>
cmpq   $0xc,0x18(%rsp)
jae    211c <test_dist_t+0x100c>
xor    %ecx,%ecx
jmp    2171 <test_dist_t+0x1061>
mov    0x30(%rsp),%rbp
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd %xmm8,-0x70(%r9,%rcx,8)
movupd %xmm8,-0x60(%r9,%rcx,8)
movupd %xmm8,-0x50(%r9,%rcx,8)
movupd %xmm8,-0x40(%r9,%rcx,8)
movupd %xmm8,-0x30(%r9,%rcx,8)
movupd %xmm8,-0x20(%r9,%rcx,8)
movupd %xmm8,-0x10(%r9,%rcx,8)
movupd %xmm8,(%r9,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rbp
jne    2130 <test_dist_t+0x1020>
testb  $0x3,0x48(%rsp)
je     21ad <test_dist_t+0x109d>
add    (%rsp),%rcx
lea    (%rsi,%rcx,8),%rcx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd %xmm8,0x1e0(%rcx,%rbp,1)
movupd %xmm8,0x1f0(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r14
jne    2190 <test_dist_t+0x1080>
mov    0x38(%rsp),%rcx
mov    0x20(%rsp),%rbp
cmp    %rbp,0x28(%rsp)
mov    0x8(%rsp),%rbp
je     21e1 <test_dist_t+0x10d1>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rax,0x1e0(%rsi,%rcx,8)
add    $0x1,%rcx
cmp    $0xc,%ecx
jne    21d0 <test_dist_t+0x10c0>
mov    0x128(%rsp),%ecx
cmp    $0xfffffffb,%ecx
jl     1c20 <test_dist_t+0xb10>
mov    (%rsp),%rcx
cmpl   $0x3,0x10(%rsp)
jb     22c0 <test_dist_t+0x11b0>
cmpq   $0xc,0x18(%rsp)
jae    220c <test_dist_t+0x10fc>
xor    %ecx,%ecx
jmp    2261 <test_dist_t+0x1151>
mov    0x30(%rsp),%rbp
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd %xmm8,-0x70(%r10,%rcx,8)
movupd %xmm8,-0x60(%r10,%rcx,8)
movupd %xmm8,-0x50(%r10,%rcx,8)
movupd %xmm8,-0x40(%r10,%rcx,8)
movupd %xmm8,-0x30(%r10,%rcx,8)
movupd %xmm8,-0x20(%r10,%rcx,8)
movupd %xmm8,-0x10(%r10,%rcx,8)
movupd %xmm8,(%r10,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rbp
jne    2220 <test_dist_t+0x1110>
testb  $0x3,0x48(%rsp)
je     229d <test_dist_t+0x118d>
add    (%rsp),%rcx
lea    (%rsi,%rcx,8),%rcx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd %xmm8,0x240(%rcx,%rbp,1)
movupd %xmm8,0x250(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r14
jne    2280 <test_dist_t+0x1170>
mov    0x38(%rsp),%rcx
mov    0x20(%rsp),%rbp
cmp    %rbp,0x28(%rsp)
mov    0x8(%rsp),%rbp
je     22d1 <test_dist_t+0x11c1>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rax,0x240(%rsi,%rcx,8)
add    $0x1,%rcx
cmp    $0xc,%ecx
jne    22c0 <test_dist_t+0x11b0>
mov    0x128(%rsp),%ecx
cmp    $0xfffffffb,%ecx
jl     1c20 <test_dist_t+0xb10>
mov    (%rsp),%rcx
cmpl   $0x3,0x10(%rsp)
jb     23b0 <test_dist_t+0x12a0>
cmpq   $0xc,0x18(%rsp)
jae    22fc <test_dist_t+0x11ec>
xor    %ecx,%ecx
jmp    2351 <test_dist_t+0x1241>
mov    0x30(%rsp),%rbp
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd %xmm8,-0x70(%r11,%rcx,8)
movupd %xmm8,-0x60(%r11,%rcx,8)
movupd %xmm8,-0x50(%r11,%rcx,8)
movupd %xmm8,-0x40(%r11,%rcx,8)
movupd %xmm8,-0x30(%r11,%rcx,8)
movupd %xmm8,-0x20(%r11,%rcx,8)
movupd %xmm8,-0x10(%r11,%rcx,8)
movupd %xmm8,(%r11,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rbp
jne    2310 <test_dist_t+0x1200>
testb  $0x3,0x48(%rsp)
je     238d <test_dist_t+0x127d>
add    (%rsp),%rcx
lea    (%rsi,%rcx,8),%rcx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd %xmm8,0x2a0(%rcx,%rbp,1)
movupd %xmm8,0x2b0(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r14
jne    2370 <test_dist_t+0x1260>
mov    0x38(%rsp),%rcx
mov    0x20(%rsp),%rbp
cmp    %rbp,0x28(%rsp)
mov    0x8(%rsp),%rbp
je     23c1 <test_dist_t+0x12b1>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rax,0x2a0(%rsi,%rcx,8)
add    $0x1,%rcx
cmp    $0xc,%ecx
jne    23b0 <test_dist_t+0x12a0>
mov    0x128(%rsp),%ecx
cmp    $0xfffffffb,%ecx
jl     1c20 <test_dist_t+0xb10>
mov    (%rsp),%rcx
cmpl   $0x3,0x10(%rsp)
jb     24a0 <test_dist_t+0x1390>
mov    %r11,0x68(%rsp)
cmpq   $0xc,0x18(%rsp)
jae    23f1 <test_dist_t+0x12e1>
xor    %ecx,%ecx
jmp    2441 <test_dist_t+0x1331>
mov    0x30(%rsp),%rbp
xor    %ecx,%ecx
mov    0x58(%rsp),%r11
nopl   (%rax)
movupd %xmm8,-0x70(%r11,%rcx,8)
movupd %xmm8,-0x60(%r11,%rcx,8)
movupd %xmm8,-0x50(%r11,%rcx,8)
movupd %xmm8,-0x40(%r11,%rcx,8)
movupd %xmm8,-0x30(%r11,%rcx,8)
movupd %xmm8,-0x20(%r11,%rcx,8)
movupd %xmm8,-0x10(%r11,%rcx,8)
movupd %xmm8,(%r11,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rbp
jne    2400 <test_dist_t+0x12f0>
testb  $0x3,0x48(%rsp)
mov    0x68(%rsp),%r11
je     247d <test_dist_t+0x136d>
add    (%rsp),%rcx
lea    (%rsi,%rcx,8),%rcx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movupd %xmm8,0x300(%rcx,%rbp,1)
movupd %xmm8,0x310(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r14
jne    2460 <test_dist_t+0x1350>
mov    0x38(%rsp),%rcx
mov    0x20(%rsp),%rbp
cmp    %rbp,0x28(%rsp)
mov    0x8(%rsp),%rbp
je     24b1 <test_dist_t+0x13a1>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rax,0x300(%rsi,%rcx,8)
add    $0x1,%rcx
cmp    $0xc,%ecx
jne    24a0 <test_dist_t+0x1390>
mov    0x128(%rsp),%ecx
cmp    $0xfffffffb,%ecx
jl     1c20 <test_dist_t+0xb10>
mov    (%rsp),%rcx
cmpl   $0x3,0x10(%rsp)
jb     2590 <test_dist_t+0x1480>
cmpq   $0xc,0x18(%rsp)
jae    24dc <test_dist_t+0x13cc>
xor    %ecx,%ecx
jmp    2534 <test_dist_t+0x1424>
mov    0x30(%rsp),%rcx
mov    %rcx,0x68(%rsp)
xor    %ecx,%ecx
mov    0x40(%rsp),%rbp
nopl   (%rax)
movupd %xmm8,-0x70(%rbp,%rcx,8)
movupd %xmm8,-0x60(%rbp,%rcx,8)
movupd %xmm8,-0x50(%rbp,%rcx,8)
movupd %xmm8,-0x40(%rbp,%rcx,8)
movupd %xmm8,-0x30(%rbp,%rcx,8)
movupd %xmm8,-0x20(%rbp,%rcx,8)
movupd %xmm8,-0x10(%rbp,%rcx,8)
movupd %xmm8,0x0(%rbp,%rcx,8)
add    $0x10,%rcx
addq   $0xfffffffffffffffc,0x68(%rsp)
jne    24f0 <test_dist_t+0x13e0>
testb  $0x3,0x48(%rsp)
je     256d <test_dist_t+0x145d>
add    (%rsp),%rcx
lea    (%rsi,%rcx,8),%rcx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movupd %xmm8,0x360(%rcx,%rbp,1)
movupd %xmm8,0x370(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r14
jne    2550 <test_dist_t+0x1440>
mov    0x38(%rsp),%rcx
mov    0x20(%rsp),%rbp
cmp    %rbp,0x28(%rsp)
mov    0x8(%rsp),%rbp
je     1c20 <test_dist_t+0xb10>
nopw   0x0(%rax,%rax,1)
mov    %rax,0x360(%rsi,%rcx,8)
add    $0x1,%rcx
cmp    $0xc,%ecx
jne    2590 <test_dist_t+0x1480>
jmp    1c20 <test_dist_t+0xb10>
lea    -0x6(%r13),%r8
lea    -0xa(%r13),%rax
mov    %rax,0x40(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %r8,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x10(%rsp)
add    $0x6,%rax
mov    %rax,0x8(%rsp)
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
add    $0x2,%rax
mov    %rcx,%rdx
mov    %rcx,0x58(%rsp)
and    %rcx,%rax
mov    %rax,0x28(%rsp)
mov    0x50(%rsp),%r12
lea    0x60(%r12),%r15
xor    %ebx,%ebx
movsd  0xa1b(%rip),%xmm1
movsd  0xa1b(%rip),%xmm2
xor    %r14d,%r14d
mov    0x64(%rsp),%edx
jmp    2646 <test_dist_t+0x1536>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbx
mov    0x20(%rsp),%r15
add    $0x1e00,%r15
mov    0x18(%rsp),%r12
add    $0x1e00,%r12
cmp    $0x6,%rbx
je     2890 <test_dist_t+0x1780>
mov    %r12,0x18(%rsp)
mov    %r15,0x20(%rsp)
xor    %esi,%esi
jmp    2678 <test_dist_t+0x1568>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rsi
add    $0x3c0,%r15
add    $0x3c0,%r12
cmp    $0x8,%rsi
je     2620 <test_dist_t+0x1510>
mov    %r12,%rdi
mov    %r15,%rbp
xor    %r10d,%r10d
jmp    26a2 <test_dist_t+0x1592>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r10
add    $0x60,%rbp
add    $0x60,%rdi
cmp    $0xa,%r10
je     2660 <test_dist_t+0x1550>
mov    0x130(%rsp),%eax
cmp    $0xfffffffb,%eax
jl     2690 <test_dist_t+0x1580>
imul   $0x1e00,%rbx,%rax
add    0x50(%rsp),%rax
imul   $0x3c0,%rsi,%r11
add    %rax,%r11
lea    (%r10,%r10,2),%r9
shl    $0x5,%r9
movsd  (%r9,%r11,1),%xmm3
cmpneqsd %xmm1,%xmm3
movq   %xmm3,%rax
sub    %eax,%r14d
test   %edx,%edx
jle    2690 <test_dist_t+0x1580>
movsd  0x8(%r9,%r11,1),%xmm3
cmpneqsd %xmm1,%xmm3
movq   %xmm3,%rax
sub    %eax,%r14d
cmp    $0x2,%r13d
je     2690 <test_dist_t+0x1580>
movsd  0x10(%r9,%r11,1),%xmm3
cmpneqsd %xmm1,%xmm3
movq   %xmm3,%rax
sub    %eax,%r14d
cmp    $0x3,%r13d
je     2690 <test_dist_t+0x1580>
movsd  0x18(%r9,%r11,1),%xmm3
cmpneqsd %xmm1,%xmm3
movq   %xmm3,%rax
sub    %eax,%r14d
cmp    $0x4,%r13d
je     2690 <test_dist_t+0x1580>
movsd  0x20(%r9,%r11,1),%xmm3
cmpneqsd %xmm1,%xmm3
movq   %xmm3,%rax
sub    %eax,%r14d
cmp    $0x5,%r13d
je     2690 <test_dist_t+0x1580>
movsd  0x28(%r9,%r11,1),%xmm3
cmpneqsd %xmm1,%xmm3
movq   %xmm3,%rax
sub    %eax,%r14d
cmp    $0x6,%r13d
je     2690 <test_dist_t+0x1580>
mov    $0x6,%eax
cmp    $0x4,%r8
jb     2870 <test_dist_t+0x1760>
movd   %r14d,%xmm3
cmpq   $0x4,0x40(%rsp)
jae    2799 <test_dist_t+0x1689>
pxor   %xmm4,%xmm4
xor    %edx,%edx
jmp    280a <test_dist_t+0x16fa>
pxor   %xmm4,%xmm4
mov    0x28(%rsp),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd -0x30(%rbp,%rdx,8),%xmm5
movupd -0x20(%rbp,%rdx,8),%xmm6
movupd -0x10(%rbp,%rdx,8),%xmm7
movupd 0x0(%rbp,%rdx,8),%xmm0
cmpneqpd %xmm8,%xmm5
shufps $0xe8,%xmm5,%xmm5
psubd  %xmm5,%xmm3
cmpneqpd %xmm8,%xmm6
shufps $0xe8,%xmm6,%xmm6
psubd  %xmm6,%xmm4
cmpneqpd %xmm8,%xmm7
shufps $0xe8,%xmm7,%xmm7
psubd  %xmm7,%xmm3
cmpneqpd %xmm8,%xmm0
shufps $0xe8,%xmm0,%xmm0
psubd  %xmm0,%xmm4
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rax
jne    27b0 <test_dist_t+0x16a0>
testb  $0x1,0x58(%rsp)
je     283e <test_dist_t+0x172e>
add    %r9,%r11
movupd 0x30(%r11,%rdx,8),%xmm0
movupd 0x40(%r11,%rdx,8),%xmm5
cmpneqpd %xmm8,%xmm0
shufps $0xe8,%xmm0,%xmm0
psubd  %xmm0,%xmm3
cmpneqpd %xmm8,%xmm5
shufps $0xe8,%xmm5,%xmm5
psubd  %xmm5,%xmm4
paddd  %xmm4,%xmm3
pshufd $0x55,%xmm3,%xmm0
paddd  %xmm3,%xmm0
movd   %xmm0,%r14d
mov    0x8(%rsp),%rax
cmp    0x10(%rsp),%r8
mov    0x64(%rsp),%edx
je     2690 <test_dist_t+0x1580>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdi,%rax,8),%xmm0
cmpneqsd %xmm2,%xmm0
movq   %xmm0,%rcx
sub    %ecx,%r14d
add    $0x1,%rax
cmp    %rax,%r13
jne    2870 <test_dist_t+0x1760>
jmp    2690 <test_dist_t+0x1580>
mov    0x50(%rsp),%r12
mov    (%rsp),%rax
lea    (%r12,%rax,8),%r8
mov    0x128(%rsp),%r15d
lea    0x6(%r15),%esi
xor    %r10d,%r10d
jmp    28c5 <test_dist_t+0x17b5>
xchg   %ax,%ax
add    $0x1,%r10
add    $0x1e00,%r8
cmp    $0x6,%r10
je     2973 <test_dist_t+0x1863>
mov    %r8,%r9
xor    %r11d,%r11d
jmp    28e1 <test_dist_t+0x17d1>
nopl   (%rax)
add    $0x1,%r11
add    $0x3c0,%r9
cmp    $0x8,%r11
je     28b0 <test_dist_t+0x17a0>
mov    %r9,%rcx
xor    %eax,%eax
jmp    28fe <test_dist_t+0x17ee>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
add    $0x60,%rcx
cmp    $0xa,%rax
je     28d0 <test_dist_t+0x17c0>
cmp    $0xfffffffb,%r15d
jl     28f0 <test_dist_t+0x17e0>
xor    %ebp,%ebp
jmp    2918 <test_dist_t+0x1808>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    %ebp,%esi
je     28f0 <test_dist_t+0x17e0>
mov    (%rsp),%rdx
lea    (%rdx,%rbp,1),%rdi
cmp    $0x6,%rdi
jl     2960 <test_dist_t+0x1850>
mov    %edi,%edi
imul   $0x1e00,%r10,%rbx
add    %r12,%rbx
imul   $0x3c0,%r11,%rdx
add    %rbx,%rdx
lea    (%rax,%rax,2),%rbx
shl    $0x5,%rbx
add    %rdx,%rbx
movsd  (%rbx,%rdi,8),%xmm0
ucomisd %xmm2,%xmm0
jne    296d <test_dist_t+0x185d>
jp     296d <test_dist_t+0x185d>
jmp    2910 <test_dist_t+0x1800>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx,%rbp,8),%xmm0
ucomisd %xmm1,%xmm0
jne    296d <test_dist_t+0x185d>
jnp    2910 <test_dist_t+0x1800>
add    $0x1,%r14d
jmp    2910 <test_dist_t+0x1800>
test   %r14d,%r14d
je     2b34 <test_dist_t+0x1a24>
mov    %r13d,%ebx
mov    %r12,%rax
xor    %r13d,%r13d
lea    0x6a4(%rip),%r14
jmp    29a9 <test_dist_t+0x1899>
xchg   %ax,%ax
add    $0x1,%r13
mov    0x10(%rsp),%rax
add    $0x1e00,%rax
cmp    $0x6,%r13
je     2a57 <test_dist_t+0x1947>
mov    %rax,0x10(%rsp)
mov    %rax,%r15
xor    %ecx,%ecx
jmp    29d6 <test_dist_t+0x18c6>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rcx
mov    0x58(%rsp),%r15
add    $0x3c0,%r15
cmp    $0x8,%rcx
je     2990 <test_dist_t+0x1880>
mov    %r15,0x58(%rsp)
mov    %r15,%rdx
xor    %r15d,%r15d
jmp    29fe <test_dist_t+0x18ee>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r15
add    $0x60,%rdx
cmp    $0xa,%r15
je     29c0 <test_dist_t+0x18b0>
mov    0x130(%rsp),%eax
cmp    $0xfffffffb,%eax
jl     29f0 <test_dist_t+0x18e0>
xor    %ebp,%ebp
mov    %rdx,0x40(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rbp,8),%xmm0
mov    %r14,%rdi
mov    $0x1,%esi
mov    %r13d,%edx
mov    %rbx,%r12
mov    %rcx,%rbx
mov    %r15d,%r8d
mov    %ebp,%r9d
call   1030 <printf@plt>
mov    0x40(%rsp),%rdx
mov    %rbx,%rcx
mov    %r12,%rbx
add    $0x1,%rbp
cmp    %rbp,%r12
jne    2a20 <test_dist_t+0x1910>
jmp    29f0 <test_dist_t+0x18e0>
mov    0x50(%rsp),%rax
mov    (%rsp),%rcx
lea    (%rax,%rcx,8),%rax
xor    %r15d,%r15d
lea    0x5c2(%rip),%r14
jmp    2a89 <test_dist_t+0x1979>
add    $0x1,%r15
mov    0x50(%rsp),%rax
add    $0x1e00,%rax
cmp    $0x6,%r15
je     2b2d <test_dist_t+0x1a1d>
mov    %rax,0x50(%rsp)
xor    %r12d,%r12d
jmp    2ab5 <test_dist_t+0x19a5>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r12
mov    0x40(%rsp),%rax
add    $0x3c0,%rax
cmp    $0x8,%r12
je     2a70 <test_dist_t+0x1960>
mov    %rax,0x40(%rsp)
mov    %rax,(%rsp)
xor    %ebx,%ebx
jmp    2adf <test_dist_t+0x19cf>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rbx
addq   $0x60,(%rsp)
cmp    $0xa,%rbx
je     2aa0 <test_dist_t+0x1990>
mov    0x128(%rsp),%eax
cmp    $0xfffffffb,%eax
jl     2ad0 <test_dist_t+0x19c0>
mov    (%rsp),%r13
mov    0x70(%rsp),%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x0(%r13),%xmm0
mov    %r14,%rdi
mov    $0x2,%esi
mov    %r15d,%edx
mov    %r12d,%ecx
mov    %ebx,%r8d
mov    %ebp,%r9d
call   1030 <printf@plt>
add    $0x1,%ebp
add    $0x8,%r13
cmp    $0xc,%ebp
jne    2b00 <test_dist_t+0x19f0>
jmp    2ad0 <test_dist_t+0x19c0>
mov    $0x1,%eax
jmp    2b36 <test_dist_t+0x1a26>
xor    %eax,%eax
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [41 x i8] c"node(%d) array[%2d][%2d][%2d][%2d] = %f\0A\00"
define i32 @test_dist_t([8 x [10 x [12 x double]]]* nocapture %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6, i32 %7, i32 %8, i32 %9, i32 %10) {
%12 = icmp sgt i32 %10, -6
%13 = add i32 %10, 5
%14 = call i32 @llvm.smax.i32(i32 %13, i32 0)
%15 = add nuw i32 %14, 1
%16 = zext i32 %15 to i64
%17 = zext i32 %15 to i64
%18 = zext i32 %15 to i64
%19 = zext i32 %15 to i64
%20 = zext i32 %15 to i64
%21 = zext i32 %15 to i64
%22 = zext i32 %15 to i64
%23 = zext i32 %15 to i64
%24 = zext i32 %15 to i64
%25 = zext i32 %15 to i64
%26 = and i64 %16, 4294967292
%27 = add nsw i64 %26, -4
%28 = lshr exact i64 %27, 2
%29 = add nuw nsw i64 %28, 1
%30 = icmp ult i32 %14, 3
%31 = and i64 %16, 4294967292
%32 = and i64 %29, 3
%33 = icmp ult i64 %27, 12
%34 = and i64 %29, 9223372036854775804
%35 = icmp eq i64 %32, 0
%36 = icmp eq i64 %31, %16
%37 = icmp ult i32 %14, 3
%38 = and i64 %16, 4294967292
%39 = and i64 %29, 3
%40 = icmp ult i64 %27, 12
%41 = and i64 %29, 9223372036854775804
%42 = icmp eq i64 %39, 0
%43 = icmp eq i64 %38, %16
%44 = icmp ult i32 %14, 3
%45 = and i64 %16, 4294967292
%46 = and i64 %29, 3
%47 = icmp ult i64 %27, 12
%48 = and i64 %29, 9223372036854775804
%49 = icmp eq i64 %46, 0
%50 = icmp eq i64 %45, %16
%51 = icmp ult i32 %14, 3
%52 = and i64 %16, 4294967292
%53 = and i64 %29, 3
%54 = icmp ult i64 %27, 12
%55 = and i64 %29, 9223372036854775804
%56 = icmp eq i64 %53, 0
%57 = icmp eq i64 %52, %16
%58 = icmp ult i32 %14, 3
%59 = and i64 %16, 4294967292
%60 = and i64 %29, 3
%61 = icmp ult i64 %27, 12
%62 = and i64 %29, 9223372036854775804
%63 = icmp eq i64 %60, 0
%64 = icmp eq i64 %59, %16
%65 = icmp ult i32 %14, 3
%66 = and i64 %16, 4294967292
%67 = and i64 %29, 3
%68 = icmp ult i64 %27, 12
%69 = and i64 %29, 9223372036854775804
%70 = icmp eq i64 %67, 0
%71 = icmp eq i64 %66, %16
%72 = icmp ult i32 %14, 3
%73 = and i64 %16, 4294967292
%74 = and i64 %29, 3
%75 = icmp ult i64 %27, 12
%76 = and i64 %29, 9223372036854775804
%77 = icmp eq i64 %74, 0
%78 = icmp eq i64 %73, %16
%79 = icmp ult i32 %14, 3
%80 = and i64 %16, 4294967292
%81 = and i64 %29, 3
%82 = icmp ult i64 %27, 12
%83 = and i64 %29, 9223372036854775804
%84 = icmp eq i64 %81, 0
%85 = icmp eq i64 %80, %16
%86 = icmp ult i32 %14, 3
%87 = and i64 %16, 4294967292
%88 = and i64 %29, 3
%89 = icmp ult i64 %27, 12
%90 = and i64 %29, 9223372036854775804
%91 = icmp eq i64 %88, 0
%92 = icmp eq i64 %87, %16
%93 = icmp ult i32 %14, 3
%94 = and i64 %16, 4294967292
%95 = and i64 %29, 3
%96 = icmp ult i64 %27, 12
%97 = and i64 %29, 9223372036854775804
%98 = icmp eq i64 %95, 0
%99 = icmp eq i64 %94, %16
br label %100
100: ; preds = %11, %698
%101 = phi i64 [ 0, %11 ], [ %699, %698 ]
br label %214
102: ; preds = %698
%103 = sub i32 6, %9
%104 = icmp sgt i32 %9, -6
%105 = sext i32 %103 to i64
%106 = add i32 %9, 5
%107 = zext i32 %106 to i64
%108 = add nuw nsw i64 %107, 1
%109 = zext i32 %106 to i64
%110 = add nuw nsw i64 %109, 1
%111 = zext i32 %106 to i64
%112 = add nuw nsw i64 %111, 1
%113 = add i32 %9, 5
%114 = zext i32 %113 to i64
%115 = add nuw nsw i64 %114, 1
%116 = zext i32 %113 to i64
%117 = add nuw nsw i64 %116, 1
%118 = zext i32 %113 to i64
%119 = add nuw nsw i64 %118, 1
%120 = add i32 %9, 5
%121 = zext i32 %120 to i64
%122 = add nuw nsw i64 %121, 1
%123 = zext i32 %120 to i64
%124 = add nuw nsw i64 %123, 1
%125 = zext i32 %120 to i64
%126 = add nuw nsw i64 %125, 1
%127 = add i32 %9, 5
%128 = zext i32 %127 to i64
%129 = add nuw nsw i64 %128, 1
%130 = and i64 %129, 8589934588
%131 = add nsw i64 %130, -4
%132 = lshr exact i64 %131, 2
%133 = add nuw nsw i64 %132, 1
%134 = icmp ult i32 %127, 3
%135 = and i64 %129, 8589934588
%136 = add nsw i64 %135, %105
%137 = and i64 %133, 3
%138 = icmp ult i64 %131, 12
%139 = and i64 %133, 9223372036854775804
%140 = icmp eq i64 %137, 0
%141 = icmp eq i64 %129, %135
%142 = icmp ult i32 %120, 3
%143 = and i64 %126, 8589934588
%144 = add nsw i64 %143, %105
%145 = and i64 %133, 3
%146 = icmp ult i64 %131, 12
%147 = and i64 %133, 9223372036854775804
%148 = icmp eq i64 %145, 0
%149 = icmp eq i64 %126, %143
%150 = icmp ult i32 %120, 3
%151 = and i64 %124, 8589934588
%152 = add nsw i64 %151, %105
%153 = and i64 %133, 3
%154 = icmp ult i64 %131, 12
%155 = and i64 %133, 9223372036854775804
%156 = icmp eq i64 %153, 0
%157 = icmp eq i64 %124, %151
%158 = icmp ult i32 %120, 3
%159 = and i64 %122, 8589934588
%160 = add nsw i64 %159, %105
%161 = and i64 %133, 3
%162 = icmp ult i64 %131, 12
%163 = and i64 %133, 9223372036854775804
%164 = icmp eq i64 %161, 0
%165 = icmp eq i64 %122, %159
%166 = icmp ult i32 %113, 3
%167 = and i64 %119, 8589934588
%168 = add nsw i64 %167, %105
%169 = and i64 %133, 3
%170 = icmp ult i64 %131, 12
%171 = and i64 %133, 9223372036854775804
%172 = icmp eq i64 %169, 0
%173 = icmp eq i64 %119, %167
%174 = icmp ult i32 %113, 3
%175 = and i64 %117, 8589934588
%176 = add nsw i64 %175, %105
%177 = and i64 %133, 3
%178 = icmp ult i64 %131, 12
%179 = and i64 %133, 9223372036854775804
%180 = icmp eq i64 %177, 0
%181 = icmp eq i64 %117, %175
%182 = icmp ult i32 %113, 3
%183 = and i64 %115, 8589934588
%184 = add nsw i64 %183, %105
%185 = and i64 %133, 3
%186 = icmp ult i64 %131, 12
%187 = and i64 %133, 9223372036854775804
%188 = icmp eq i64 %185, 0
%189 = icmp eq i64 %115, %183
%190 = icmp ult i32 %106, 3
%191 = and i64 %112, 8589934588
%192 = add nsw i64 %191, %105
%193 = and i64 %133, 3
%194 = icmp ult i64 %131, 12
%195 = and i64 %133, 9223372036854775804
%196 = icmp eq i64 %193, 0
%197 = icmp eq i64 %112, %191
%198 = icmp ult i32 %106, 3
%199 = and i64 %110, 8589934588
%200 = add nsw i64 %199, %105
%201 = and i64 %133, 3
%202 = icmp ult i64 %131, 12
%203 = and i64 %133, 9223372036854775804
%204 = icmp eq i64 %201, 0
%205 = icmp eq i64 %110, %199
%206 = icmp ult i32 %106, 3
%207 = and i64 %108, 8589934588
%208 = add nsw i64 %207, %105
%209 = and i64 %133, 3
%210 = icmp ult i64 %131, 12
%211 = and i64 %133, 9223372036854775804
%212 = icmp eq i64 %209, 0
%213 = icmp eq i64 %108, %207
br label %701
214: ; preds = %100, %695
%215 = phi i64 [ 0, %100 ], [ %696, %695 ]
br i1 %12, label %216, label %695
216: ; preds = %214
br i1 %30, label %256, label %217
217: ; preds = %216
br i1 %33, label %243, label %218
218: ; preds = %217, %218
%219 = phi i64 [ %240, %218 ], [ 0, %217 ]
%220 = phi i64 [ %241, %218 ], [ 0, %217 ]
%221 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 0, i64 %219
%222 = bitcast double* %221 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %222
%223 = getelementptr inbounds double, double* %221, i64 2
%224 = bitcast double* %223 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %224
%225 = or i64 %219, 4
%226 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 0, i64 %225
%227 = bitcast double* %226 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %227
%228 = getelementptr inbounds double, double* %226, i64 2
%229 = bitcast double* %228 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %229
%230 = or i64 %219, 8
%231 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 0, i64 %230
%232 = bitcast double* %231 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %232
%233 = getelementptr inbounds double, double* %231, i64 2
%234 = bitcast double* %233 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %234
%235 = or i64 %219, 12
%236 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 0, i64 %235
%237 = bitcast double* %236 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %237
%238 = getelementptr inbounds double, double* %236, i64 2
%239 = bitcast double* %238 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %239
%240 = add nuw i64 %219, 16
%241 = add nuw i64 %220, 4
%242 = icmp eq i64 %241, %34
br i1 %242, label %243, label %218
243: ; preds = %218, %217
%244 = phi i64 [ 0, %217 ], [ %240, %218 ]
br i1 %35, label %255, label %245
245: ; preds = %243, %245
%246 = phi i64 [ %252, %245 ], [ %244, %243 ]
%247 = phi i64 [ %253, %245 ], [ 0, %243 ]
%248 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 0, i64 %246
%249 = bitcast double* %248 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %249
%250 = getelementptr inbounds double, double* %248, i64 2
%251 = bitcast double* %250 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %251
%252 = add nuw i64 %246, 4
%253 = add i64 %247, 1
%254 = icmp eq i64 %253, %32
br i1 %254, label %255, label %245
255: ; preds = %245, %243
br i1 %36, label %263, label %256
256: ; preds = %216, %255
%257 = phi i64 [ 0, %216 ], [ %31, %255 ]
br label %258
258: ; preds = %256, %258
%259 = phi i64 [ %261, %258 ], [ %257, %256 ]
%260 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 0, i64 %259
store double 1.000000e+00, double* %260
%261 = add nuw nsw i64 %259, 1
%262 = icmp eq i64 %261, %16
br i1 %262, label %263, label %258
263: ; preds = %258, %255
br i1 %12, label %264, label %695
264: ; preds = %263
br i1 %37, label %304, label %265
265: ; preds = %264
br i1 %40, label %291, label %266
266: ; preds = %265, %266
%267 = phi i64 [ %288, %266 ], [ 0, %265 ]
%268 = phi i64 [ %289, %266 ], [ 0, %265 ]
%269 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 1, i64 %267
%270 = bitcast double* %269 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %270
%271 = getelementptr inbounds double, double* %269, i64 2
%272 = bitcast double* %271 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %272
%273 = or i64 %267, 4
%274 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 1, i64 %273
%275 = bitcast double* %274 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %275
%276 = getelementptr inbounds double, double* %274, i64 2
%277 = bitcast double* %276 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %277
%278 = or i64 %267, 8
%279 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 1, i64 %278
%280 = bitcast double* %279 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %280
%281 = getelementptr inbounds double, double* %279, i64 2
%282 = bitcast double* %281 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %282
%283 = or i64 %267, 12
%284 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 1, i64 %283
%285 = bitcast double* %284 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %285
%286 = getelementptr inbounds double, double* %284, i64 2
%287 = bitcast double* %286 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %287
%288 = add nuw i64 %267, 16
%289 = add nuw i64 %268, 4
%290 = icmp eq i64 %289, %41
br i1 %290, label %291, label %266
291: ; preds = %266, %265
%292 = phi i64 [ 0, %265 ], [ %288, %266 ]
br i1 %42, label %303, label %293
293: ; preds = %291, %293
%294 = phi i64 [ %300, %293 ], [ %292, %291 ]
%295 = phi i64 [ %301, %293 ], [ 0, %291 ]
%296 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 1, i64 %294
%297 = bitcast double* %296 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %297
%298 = getelementptr inbounds double, double* %296, i64 2
%299 = bitcast double* %298 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %299
%300 = add nuw i64 %294, 4
%301 = add i64 %295, 1
%302 = icmp eq i64 %301, %39
br i1 %302, label %303, label %293
303: ; preds = %293, %291
br i1 %43, label %311, label %304
304: ; preds = %264, %303
%305 = phi i64 [ 0, %264 ], [ %38, %303 ]
br label %306
306: ; preds = %304, %306
%307 = phi i64 [ %309, %306 ], [ %305, %304 ]
%308 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 1, i64 %307
store double 1.000000e+00, double* %308
%309 = add nuw nsw i64 %307, 1
%310 = icmp eq i64 %309, %17
br i1 %310, label %311, label %306
311: ; preds = %306, %303
br i1 %12, label %312, label %695
312: ; preds = %311
br i1 %44, label %352, label %313
313: ; preds = %312
br i1 %47, label %339, label %314
314: ; preds = %313, %314
%315 = phi i64 [ %336, %314 ], [ 0, %313 ]
%316 = phi i64 [ %337, %314 ], [ 0, %313 ]
%317 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 2, i64 %315
%318 = bitcast double* %317 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %318
%319 = getelementptr inbounds double, double* %317, i64 2
%320 = bitcast double* %319 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %320
%321 = or i64 %315, 4
%322 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 2, i64 %321
%323 = bitcast double* %322 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %323
%324 = getelementptr inbounds double, double* %322, i64 2
%325 = bitcast double* %324 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %325
%326 = or i64 %315, 8
%327 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 2, i64 %326
%328 = bitcast double* %327 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %328
%329 = getelementptr inbounds double, double* %327, i64 2
%330 = bitcast double* %329 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %330
%331 = or i64 %315, 12
%332 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 2, i64 %331
%333 = bitcast double* %332 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %333
%334 = getelementptr inbounds double, double* %332, i64 2
%335 = bitcast double* %334 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %335
%336 = add nuw i64 %315, 16
%337 = add nuw i64 %316, 4
%338 = icmp eq i64 %337, %48
br i1 %338, label %339, label %314
339: ; preds = %314, %313
%340 = phi i64 [ 0, %313 ], [ %336, %314 ]
br i1 %49, label %351, label %341
341: ; preds = %339, %341
%342 = phi i64 [ %348, %341 ], [ %340, %339 ]
%343 = phi i64 [ %349, %341 ], [ 0, %339 ]
%344 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 2, i64 %342
%345 = bitcast double* %344 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %345
%346 = getelementptr inbounds double, double* %344, i64 2
%347 = bitcast double* %346 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %347
%348 = add nuw i64 %342, 4
%349 = add i64 %343, 1
%350 = icmp eq i64 %349, %46
br i1 %350, label %351, label %341
351: ; preds = %341, %339
br i1 %50, label %359, label %352
352: ; preds = %312, %351
%353 = phi i64 [ 0, %312 ], [ %45, %351 ]
br label %354
354: ; preds = %352, %354
%355 = phi i64 [ %357, %354 ], [ %353, %352 ]
%356 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 2, i64 %355
store double 1.000000e+00, double* %356
%357 = add nuw nsw i64 %355, 1
%358 = icmp eq i64 %357, %18
br i1 %358, label %359, label %354
359: ; preds = %354, %351
br i1 %12, label %360, label %695
360: ; preds = %359
br i1 %51, label %400, label %361
361: ; preds = %360
br i1 %54, label %387, label %362
362: ; preds = %361, %362
%363 = phi i64 [ %384, %362 ], [ 0, %361 ]
%364 = phi i64 [ %385, %362 ], [ 0, %361 ]
%365 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 3, i64 %363
%366 = bitcast double* %365 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %366
%367 = getelementptr inbounds double, double* %365, i64 2
%368 = bitcast double* %367 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %368
%369 = or i64 %363, 4
%370 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 3, i64 %369
%371 = bitcast double* %370 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %371
%372 = getelementptr inbounds double, double* %370, i64 2
%373 = bitcast double* %372 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %373
%374 = or i64 %363, 8
%375 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 3, i64 %374
%376 = bitcast double* %375 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %376
%377 = getelementptr inbounds double, double* %375, i64 2
%378 = bitcast double* %377 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %378
%379 = or i64 %363, 12
%380 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 3, i64 %379
%381 = bitcast double* %380 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %381
%382 = getelementptr inbounds double, double* %380, i64 2
%383 = bitcast double* %382 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %383
%384 = add nuw i64 %363, 16
%385 = add nuw i64 %364, 4
%386 = icmp eq i64 %385, %55
br i1 %386, label %387, label %362
387: ; preds = %362, %361
%388 = phi i64 [ 0, %361 ], [ %384, %362 ]
br i1 %56, label %399, label %389
389: ; preds = %387, %389
%390 = phi i64 [ %396, %389 ], [ %388, %387 ]
%391 = phi i64 [ %397, %389 ], [ 0, %387 ]
%392 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 3, i64 %390
%393 = bitcast double* %392 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %393
%394 = getelementptr inbounds double, double* %392, i64 2
%395 = bitcast double* %394 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %395
%396 = add nuw i64 %390, 4
%397 = add i64 %391, 1
%398 = icmp eq i64 %397, %53
br i1 %398, label %399, label %389
399: ; preds = %389, %387
br i1 %57, label %407, label %400
400: ; preds = %360, %399
%401 = phi i64 [ 0, %360 ], [ %52, %399 ]
br label %402
402: ; preds = %400, %402
%403 = phi i64 [ %405, %402 ], [ %401, %400 ]
%404 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 3, i64 %403
store double 1.000000e+00, double* %404
%405 = add nuw nsw i64 %403, 1
%406 = icmp eq i64 %405, %19
br i1 %406, label %407, label %402
407: ; preds = %402, %399
br i1 %12, label %408, label %695
408: ; preds = %407
br i1 %58, label %448, label %409
409: ; preds = %408
br i1 %61, label %435, label %410
410: ; preds = %409, %410
%411 = phi i64 [ %432, %410 ], [ 0, %409 ]
%412 = phi i64 [ %433, %410 ], [ 0, %409 ]
%413 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 4, i64 %411
%414 = bitcast double* %413 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %414
%415 = getelementptr inbounds double, double* %413, i64 2
%416 = bitcast double* %415 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %416
%417 = or i64 %411, 4
%418 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 4, i64 %417
%419 = bitcast double* %418 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %419
%420 = getelementptr inbounds double, double* %418, i64 2
%421 = bitcast double* %420 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %421
%422 = or i64 %411, 8
%423 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 4, i64 %422
%424 = bitcast double* %423 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %424
%425 = getelementptr inbounds double, double* %423, i64 2
%426 = bitcast double* %425 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %426
%427 = or i64 %411, 12
%428 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 4, i64 %427
%429 = bitcast double* %428 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %429
%430 = getelementptr inbounds double, double* %428, i64 2
%431 = bitcast double* %430 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %431
%432 = add nuw i64 %411, 16
%433 = add nuw i64 %412, 4
%434 = icmp eq i64 %433, %62
br i1 %434, label %435, label %410
435: ; preds = %410, %409
%436 = phi i64 [ 0, %409 ], [ %432, %410 ]
br i1 %63, label %447, label %437
437: ; preds = %435, %437
%438 = phi i64 [ %444, %437 ], [ %436, %435 ]
%439 = phi i64 [ %445, %437 ], [ 0, %435 ]
%440 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 4, i64 %438
%441 = bitcast double* %440 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %441
%442 = getelementptr inbounds double, double* %440, i64 2
%443 = bitcast double* %442 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %443
%444 = add nuw i64 %438, 4
%445 = add i64 %439, 1
%446 = icmp eq i64 %445, %60
br i1 %446, label %447, label %437
447: ; preds = %437, %435
br i1 %64, label %455, label %448
448: ; preds = %408, %447
%449 = phi i64 [ 0, %408 ], [ %59, %447 ]
br label %450
450: ; preds = %448, %450
%451 = phi i64 [ %453, %450 ], [ %449, %448 ]
%452 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 4, i64 %451
store double 1.000000e+00, double* %452
%453 = add nuw nsw i64 %451, 1
%454 = icmp eq i64 %453, %20
br i1 %454, label %455, label %450
455: ; preds = %450, %447
br i1 %12, label %456, label %695
456: ; preds = %455
br i1 %65, label %496, label %457
457: ; preds = %456
br i1 %68, label %483, label %458
458: ; preds = %457, %458
%459 = phi i64 [ %480, %458 ], [ 0, %457 ]
%460 = phi i64 [ %481, %458 ], [ 0, %457 ]
%461 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 5, i64 %459
%462 = bitcast double* %461 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %462
%463 = getelementptr inbounds double, double* %461, i64 2
%464 = bitcast double* %463 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %464
%465 = or i64 %459, 4
%466 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 5, i64 %465
%467 = bitcast double* %466 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %467
%468 = getelementptr inbounds double, double* %466, i64 2
%469 = bitcast double* %468 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %469
%470 = or i64 %459, 8
%471 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 5, i64 %470
%472 = bitcast double* %471 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %472
%473 = getelementptr inbounds double, double* %471, i64 2
%474 = bitcast double* %473 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %474
%475 = or i64 %459, 12
%476 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 5, i64 %475
%477 = bitcast double* %476 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %477
%478 = getelementptr inbounds double, double* %476, i64 2
%479 = bitcast double* %478 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %479
%480 = add nuw i64 %459, 16
%481 = add nuw i64 %460, 4
%482 = icmp eq i64 %481, %69
br i1 %482, label %483, label %458
483: ; preds = %458, %457
%484 = phi i64 [ 0, %457 ], [ %480, %458 ]
br i1 %70, label %495, label %485
485: ; preds = %483, %485
%486 = phi i64 [ %492, %485 ], [ %484, %483 ]
%487 = phi i64 [ %493, %485 ], [ 0, %483 ]
%488 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 5, i64 %486
%489 = bitcast double* %488 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %489
%490 = getelementptr inbounds double, double* %488, i64 2
%491 = bitcast double* %490 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %491
%492 = add nuw i64 %486, 4
%493 = add i64 %487, 1
%494 = icmp eq i64 %493, %67
br i1 %494, label %495, label %485
495: ; preds = %485, %483
br i1 %71, label %503, label %496
496: ; preds = %456, %495
%497 = phi i64 [ 0, %456 ], [ %66, %495 ]
br label %498
498: ; preds = %496, %498
%499 = phi i64 [ %501, %498 ], [ %497, %496 ]
%500 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 5, i64 %499
store double 1.000000e+00, double* %500
%501 = add nuw nsw i64 %499, 1
%502 = icmp eq i64 %501, %21
br i1 %502, label %503, label %498
503: ; preds = %498, %495
br i1 %12, label %504, label %695
504: ; preds = %503
br i1 %72, label %544, label %505
505: ; preds = %504
br i1 %75, label %531, label %506
506: ; preds = %505, %506
%507 = phi i64 [ %528, %506 ], [ 0, %505 ]
%508 = phi i64 [ %529, %506 ], [ 0, %505 ]
%509 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 6, i64 %507
%510 = bitcast double* %509 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %510
%511 = getelementptr inbounds double, double* %509, i64 2
%512 = bitcast double* %511 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %512
%513 = or i64 %507, 4
%514 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 6, i64 %513
%515 = bitcast double* %514 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %515
%516 = getelementptr inbounds double, double* %514, i64 2
%517 = bitcast double* %516 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %517
%518 = or i64 %507, 8
%519 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 6, i64 %518
%520 = bitcast double* %519 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %520
%521 = getelementptr inbounds double, double* %519, i64 2
%522 = bitcast double* %521 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %522
%523 = or i64 %507, 12
%524 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 6, i64 %523
%525 = bitcast double* %524 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %525
%526 = getelementptr inbounds double, double* %524, i64 2
%527 = bitcast double* %526 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %527
%528 = add nuw i64 %507, 16
%529 = add nuw i64 %508, 4
%530 = icmp eq i64 %529, %76
br i1 %530, label %531, label %506
531: ; preds = %506, %505
%532 = phi i64 [ 0, %505 ], [ %528, %506 ]
br i1 %77, label %543, label %533
533: ; preds = %531, %533
%534 = phi i64 [ %540, %533 ], [ %532, %531 ]
%535 = phi i64 [ %541, %533 ], [ 0, %531 ]
%536 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 6, i64 %534
%537 = bitcast double* %536 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %537
%538 = getelementptr inbounds double, double* %536, i64 2
%539 = bitcast double* %538 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %539
%540 = add nuw i64 %534, 4
%541 = add i64 %535, 1
%542 = icmp eq i64 %541, %74
br i1 %542, label %543, label %533
543: ; preds = %533, %531
br i1 %78, label %551, label %544
544: ; preds = %504, %543
%545 = phi i64 [ 0, %504 ], [ %73, %543 ]
br label %546
546: ; preds = %544, %546
%547 = phi i64 [ %549, %546 ], [ %545, %544 ]
%548 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 6, i64 %547
store double 1.000000e+00, double* %548
%549 = add nuw nsw i64 %547, 1
%550 = icmp eq i64 %549, %22
br i1 %550, label %551, label %546
551: ; preds = %546, %543
br i1 %12, label %552, label %695
552: ; preds = %551
br i1 %79, label %592, label %553
553: ; preds = %552
br i1 %82, label %579, label %554
554: ; preds = %553, %554
%555 = phi i64 [ %576, %554 ], [ 0, %553 ]
%556 = phi i64 [ %577, %554 ], [ 0, %553 ]
%557 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 7, i64 %555
%558 = bitcast double* %557 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %558
%559 = getelementptr inbounds double, double* %557, i64 2
%560 = bitcast double* %559 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %560
%561 = or i64 %555, 4
%562 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 7, i64 %561
%563 = bitcast double* %562 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %563
%564 = getelementptr inbounds double, double* %562, i64 2
%565 = bitcast double* %564 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %565
%566 = or i64 %555, 8
%567 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 7, i64 %566
%568 = bitcast double* %567 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %568
%569 = getelementptr inbounds double, double* %567, i64 2
%570 = bitcast double* %569 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %570
%571 = or i64 %555, 12
%572 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 7, i64 %571
%573 = bitcast double* %572 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %573
%574 = getelementptr inbounds double, double* %572, i64 2
%575 = bitcast double* %574 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %575
%576 = add nuw i64 %555, 16
%577 = add nuw i64 %556, 4
%578 = icmp eq i64 %577, %83
br i1 %578, label %579, label %554
579: ; preds = %554, %553
%580 = phi i64 [ 0, %553 ], [ %576, %554 ]
br i1 %84, label %591, label %581
581: ; preds = %579, %581
%582 = phi i64 [ %588, %581 ], [ %580, %579 ]
%583 = phi i64 [ %589, %581 ], [ 0, %579 ]
%584 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 7, i64 %582
%585 = bitcast double* %584 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %585
%586 = getelementptr inbounds double, double* %584, i64 2
%587 = bitcast double* %586 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %587
%588 = add nuw i64 %582, 4
%589 = add i64 %583, 1
%590 = icmp eq i64 %589, %81
br i1 %590, label %591, label %581
591: ; preds = %581, %579
br i1 %85, label %599, label %592
592: ; preds = %552, %591
%593 = phi i64 [ 0, %552 ], [ %80, %591 ]
br label %594
594: ; preds = %592, %594
%595 = phi i64 [ %597, %594 ], [ %593, %592 ]
%596 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 7, i64 %595
store double 1.000000e+00, double* %596
%597 = add nuw nsw i64 %595, 1
%598 = icmp eq i64 %597, %23
br i1 %598, label %599, label %594
599: ; preds = %594, %591
br i1 %12, label %600, label %695
600: ; preds = %599
br i1 %86, label %640, label %601
601: ; preds = %600
br i1 %89, label %627, label %602
602: ; preds = %601, %602
%603 = phi i64 [ %624, %602 ], [ 0, %601 ]
%604 = phi i64 [ %625, %602 ], [ 0, %601 ]
%605 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 8, i64 %603
%606 = bitcast double* %605 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %606
%607 = getelementptr inbounds double, double* %605, i64 2
%608 = bitcast double* %607 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %608
%609 = or i64 %603, 4
%610 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 8, i64 %609
%611 = bitcast double* %610 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %611
%612 = getelementptr inbounds double, double* %610, i64 2
%613 = bitcast double* %612 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %613
%614 = or i64 %603, 8
%615 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 8, i64 %614
%616 = bitcast double* %615 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %616
%617 = getelementptr inbounds double, double* %615, i64 2
%618 = bitcast double* %617 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %618
%619 = or i64 %603, 12
%620 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 8, i64 %619
%621 = bitcast double* %620 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %621
%622 = getelementptr inbounds double, double* %620, i64 2
%623 = bitcast double* %622 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %623
%624 = add nuw i64 %603, 16
%625 = add nuw i64 %604, 4
%626 = icmp eq i64 %625, %90
br i1 %626, label %627, label %602
627: ; preds = %602, %601
%628 = phi i64 [ 0, %601 ], [ %624, %602 ]
br i1 %91, label %639, label %629
629: ; preds = %627, %629
%630 = phi i64 [ %636, %629 ], [ %628, %627 ]
%631 = phi i64 [ %637, %629 ], [ 0, %627 ]
%632 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 8, i64 %630
%633 = bitcast double* %632 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %633
%634 = getelementptr inbounds double, double* %632, i64 2
%635 = bitcast double* %634 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %635
%636 = add nuw i64 %630, 4
%637 = add i64 %631, 1
%638 = icmp eq i64 %637, %88
br i1 %638, label %639, label %629
639: ; preds = %629, %627
br i1 %92, label %647, label %640
640: ; preds = %600, %639
%641 = phi i64 [ 0, %600 ], [ %87, %639 ]
br label %642
642: ; preds = %640, %642
%643 = phi i64 [ %645, %642 ], [ %641, %640 ]
%644 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 8, i64 %643
store double 1.000000e+00, double* %644
%645 = add nuw nsw i64 %643, 1
%646 = icmp eq i64 %645, %24
br i1 %646, label %647, label %642
647: ; preds = %642, %639
br i1 %12, label %648, label %695
648: ; preds = %647
br i1 %93, label %688, label %649
649: ; preds = %648
br i1 %96, label %675, label %650
650: ; preds = %649, %650
%651 = phi i64 [ %672, %650 ], [ 0, %649 ]
%652 = phi i64 [ %673, %650 ], [ 0, %649 ]
%653 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 9, i64 %651
%654 = bitcast double* %653 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %654
%655 = getelementptr inbounds double, double* %653, i64 2
%656 = bitcast double* %655 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %656
%657 = or i64 %651, 4
%658 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 9, i64 %657
%659 = bitcast double* %658 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %659
%660 = getelementptr inbounds double, double* %658, i64 2
%661 = bitcast double* %660 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %661
%662 = or i64 %651, 8
%663 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 9, i64 %662
%664 = bitcast double* %663 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %664
%665 = getelementptr inbounds double, double* %663, i64 2
%666 = bitcast double* %665 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %666
%667 = or i64 %651, 12
%668 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 9, i64 %667
%669 = bitcast double* %668 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %669
%670 = getelementptr inbounds double, double* %668, i64 2
%671 = bitcast double* %670 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %671
%672 = add nuw i64 %651, 16
%673 = add nuw i64 %652, 4
%674 = icmp eq i64 %673, %97
br i1 %674, label %675, label %650
675: ; preds = %650, %649
%676 = phi i64 [ 0, %649 ], [ %672, %650 ]
br i1 %98, label %687, label %677
677: ; preds = %675, %677
%678 = phi i64 [ %684, %677 ], [ %676, %675 ]
%679 = phi i64 [ %685, %677 ], [ 0, %675 ]
%680 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 9, i64 %678
%681 = bitcast double* %680 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %681
%682 = getelementptr inbounds double, double* %680, i64 2
%683 = bitcast double* %682 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %683
%684 = add nuw i64 %678, 4
%685 = add i64 %679, 1
%686 = icmp eq i64 %685, %95
br i1 %686, label %687, label %677
687: ; preds = %677, %675
br i1 %99, label %695, label %688
688: ; preds = %648, %687
%689 = phi i64 [ 0, %648 ], [ %94, %687 ]
br label %690
690: ; preds = %688, %690
%691 = phi i64 [ %693, %690 ], [ %689, %688 ]
%692 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %101, i64 %215, i64 9, i64 %691
store double 1.000000e+00, double* %692
%693 = add nuw nsw i64 %691, 1
%694 = icmp eq i64 %693, %25
br i1 %694, label %695, label %690
695: ; preds = %690, %687, %214, %263, %311, %359, %407, %455, %503, %551, %599, %647
%696 = add nuw nsw i64 %215, 1
%697 = icmp eq i64 %696, 8
br i1 %697, label %698, label %214
698: ; preds = %695
%699 = add nuw nsw i64 %101, 1
%700 = icmp eq i64 %699, 6
br i1 %700, label %102, label %100
701: ; preds = %102, %1267
%702 = phi i64 [ 0, %102 ], [ %1268, %1267 ]
br label %723
703: ; preds = %1267
%704 = zext i32 %15 to i64
%705 = icmp slt i32 %13, 1
%706 = icmp eq i32 %15, 2
%707 = icmp eq i32 %15, 3
%708 = icmp eq i32 %15, 4
%709 = icmp eq i32 %15, 5
%710 = icmp eq i32 %15, 6
%711 = add nsw i64 %16, -6
%712 = add nsw i64 %16, -10
%713 = lshr i64 %712, 2
%714 = add nuw nsw i64 %713, 1
%715 = icmp ult i64 %711, 4
%716 = and i64 %711, -4
%717 = add nsw i64 %716, 6
%718 = and i64 %714, 1
%719 = icmp ult i64 %712, 4
%720 = and i64 %714, 9223372036854775806
%721 = icmp eq i64 %718, 0
%722 = icmp eq i64 %711, %716
br label %1270
723: ; preds = %701, %1264
%724 = phi i64 [ 0, %701 ], [ %1265, %1264 ]
br i1 %104, label %725, label %1264
725: ; preds = %723
br i1 %134, label %770, label %726
726: ; preds = %725
br i1 %138, label %756, label %727
727: ; preds = %726, %727
%728 = phi i64 [ %753, %727 ], [ 0, %726 ]
%729 = phi i64 [ %754, %727 ], [ 0, %726 ]
%730 = add i64 %728, %105
%731 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 0, i64 %730
%732 = bitcast double* %731 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %732
%733 = getelementptr inbounds double, double* %731, i64 2
%734 = bitcast double* %733 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %734
%735 = or i64 %728, 4
%736 = add i64 %735, %105
%737 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 0, i64 %736
%738 = bitcast double* %737 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %738
%739 = getelementptr inbounds double, double* %737, i64 2
%740 = bitcast double* %739 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %740
%741 = or i64 %728, 8
%742 = add i64 %741, %105
%743 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 0, i64 %742
%744 = bitcast double* %743 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %744
%745 = getelementptr inbounds double, double* %743, i64 2
%746 = bitcast double* %745 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %746
%747 = or i64 %728, 12
%748 = add i64 %747, %105
%749 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 0, i64 %748
%750 = bitcast double* %749 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %750
%751 = getelementptr inbounds double, double* %749, i64 2
%752 = bitcast double* %751 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %752
%753 = add nuw i64 %728, 16
%754 = add nuw i64 %729, 4
%755 = icmp eq i64 %754, %139
br i1 %755, label %756, label %727
756: ; preds = %727, %726
%757 = phi i64 [ 0, %726 ], [ %753, %727 ]
br i1 %140, label %769, label %758
758: ; preds = %756, %758
%759 = phi i64 [ %766, %758 ], [ %757, %756 ]
%760 = phi i64 [ %767, %758 ], [ 0, %756 ]
%761 = add i64 %759, %105
%762 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 0, i64 %761
%763 = bitcast double* %762 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %763
%764 = getelementptr inbounds double, double* %762, i64 2
%765 = bitcast double* %764 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %765
%766 = add nuw i64 %759, 4
%767 = add i64 %760, 1
%768 = icmp eq i64 %767, %137
br i1 %768, label %769, label %758
769: ; preds = %758, %756
br i1 %141, label %778, label %770
770: ; preds = %725, %769
%771 = phi i64 [ %105, %725 ], [ %136, %769 ]
br label %772
772: ; preds = %770, %772
%773 = phi i64 [ %775, %772 ], [ %771, %770 ]
%774 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 0, i64 %773
store double 2.000000e+00, double* %774
%775 = add nsw i64 %773, 1
%776 = trunc i64 %775 to i32
%777 = icmp eq i32 %776, 12
br i1 %777, label %778, label %772
778: ; preds = %772, %769
br i1 %104, label %779, label %1264
779: ; preds = %778
br i1 %142, label %824, label %780
780: ; preds = %779
br i1 %146, label %810, label %781
781: ; preds = %780, %781
%782 = phi i64 [ %807, %781 ], [ 0, %780 ]
%783 = phi i64 [ %808, %781 ], [ 0, %780 ]
%784 = add i64 %782, %105
%785 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 1, i64 %784
%786 = bitcast double* %785 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %786
%787 = getelementptr inbounds double, double* %785, i64 2
%788 = bitcast double* %787 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %788
%789 = or i64 %782, 4
%790 = add i64 %789, %105
%791 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 1, i64 %790
%792 = bitcast double* %791 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %792
%793 = getelementptr inbounds double, double* %791, i64 2
%794 = bitcast double* %793 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %794
%795 = or i64 %782, 8
%796 = add i64 %795, %105
%797 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 1, i64 %796
%798 = bitcast double* %797 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %798
%799 = getelementptr inbounds double, double* %797, i64 2
%800 = bitcast double* %799 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %800
%801 = or i64 %782, 12
%802 = add i64 %801, %105
%803 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 1, i64 %802
%804 = bitcast double* %803 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %804
%805 = getelementptr inbounds double, double* %803, i64 2
%806 = bitcast double* %805 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %806
%807 = add nuw i64 %782, 16
%808 = add nuw i64 %783, 4
%809 = icmp eq i64 %808, %147
br i1 %809, label %810, label %781
810: ; preds = %781, %780
%811 = phi i64 [ 0, %780 ], [ %807, %781 ]
br i1 %148, label %823, label %812
812: ; preds = %810, %812
%813 = phi i64 [ %820, %812 ], [ %811, %810 ]
%814 = phi i64 [ %821, %812 ], [ 0, %810 ]
%815 = add i64 %813, %105
%816 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 1, i64 %815
%817 = bitcast double* %816 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %817
%818 = getelementptr inbounds double, double* %816, i64 2
%819 = bitcast double* %818 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %819
%820 = add nuw i64 %813, 4
%821 = add i64 %814, 1
%822 = icmp eq i64 %821, %145
br i1 %822, label %823, label %812
823: ; preds = %812, %810
br i1 %149, label %832, label %824
824: ; preds = %779, %823
%825 = phi i64 [ %105, %779 ], [ %144, %823 ]
br label %826
826: ; preds = %824, %826
%827 = phi i64 [ %829, %826 ], [ %825, %824 ]
%828 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 1, i64 %827
store double 2.000000e+00, double* %828
%829 = add nsw i64 %827, 1
%830 = trunc i64 %829 to i32
%831 = icmp eq i32 %830, 12
br i1 %831, label %832, label %826
832: ; preds = %826, %823
br i1 %104, label %833, label %1264
833: ; preds = %832
br i1 %150, label %878, label %834
834: ; preds = %833
br i1 %154, label %864, label %835
835: ; preds = %834, %835
%836 = phi i64 [ %861, %835 ], [ 0, %834 ]
%837 = phi i64 [ %862, %835 ], [ 0, %834 ]
%838 = add i64 %836, %105
%839 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 2, i64 %838
%840 = bitcast double* %839 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %840
%841 = getelementptr inbounds double, double* %839, i64 2
%842 = bitcast double* %841 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %842
%843 = or i64 %836, 4
%844 = add i64 %843, %105
%845 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 2, i64 %844
%846 = bitcast double* %845 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %846
%847 = getelementptr inbounds double, double* %845, i64 2
%848 = bitcast double* %847 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %848
%849 = or i64 %836, 8
%850 = add i64 %849, %105
%851 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 2, i64 %850
%852 = bitcast double* %851 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %852
%853 = getelementptr inbounds double, double* %851, i64 2
%854 = bitcast double* %853 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %854
%855 = or i64 %836, 12
%856 = add i64 %855, %105
%857 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 2, i64 %856
%858 = bitcast double* %857 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %858
%859 = getelementptr inbounds double, double* %857, i64 2
%860 = bitcast double* %859 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %860
%861 = add nuw i64 %836, 16
%862 = add nuw i64 %837, 4
%863 = icmp eq i64 %862, %155
br i1 %863, label %864, label %835
864: ; preds = %835, %834
%865 = phi i64 [ 0, %834 ], [ %861, %835 ]
br i1 %156, label %877, label %866
866: ; preds = %864, %866
%867 = phi i64 [ %874, %866 ], [ %865, %864 ]
%868 = phi i64 [ %875, %866 ], [ 0, %864 ]
%869 = add i64 %867, %105
%870 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 2, i64 %869
%871 = bitcast double* %870 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %871
%872 = getelementptr inbounds double, double* %870, i64 2
%873 = bitcast double* %872 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %873
%874 = add nuw i64 %867, 4
%875 = add i64 %868, 1
%876 = icmp eq i64 %875, %153
br i1 %876, label %877, label %866
877: ; preds = %866, %864
br i1 %157, label %886, label %878
878: ; preds = %833, %877
%879 = phi i64 [ %105, %833 ], [ %152, %877 ]
br label %880
880: ; preds = %878, %880
%881 = phi i64 [ %883, %880 ], [ %879, %878 ]
%882 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 2, i64 %881
store double 2.000000e+00, double* %882
%883 = add nsw i64 %881, 1
%884 = trunc i64 %883 to i32
%885 = icmp eq i32 %884, 12
br i1 %885, label %886, label %880
886: ; preds = %880, %877
br i1 %104, label %887, label %1264
887: ; preds = %886
br i1 %158, label %932, label %888
888: ; preds = %887
br i1 %162, label %918, label %889
889: ; preds = %888, %889
%890 = phi i64 [ %915, %889 ], [ 0, %888 ]
%891 = phi i64 [ %916, %889 ], [ 0, %888 ]
%892 = add i64 %890, %105
%893 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 3, i64 %892
%894 = bitcast double* %893 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %894
%895 = getelementptr inbounds double, double* %893, i64 2
%896 = bitcast double* %895 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %896
%897 = or i64 %890, 4
%898 = add i64 %897, %105
%899 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 3, i64 %898
%900 = bitcast double* %899 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %900
%901 = getelementptr inbounds double, double* %899, i64 2
%902 = bitcast double* %901 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %902
%903 = or i64 %890, 8
%904 = add i64 %903, %105
%905 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 3, i64 %904
%906 = bitcast double* %905 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %906
%907 = getelementptr inbounds double, double* %905, i64 2
%908 = bitcast double* %907 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %908
%909 = or i64 %890, 12
%910 = add i64 %909, %105
%911 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 3, i64 %910
%912 = bitcast double* %911 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %912
%913 = getelementptr inbounds double, double* %911, i64 2
%914 = bitcast double* %913 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %914
%915 = add nuw i64 %890, 16
%916 = add nuw i64 %891, 4
%917 = icmp eq i64 %916, %163
br i1 %917, label %918, label %889
918: ; preds = %889, %888
%919 = phi i64 [ 0, %888 ], [ %915, %889 ]
br i1 %164, label %931, label %920
920: ; preds = %918, %920
%921 = phi i64 [ %928, %920 ], [ %919, %918 ]
%922 = phi i64 [ %929, %920 ], [ 0, %918 ]
%923 = add i64 %921, %105
%924 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 3, i64 %923
%925 = bitcast double* %924 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %925
%926 = getelementptr inbounds double, double* %924, i64 2
%927 = bitcast double* %926 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %927
%928 = add nuw i64 %921, 4
%929 = add i64 %922, 1
%930 = icmp eq i64 %929, %161
br i1 %930, label %931, label %920
931: ; preds = %920, %918
br i1 %165, label %940, label %932
932: ; preds = %887, %931
%933 = phi i64 [ %105, %887 ], [ %160, %931 ]
br label %934
934: ; preds = %932, %934
%935 = phi i64 [ %937, %934 ], [ %933, %932 ]
%936 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 3, i64 %935
store double 2.000000e+00, double* %936
%937 = add nsw i64 %935, 1
%938 = trunc i64 %937 to i32
%939 = icmp eq i32 %938, 12
br i1 %939, label %940, label %934
940: ; preds = %934, %931
br i1 %104, label %941, label %1264
941: ; preds = %940
br i1 %166, label %986, label %942
942: ; preds = %941
br i1 %170, label %972, label %943
943: ; preds = %942, %943
%944 = phi i64 [ %969, %943 ], [ 0, %942 ]
%945 = phi i64 [ %970, %943 ], [ 0, %942 ]
%946 = add i64 %944, %105
%947 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 4, i64 %946
%948 = bitcast double* %947 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %948
%949 = getelementptr inbounds double, double* %947, i64 2
%950 = bitcast double* %949 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %950
%951 = or i64 %944, 4
%952 = add i64 %951, %105
%953 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 4, i64 %952
%954 = bitcast double* %953 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %954
%955 = getelementptr inbounds double, double* %953, i64 2
%956 = bitcast double* %955 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %956
%957 = or i64 %944, 8
%958 = add i64 %957, %105
%959 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 4, i64 %958
%960 = bitcast double* %959 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %960
%961 = getelementptr inbounds double, double* %959, i64 2
%962 = bitcast double* %961 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %962
%963 = or i64 %944, 12
%964 = add i64 %963, %105
%965 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 4, i64 %964
%966 = bitcast double* %965 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %966
%967 = getelementptr inbounds double, double* %965, i64 2
%968 = bitcast double* %967 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %968
%969 = add nuw i64 %944, 16
%970 = add nuw i64 %945, 4
%971 = icmp eq i64 %970, %171
br i1 %971, label %972, label %943
972: ; preds = %943, %942
%973 = phi i64 [ 0, %942 ], [ %969, %943 ]
br i1 %172, label %985, label %974
974: ; preds = %972, %974
%975 = phi i64 [ %982, %974 ], [ %973, %972 ]
%976 = phi i64 [ %983, %974 ], [ 0, %972 ]
%977 = add i64 %975, %105
%978 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 4, i64 %977
%979 = bitcast double* %978 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %979
%980 = getelementptr inbounds double, double* %978, i64 2
%981 = bitcast double* %980 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %981
%982 = add nuw i64 %975, 4
%983 = add i64 %976, 1
%984 = icmp eq i64 %983, %169
br i1 %984, label %985, label %974
985: ; preds = %974, %972
br i1 %173, label %994, label %986
986: ; preds = %941, %985
%987 = phi i64 [ %105, %941 ], [ %168, %985 ]
br label %988
988: ; preds = %986, %988
%989 = phi i64 [ %991, %988 ], [ %987, %986 ]
%990 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 4, i64 %989
store double 2.000000e+00, double* %990
%991 = add nsw i64 %989, 1
%992 = trunc i64 %991 to i32
%993 = icmp eq i32 %992, 12
br i1 %993, label %994, label %988
994: ; preds = %988, %985
br i1 %104, label %995, label %1264
995: ; preds = %994
br i1 %174, label %1040, label %996
996: ; preds = %995
br i1 %178, label %1026, label %997
997: ; preds = %996, %997
%998 = phi i64 [ %1023, %997 ], [ 0, %996 ]
%999 = phi i64 [ %1024, %997 ], [ 0, %996 ]
%1000 = add i64 %998, %105
%1001 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 5, i64 %1000
%1002 = bitcast double* %1001 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1002
%1003 = getelementptr inbounds double, double* %1001, i64 2
%1004 = bitcast double* %1003 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1004
%1005 = or i64 %998, 4
%1006 = add i64 %1005, %105
%1007 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 5, i64 %1006
%1008 = bitcast double* %1007 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1008
%1009 = getelementptr inbounds double, double* %1007, i64 2
%1010 = bitcast double* %1009 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1010
%1011 = or i64 %998, 8
%1012 = add i64 %1011, %105
%1013 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 5, i64 %1012
%1014 = bitcast double* %1013 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1014
%1015 = getelementptr inbounds double, double* %1013, i64 2
%1016 = bitcast double* %1015 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1016
%1017 = or i64 %998, 12
%1018 = add i64 %1017, %105
%1019 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 5, i64 %1018
%1020 = bitcast double* %1019 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1020
%1021 = getelementptr inbounds double, double* %1019, i64 2
%1022 = bitcast double* %1021 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1022
%1023 = add nuw i64 %998, 16
%1024 = add nuw i64 %999, 4
%1025 = icmp eq i64 %1024, %179
br i1 %1025, label %1026, label %997
1026: ; preds = %997, %996
%1027 = phi i64 [ 0, %996 ], [ %1023, %997 ]
br i1 %180, label %1039, label %1028
1028: ; preds = %1026, %1028
%1029 = phi i64 [ %1036, %1028 ], [ %1027, %1026 ]
%1030 = phi i64 [ %1037, %1028 ], [ 0, %1026 ]
%1031 = add i64 %1029, %105
%1032 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 5, i64 %1031
%1033 = bitcast double* %1032 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1033
%1034 = getelementptr inbounds double, double* %1032, i64 2
%1035 = bitcast double* %1034 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1035
%1036 = add nuw i64 %1029, 4
%1037 = add i64 %1030, 1
%1038 = icmp eq i64 %1037, %177
br i1 %1038, label %1039, label %1028
1039: ; preds = %1028, %1026
br i1 %181, label %1048, label %1040
1040: ; preds = %995, %1039
%1041 = phi i64 [ %105, %995 ], [ %176, %1039 ]
br label %1042
1042: ; preds = %1040, %1042
%1043 = phi i64 [ %1045, %1042 ], [ %1041, %1040 ]
%1044 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 5, i64 %1043
store double 2.000000e+00, double* %1044
%1045 = add nsw i64 %1043, 1
%1046 = trunc i64 %1045 to i32
%1047 = icmp eq i32 %1046, 12
br i1 %1047, label %1048, label %1042
1048: ; preds = %1042, %1039
br i1 %104, label %1049, label %1264
1049: ; preds = %1048
br i1 %182, label %1094, label %1050
1050: ; preds = %1049
br i1 %186, label %1080, label %1051
1051: ; preds = %1050, %1051
%1052 = phi i64 [ %1077, %1051 ], [ 0, %1050 ]
%1053 = phi i64 [ %1078, %1051 ], [ 0, %1050 ]
%1054 = add i64 %1052, %105
%1055 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 6, i64 %1054
%1056 = bitcast double* %1055 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1056
%1057 = getelementptr inbounds double, double* %1055, i64 2
%1058 = bitcast double* %1057 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1058
%1059 = or i64 %1052, 4
%1060 = add i64 %1059, %105
%1061 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 6, i64 %1060
%1062 = bitcast double* %1061 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1062
%1063 = getelementptr inbounds double, double* %1061, i64 2
%1064 = bitcast double* %1063 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1064
%1065 = or i64 %1052, 8
%1066 = add i64 %1065, %105
%1067 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 6, i64 %1066
%1068 = bitcast double* %1067 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1068
%1069 = getelementptr inbounds double, double* %1067, i64 2
%1070 = bitcast double* %1069 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1070
%1071 = or i64 %1052, 12
%1072 = add i64 %1071, %105
%1073 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 6, i64 %1072
%1074 = bitcast double* %1073 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1074
%1075 = getelementptr inbounds double, double* %1073, i64 2
%1076 = bitcast double* %1075 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1076
%1077 = add nuw i64 %1052, 16
%1078 = add nuw i64 %1053, 4
%1079 = icmp eq i64 %1078, %187
br i1 %1079, label %1080, label %1051
1080: ; preds = %1051, %1050
%1081 = phi i64 [ 0, %1050 ], [ %1077, %1051 ]
br i1 %188, label %1093, label %1082
1082: ; preds = %1080, %1082
%1083 = phi i64 [ %1090, %1082 ], [ %1081, %1080 ]
%1084 = phi i64 [ %1091, %1082 ], [ 0, %1080 ]
%1085 = add i64 %1083, %105
%1086 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 6, i64 %1085
%1087 = bitcast double* %1086 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1087
%1088 = getelementptr inbounds double, double* %1086, i64 2
%1089 = bitcast double* %1088 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1089
%1090 = add nuw i64 %1083, 4
%1091 = add i64 %1084, 1
%1092 = icmp eq i64 %1091, %185
br i1 %1092, label %1093, label %1082
1093: ; preds = %1082, %1080
br i1 %189, label %1102, label %1094
1094: ; preds = %1049, %1093
%1095 = phi i64 [ %105, %1049 ], [ %184, %1093 ]
br label %1096
1096: ; preds = %1094, %1096
%1097 = phi i64 [ %1099, %1096 ], [ %1095, %1094 ]
%1098 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 6, i64 %1097
store double 2.000000e+00, double* %1098
%1099 = add nsw i64 %1097, 1
%1100 = trunc i64 %1099 to i32
%1101 = icmp eq i32 %1100, 12
br i1 %1101, label %1102, label %1096
1102: ; preds = %1096, %1093
br i1 %104, label %1103, label %1264
1103: ; preds = %1102
br i1 %190, label %1148, label %1104
1104: ; preds = %1103
br i1 %194, label %1134, label %1105
1105: ; preds = %1104, %1105
%1106 = phi i64 [ %1131, %1105 ], [ 0, %1104 ]
%1107 = phi i64 [ %1132, %1105 ], [ 0, %1104 ]
%1108 = add i64 %1106, %105
%1109 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 7, i64 %1108
%1110 = bitcast double* %1109 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1110
%1111 = getelementptr inbounds double, double* %1109, i64 2
%1112 = bitcast double* %1111 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1112
%1113 = or i64 %1106, 4
%1114 = add i64 %1113, %105
%1115 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 7, i64 %1114
%1116 = bitcast double* %1115 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1116
%1117 = getelementptr inbounds double, double* %1115, i64 2
%1118 = bitcast double* %1117 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1118
%1119 = or i64 %1106, 8
%1120 = add i64 %1119, %105
%1121 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 7, i64 %1120
%1122 = bitcast double* %1121 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1122
%1123 = getelementptr inbounds double, double* %1121, i64 2
%1124 = bitcast double* %1123 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1124
%1125 = or i64 %1106, 12
%1126 = add i64 %1125, %105
%1127 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 7, i64 %1126
%1128 = bitcast double* %1127 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1128
%1129 = getelementptr inbounds double, double* %1127, i64 2
%1130 = bitcast double* %1129 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1130
%1131 = add nuw i64 %1106, 16
%1132 = add nuw i64 %1107, 4
%1133 = icmp eq i64 %1132, %195
br i1 %1133, label %1134, label %1105
1134: ; preds = %1105, %1104
%1135 = phi i64 [ 0, %1104 ], [ %1131, %1105 ]
br i1 %196, label %1147, label %1136
1136: ; preds = %1134, %1136
%1137 = phi i64 [ %1144, %1136 ], [ %1135, %1134 ]
%1138 = phi i64 [ %1145, %1136 ], [ 0, %1134 ]
%1139 = add i64 %1137, %105
%1140 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 7, i64 %1139
%1141 = bitcast double* %1140 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1141
%1142 = getelementptr inbounds double, double* %1140, i64 2
%1143 = bitcast double* %1142 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1143
%1144 = add nuw i64 %1137, 4
%1145 = add i64 %1138, 1
%1146 = icmp eq i64 %1145, %193
br i1 %1146, label %1147, label %1136
1147: ; preds = %1136, %1134
br i1 %197, label %1156, label %1148
1148: ; preds = %1103, %1147
%1149 = phi i64 [ %105, %1103 ], [ %192, %1147 ]
br label %1150
1150: ; preds = %1148, %1150
%1151 = phi i64 [ %1153, %1150 ], [ %1149, %1148 ]
%1152 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 7, i64 %1151
store double 2.000000e+00, double* %1152
%1153 = add nsw i64 %1151, 1
%1154 = trunc i64 %1153 to i32
%1155 = icmp eq i32 %1154, 12
br i1 %1155, label %1156, label %1150
1156: ; preds = %1150, %1147
br i1 %104, label %1157, label %1264
1157: ; preds = %1156
br i1 %198, label %1202, label %1158
1158: ; preds = %1157
br i1 %202, label %1188, label %1159
1159: ; preds = %1158, %1159
%1160 = phi i64 [ %1185, %1159 ], [ 0, %1158 ]
%1161 = phi i64 [ %1186, %1159 ], [ 0, %1158 ]
%1162 = add i64 %1160, %105
%1163 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 8, i64 %1162
%1164 = bitcast double* %1163 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1164
%1165 = getelementptr inbounds double, double* %1163, i64 2
%1166 = bitcast double* %1165 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1166
%1167 = or i64 %1160, 4
%1168 = add i64 %1167, %105
%1169 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 8, i64 %1168
%1170 = bitcast double* %1169 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1170
%1171 = getelementptr inbounds double, double* %1169, i64 2
%1172 = bitcast double* %1171 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1172
%1173 = or i64 %1160, 8
%1174 = add i64 %1173, %105
%1175 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 8, i64 %1174
%1176 = bitcast double* %1175 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1176
%1177 = getelementptr inbounds double, double* %1175, i64 2
%1178 = bitcast double* %1177 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1178
%1179 = or i64 %1160, 12
%1180 = add i64 %1179, %105
%1181 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 8, i64 %1180
%1182 = bitcast double* %1181 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1182
%1183 = getelementptr inbounds double, double* %1181, i64 2
%1184 = bitcast double* %1183 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1184
%1185 = add nuw i64 %1160, 16
%1186 = add nuw i64 %1161, 4
%1187 = icmp eq i64 %1186, %203
br i1 %1187, label %1188, label %1159
1188: ; preds = %1159, %1158
%1189 = phi i64 [ 0, %1158 ], [ %1185, %1159 ]
br i1 %204, label %1201, label %1190
1190: ; preds = %1188, %1190
%1191 = phi i64 [ %1198, %1190 ], [ %1189, %1188 ]
%1192 = phi i64 [ %1199, %1190 ], [ 0, %1188 ]
%1193 = add i64 %1191, %105
%1194 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 8, i64 %1193
%1195 = bitcast double* %1194 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1195
%1196 = getelementptr inbounds double, double* %1194, i64 2
%1197 = bitcast double* %1196 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1197
%1198 = add nuw i64 %1191, 4
%1199 = add i64 %1192, 1
%1200 = icmp eq i64 %1199, %201
br i1 %1200, label %1201, label %1190
1201: ; preds = %1190, %1188
br i1 %205, label %1210, label %1202
1202: ; preds = %1157, %1201
%1203 = phi i64 [ %105, %1157 ], [ %200, %1201 ]
br label %1204
1204: ; preds = %1202, %1204
%1205 = phi i64 [ %1207, %1204 ], [ %1203, %1202 ]
%1206 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 8, i64 %1205
store double 2.000000e+00, double* %1206
%1207 = add nsw i64 %1205, 1
%1208 = trunc i64 %1207 to i32
%1209 = icmp eq i32 %1208, 12
br i1 %1209, label %1210, label %1204
1210: ; preds = %1204, %1201
br i1 %104, label %1211, label %1264
1211: ; preds = %1210
br i1 %206, label %1256, label %1212
1212: ; preds = %1211
br i1 %210, label %1242, label %1213
1213: ; preds = %1212, %1213
%1214 = phi i64 [ %1239, %1213 ], [ 0, %1212 ]
%1215 = phi i64 [ %1240, %1213 ], [ 0, %1212 ]
%1216 = add i64 %1214, %105
%1217 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 9, i64 %1216
%1218 = bitcast double* %1217 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1218
%1219 = getelementptr inbounds double, double* %1217, i64 2
%1220 = bitcast double* %1219 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1220
%1221 = or i64 %1214, 4
%1222 = add i64 %1221, %105
%1223 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 9, i64 %1222
%1224 = bitcast double* %1223 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1224
%1225 = getelementptr inbounds double, double* %1223, i64 2
%1226 = bitcast double* %1225 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1226
%1227 = or i64 %1214, 8
%1228 = add i64 %1227, %105
%1229 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 9, i64 %1228
%1230 = bitcast double* %1229 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1230
%1231 = getelementptr inbounds double, double* %1229, i64 2
%1232 = bitcast double* %1231 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1232
%1233 = or i64 %1214, 12
%1234 = add i64 %1233, %105
%1235 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 9, i64 %1234
%1236 = bitcast double* %1235 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1236
%1237 = getelementptr inbounds double, double* %1235, i64 2
%1238 = bitcast double* %1237 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1238
%1239 = add nuw i64 %1214, 16
%1240 = add nuw i64 %1215, 4
%1241 = icmp eq i64 %1240, %211
br i1 %1241, label %1242, label %1213
1242: ; preds = %1213, %1212
%1243 = phi i64 [ 0, %1212 ], [ %1239, %1213 ]
br i1 %212, label %1255, label %1244
1244: ; preds = %1242, %1244
%1245 = phi i64 [ %1252, %1244 ], [ %1243, %1242 ]
%1246 = phi i64 [ %1253, %1244 ], [ 0, %1242 ]
%1247 = add i64 %1245, %105
%1248 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 9, i64 %1247
%1249 = bitcast double* %1248 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1249
%1250 = getelementptr inbounds double, double* %1248, i64 2
%1251 = bitcast double* %1250 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1251
%1252 = add nuw i64 %1245, 4
%1253 = add i64 %1246, 1
%1254 = icmp eq i64 %1253, %209
br i1 %1254, label %1255, label %1244
1255: ; preds = %1244, %1242
br i1 %213, label %1264, label %1256
1256: ; preds = %1211, %1255
%1257 = phi i64 [ %105, %1211 ], [ %208, %1255 ]
br label %1258
1258: ; preds = %1256, %1258
%1259 = phi i64 [ %1261, %1258 ], [ %1257, %1256 ]
%1260 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %702, i64 %724, i64 9, i64 %1259
store double 2.000000e+00, double* %1260
%1261 = add nsw i64 %1259, 1
%1262 = trunc i64 %1261 to i32
%1263 = icmp eq i32 %1262, 12
br i1 %1263, label %1264, label %1258
1264: ; preds = %1258, %1255, %723, %778, %832, %886, %940, %994, %1048, %1102, %1156, %1210
%1265 = add nuw nsw i64 %724, 1
%1266 = icmp eq i64 %1265, 8
br i1 %1266, label %1267, label %723
1267: ; preds = %1264
%1268 = add nuw nsw i64 %702, 1
%1269 = icmp eq i64 %1268, 6
br i1 %1269, label %703, label %701
1270: ; preds = %703, %1397
%1271 = phi i64 [ 0, %703 ], [ %1398, %1397 ]
%1272 = phi i32 [ 0, %703 ], [ %1391, %1397 ]
br label %1273
1273: ; preds = %1270, %1394
%1274 = phi i64 [ 0, %1270 ], [ %1395, %1394 ]
%1275 = phi i32 [ %1272, %1270 ], [ %1391, %1394 ]
br label %1276
1276: ; preds = %1273, %1390
%1277 = phi i64 [ 0, %1273 ], [ %1392, %1390 ]
%1278 = phi i32 [ %1275, %1273 ], [ %1391, %1390 ]
br i1 %12, label %1279, label %1390
1279: ; preds = %1276
%1280 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %1271, i64 %1274, i64 %1277, i64 0
%1281 = load double, double* %1280
%1282 = fcmp une double %1281, 1.000000e+00
%1283 = zext i1 %1282 to i32
%1284 = add nsw i32 %1278, %1283
br i1 %705, label %1390, label %1285
1285: ; preds = %1279
%1286 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %1271, i64 %1274, i64 %1277, i64 1
%1287 = load double, double* %1286
%1288 = fcmp une double %1287, 1.000000e+00
%1289 = zext i1 %1288 to i32
%1290 = add nsw i32 %1284, %1289
br i1 %706, label %1390, label %1291
1291: ; preds = %1285
%1292 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %1271, i64 %1274, i64 %1277, i64 2
%1293 = load double, double* %1292
%1294 = fcmp une double %1293, 1.000000e+00
%1295 = zext i1 %1294 to i32
%1296 = add nsw i32 %1290, %1295
br i1 %707, label %1390, label %1297
1297: ; preds = %1291
%1298 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %1271, i64 %1274, i64 %1277, i64 3
%1299 = load double, double* %1298
%1300 = fcmp une double %1299, 1.000000e+00
%1301 = zext i1 %1300 to i32
%1302 = add nsw i32 %1296, %1301
br i1 %708, label %1390, label %1303
1303: ; preds = %1297
%1304 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %1271, i64 %1274, i64 %1277, i64 4
%1305 = load double, double* %1304
%1306 = fcmp une double %1305, 1.000000e+00
%1307 = zext i1 %1306 to i32
%1308 = add nsw i32 %1302, %1307
br i1 %709, label %1390, label %1309
1309: ; preds = %1303
%1310 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %1271, i64 %1274, i64 %1277, i64 5
%1311 = load double, double* %1310
%1312 = fcmp une double %1311, 1.000000e+00
%1313 = zext i1 %1312 to i32
%1314 = add nsw i32 %1308, %1313
br i1 %710, label %1390, label %1315
1315: ; preds = %1309
br i1 %715, label %1377, label %1316
1316: ; preds = %1315
%1317 = insertelement <2 x i32> <i32 poison, i32 0>, i32 %1314, i64 0
br i1 %719, label %1352, label %1318
1318: ; preds = %1316, %1318
%1319 = phi i64 [ %1349, %1318 ], [ 0, %1316 ]
%1320 = phi <2 x i32> [ %1347, %1318 ], [ %1317, %1316 ]
%1321 = phi <2 x i32> [ %1348, %1318 ], [ zeroinitializer, %1316 ]
%1322 = phi i64 [ %1350, %1318 ], [ 0, %1316 ]
%1323 = or i64 %1319, 6
%1324 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %1271, i64 %1274, i64 %1277, i64 %1323
%1325 = bitcast double* %1324 to <2 x double>*
%1326 = load <2 x double>, <2 x double>* %1325
%1327 = getelementptr inbounds double, double* %1324, i64 2
%1328 = bitcast double* %1327 to <2 x double>*
%1329 = load <2 x double>, <2 x double>* %1328
%1330 = fcmp une <2 x double> %1326, <double 2.000000e+00, double 2.000000e+00>
%1331 = fcmp une <2 x double> %1329, <double 2.000000e+00, double 2.000000e+00>
%1332 = zext <2 x i1> %1330 to <2 x i32>
%1333 = zext <2 x i1> %1331 to <2 x i32>
%1334 = add <2 x i32> %1320, %1332
%1335 = add <2 x i32> %1321, %1333
%1336 = add i64 %1319, 10
%1337 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %1271, i64 %1274, i64 %1277, i64 %1336
%1338 = bitcast double* %1337 to <2 x double>*
%1339 = load <2 x double>, <2 x double>* %1338
%1340 = getelementptr inbounds double, double* %1337, i64 2
%1341 = bitcast double* %1340 to <2 x double>*
%1342 = load <2 x double>, <2 x double>* %1341
%1343 = fcmp une <2 x double> %1339, <double 2.000000e+00, double 2.000000e+00>
%1344 = fcmp une <2 x double> %1342, <double 2.000000e+00, double 2.000000e+00>
%1345 = zext <2 x i1> %1343 to <2 x i32>
%1346 = zext <2 x i1> %1344 to <2 x i32>
%1347 = add <2 x i32> %1334, %1345
%1348 = add <2 x i32> %1335, %1346
%1349 = add nuw i64 %1319, 8
%1350 = add i64 %1322, 2
%1351 = icmp eq i64 %1350, %720
br i1 %1351, label %1352, label %1318
1352: ; preds = %1318, %1316
%1353 = phi <2 x i32> [ undef, %1316 ], [ %1347, %1318 ]
%1354 = phi <2 x i32> [ undef, %1316 ], [ %1348, %1318 ]
%1355 = phi i64 [ 0, %1316 ], [ %1349, %1318 ]
%1356 = phi <2 x i32> [ %1317, %1316 ], [ %1347, %1318 ]
%1357 = phi <2 x i32> [ zeroinitializer, %1316 ], [ %1348, %1318 ]
br i1 %721, label %1372, label %1358
1358: ; preds = %1352
%1359 = add i64 %1355, 6
%1360 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %1271, i64 %1274, i64 %1277, i64 %1359
%1361 = bitcast double* %1360 to <2 x double>*
%1362 = load <2 x double>, <2 x double>* %1361
%1363 = getelementptr inbounds double, double* %1360, i64 2
%1364 = bitcast double* %1363 to <2 x double>*
%1365 = load <2 x double>, <2 x double>* %1364
%1366 = fcmp une <2 x double> %1362, <double 2.000000e+00, double 2.000000e+00>
%1367 = fcmp une <2 x double> %1365, <double 2.000000e+00, double 2.000000e+00>
%1368 = zext <2 x i1> %1366 to <2 x i32>
%1369 = zext <2 x i1> %1367 to <2 x i32>
%1370 = add <2 x i32> %1356, %1368
%1371 = add <2 x i32> %1357, %1369
br label %1372
1372: ; preds = %1352, %1358
%1373 = phi <2 x i32> [ %1353, %1352 ], [ %1370, %1358 ]
%1374 = phi <2 x i32> [ %1354, %1352 ], [ %1371, %1358 ]
%1375 = add <2 x i32> %1374, %1373
%1376 = call i32 @llvm.vector.reduce.add.v2i32(<2 x i32> %1375)
br i1 %722, label %1390, label %1377
1377: ; preds = %1315, %1372
%1378 = phi i64 [ 6, %1315 ], [ %717, %1372 ]
%1379 = phi i32 [ %1314, %1315 ], [ %1376, %1372 ]
br label %1380
1380: ; preds = %1377, %1380
%1381 = phi i64 [ %1388, %1380 ], [ %1378, %1377 ]
%1382 = phi i32 [ %1387, %1380 ], [ %1379, %1377 ]
%1383 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %1271, i64 %1274, i64 %1277, i64 %1381
%1384 = load double, double* %1383
%1385 = fcmp une double %1384, 2.000000e+00
%1386 = zext i1 %1385 to i32
%1387 = add nsw i32 %1382, %1386
%1388 = add nuw nsw i64 %1381, 1
%1389 = icmp eq i64 %1388, %704
br i1 %1389, label %1390, label %1380
1390: ; preds = %1380, %1372, %1279, %1285, %1291, %1297, %1303, %1309, %1276
%1391 = phi i32 [ %1278, %1276 ], [ %1284, %1279 ], [ %1290, %1285 ], [ %1296, %1291 ], [ %1302, %1297 ], [ %1308, %1303 ], [ %1314, %1309 ], [ %1376, %1372 ], [ %1387, %1380 ]
%1392 = add nuw nsw i64 %1277, 1
%1393 = icmp eq i64 %1392, 10
br i1 %1393, label %1394, label %1276
1394: ; preds = %1390
%1395 = add nuw nsw i64 %1274, 1
%1396 = icmp eq i64 %1395, 8
br i1 %1396, label %1397, label %1273
1397: ; preds = %1394
%1398 = add nuw nsw i64 %1271, 1
%1399 = icmp eq i64 %1398, 6
br i1 %1399, label %1400, label %1270
1400: ; preds = %1397, %1438
%1401 = phi i64 [ %1439, %1438 ], [ 0, %1397 ]
%1402 = phi i32 [ %1432, %1438 ], [ %1391, %1397 ]
br label %1403
1403: ; preds = %1400, %1435
%1404 = phi i64 [ 0, %1400 ], [ %1436, %1435 ]
%1405 = phi i32 [ %1402, %1400 ], [ %1432, %1435 ]
br label %1406
1406: ; preds = %1403, %1431
%1407 = phi i64 [ 0, %1403 ], [ %1433, %1431 ]
%1408 = phi i32 [ %1405, %1403 ], [ %1432, %1431 ]
br i1 %104, label %1409, label %1431
1409: ; preds = %1406, %1426
%1410 = phi i64 [ %1428, %1426 ], [ %105, %1406 ]
%1411 = phi i32 [ %1427, %1426 ], [ %1408, %1406 ]
%1412 = icmp sgt i64 %1410, 5
br i1 %1412, label %1413, label %1420
1413: ; preds = %1409
%1414 = and i64 %1410, 4294967295
%1415 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %1401, i64 %1404, i64 %1407, i64 %1414
%1416 = load double, double* %1415
%1417 = fcmp une double %1416, 2.000000e+00
br i1 %1417, label %1418, label %1426
1418: ; preds = %1413
%1419 = add nsw i32 %1411, 1
br label %1426
1420: ; preds = %1409
%1421 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %1401, i64 %1404, i64 %1407, i64 %1410
%1422 = load double, double* %1421
%1423 = fcmp une double %1422, 1.000000e+00
br i1 %1423, label %1424, label %1426
1424: ; preds = %1420
%1425 = add nsw i32 %1411, 1
br label %1426
1426: ; preds = %1418, %1413, %1424, %1420
%1427 = phi i32 [ %1419, %1418 ], [ %1411, %1413 ], [ %1425, %1424 ], [ %1411, %1420 ]
%1428 = add nsw i64 %1410, 1
%1429 = trunc i64 %1428 to i32
%1430 = icmp eq i32 %1429, 12
br i1 %1430, label %1431, label %1409
1431: ; preds = %1426, %1406
%1432 = phi i32 [ %1408, %1406 ], [ %1427, %1426 ]
%1433 = add nuw nsw i64 %1407, 1
%1434 = icmp eq i64 %1433, 10
br i1 %1434, label %1435, label %1406
1435: ; preds = %1431
%1436 = add nuw nsw i64 %1404, 1
%1437 = icmp eq i64 %1436, 8
br i1 %1437, label %1438, label %1403
1438: ; preds = %1435
%1439 = add nuw nsw i64 %1401, 1
%1440 = icmp eq i64 %1439, 6
br i1 %1440, label %1441, label %1400
1441: ; preds = %1438
%1442 = icmp eq i32 %1432, 0
br i1 %1442, label %1500, label %1443
1443: ; preds = %1441
%1444 = zext i32 %15 to i64
br label %1445
1445: ; preds = %1443, %1469
%1446 = phi i64 [ 0, %1443 ], [ %1470, %1469 ]
%1447 = trunc i64 %1446 to i32
br label %1448
1448: ; preds = %1445, %1466
%1449 = phi i64 [ 0, %1445 ], [ %1467, %1466 ]
%1450 = trunc i64 %1449 to i32
br label %1451
1451: ; preds = %1448, %1463
%1452 = phi i64 [ 0, %1448 ], [ %1464, %1463 ]
br i1 %12, label %1453, label %1463
1453: ; preds = %1451
%1454 = trunc i64 %1452 to i32
br label %1455
1455: ; preds = %1453, %1455
%1456 = phi i64 [ 0, %1453 ], [ %1461, %1455 ]
%1457 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %1446, i64 %1449, i64 %1452, i64 %1456
%1458 = load double, double* %1457
%1459 = trunc i64 %1456 to i32
%1460 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 1, i32 %1447, i32 %1450, i32 %1454, i32 %1459, double %1458)
%1461 = add nuw nsw i64 %1456, 1
%1462 = icmp eq i64 %1461, %1444
br i1 %1462, label %1463, label %1455
1463: ; preds = %1455, %1451
%1464 = add nuw nsw i64 %1452, 1
%1465 = icmp eq i64 %1464, 10
br i1 %1465, label %1466, label %1451
1466: ; preds = %1463
%1467 = add nuw nsw i64 %1449, 1
%1468 = icmp eq i64 %1467, 8
br i1 %1468, label %1469, label %1448
1469: ; preds = %1466
%1470 = add nuw nsw i64 %1446, 1
%1471 = icmp eq i64 %1470, 6
br i1 %1471, label %1472, label %1445
1472: ; preds = %1469, %1497
%1473 = phi i64 [ %1498, %1497 ], [ 0, %1469 ]
%1474 = trunc i64 %1473 to i32
br label %1475
1475: ; preds = %1472, %1494
%1476 = phi i64 [ 0, %1472 ], [ %1495, %1494 ]
%1477 = trunc i64 %1476 to i32
br label %1478
1478: ; preds = %1475, %1491
%1479 = phi i64 [ 0, %1475 ], [ %1492, %1491 ]
br i1 %104, label %1480, label %1491
1480: ; preds = %1478
%1481 = trunc i64 %1479 to i32
br label %1482
1482: ; preds = %1480, %1482
%1483 = phi i64 [ %105, %1480 ], [ %1488, %1482 ]
%1484 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %1473, i64 %1476, i64 %1479, i64 %1483
%1485 = load double, double* %1484
%1486 = trunc i64 %1483 to i32
%1487 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 2, i32 %1474, i32 %1477, i32 %1481, i32 %1486, double %1485)
%1488 = add nsw i64 %1483, 1
%1489 = trunc i64 %1488 to i32
%1490 = icmp eq i32 %1489, 12
br i1 %1490, label %1491, label %1482
1491: ; preds = %1482, %1478
%1492 = add nuw nsw i64 %1479, 1
%1493 = icmp eq i64 %1492, 10
br i1 %1493, label %1494, label %1478
1494: ; preds = %1491
%1495 = add nuw nsw i64 %1476, 1
%1496 = icmp eq i64 %1495, 8
br i1 %1496, label %1497, label %1475
1497: ; preds = %1494
%1498 = add nuw nsw i64 %1473, 1
%1499 = icmp eq i64 %1498, 6
br i1 %1499, label %1500, label %1472
1500: ; preds = %1497, %1441
%1501 = phi i32 [ 0, %1441 ], [ 1, %1497 ]
ret i32 %1501
}