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


x86 assembly (clang, -O0):
<test_dist_y>:
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_y+0x101>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    0x30(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    11fe <test_dist_y+0xee>
movl   $0x0,-0x2c(%rbp)
cmpl   $0xa,-0x2c(%rbp)
jge    11eb <test_dist_y+0xdb>
movl   $0x0,-0x28(%rbp)
cmpl   $0xc,-0x28(%rbp)
jge    11d8 <test_dist_y+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    1184 <test_dist_y+0x74>
jmp    11dd <test_dist_y+0xcd>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1173 <test_dist_y+0x63>
jmp    11f0 <test_dist_y+0xe0>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    115b <test_dist_y+0x4b>
jmp    1203 <test_dist_y+0xf3>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    114a <test_dist_y+0x3a>
movl   $0x0,-0x34(%rbp)
cmpl   $0x6,-0x34(%rbp)
jge    12dc <test_dist_y+0x1cc>
mov    $0x4,%eax
sub    0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x8,-0x30(%rbp)
jge    12c9 <test_dist_y+0x1b9>
movl   $0x0,-0x2c(%rbp)
cmpl   $0xa,-0x2c(%rbp)
jge    12b6 <test_dist_y+0x1a6>
movl   $0x0,-0x28(%rbp)
cmpl   $0xc,-0x28(%rbp)
jge    12a3 <test_dist_y+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_y+0x13f>
jmp    12a8 <test_dist_y+0x198>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    123e <test_dist_y+0x12e>
jmp    12bb <test_dist_y+0x1ab>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    122d <test_dist_y+0x11d>
jmp    12ce <test_dist_y+0x1be>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1218 <test_dist_y+0x108>
movl   $0x0,-0x34(%rbp)
cmpl   $0x6,-0x34(%rbp)
jge    1446 <test_dist_y+0x336>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    0x30(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    1433 <test_dist_y+0x323>
movl   $0x0,-0x2c(%rbp)
cmpl   $0xa,-0x2c(%rbp)
jge    1420 <test_dist_y+0x310>
movl   $0x0,-0x28(%rbp)
cmpl   $0xc,-0x28(%rbp)
jge    140d <test_dist_y+0x2fd>
xor    %eax,%eax
cmp    -0x30(%rbp),%eax
jg     139b <test_dist_y+0x28b>
cmpl   $0x4,-0x30(%rbp)
jge    139b <test_dist_y+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_y+0x27d>
jp     138d <test_dist_y+0x27d>
jmp    1396 <test_dist_y+0x286>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13fa <test_dist_y+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_y+0x2dc>
jp     13ec <test_dist_y+0x2dc>
jmp    13f5 <test_dist_y+0x2e5>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13fa <test_dist_y+0x2ea>
jmp    13ff <test_dist_y+0x2ef>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    131d <test_dist_y+0x20d>
jmp    1412 <test_dist_y+0x302>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    130c <test_dist_y+0x1fc>
jmp    1425 <test_dist_y+0x315>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12f4 <test_dist_y+0x1e4>
jmp    1438 <test_dist_y+0x328>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12e3 <test_dist_y+0x1d3>
movl   $0x0,-0x34(%rbp)
cmpl   $0x6,-0x34(%rbp)
jge    15b0 <test_dist_y+0x4a0>
mov    $0x4,%eax
sub    0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x8,-0x30(%rbp)
jge    159d <test_dist_y+0x48d>
movl   $0x0,-0x2c(%rbp)
cmpl   $0xa,-0x2c(%rbp)
jge    158a <test_dist_y+0x47a>
movl   $0x0,-0x28(%rbp)
cmpl   $0xc,-0x28(%rbp)
jge    1577 <test_dist_y+0x467>
mov    $0x4,%eax
cmp    -0x30(%rbp),%eax
jg     1505 <test_dist_y+0x3f5>
cmpl   $0x8,-0x30(%rbp)
jge    1505 <test_dist_y+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_y+0x3e7>
jp     14f7 <test_dist_y+0x3e7>
jmp    1500 <test_dist_y+0x3f0>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1564 <test_dist_y+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_y+0x446>
jp     1556 <test_dist_y+0x446>
jmp    155f <test_dist_y+0x44f>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1564 <test_dist_y+0x454>
jmp    1569 <test_dist_y+0x459>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1484 <test_dist_y+0x374>
jmp    157c <test_dist_y+0x46c>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1473 <test_dist_y+0x363>
jmp    158f <test_dist_y+0x47f>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1462 <test_dist_y+0x352>
jmp    15a2 <test_dist_y+0x492>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    144d <test_dist_y+0x33d>
cmpl   $0x0,-0x38(%rbp)
jne    15c6 <test_dist_y+0x4b6>
movl   $0x0,-0x4(%rbp)
jmp    1794 <test_dist_y+0x684>
movl   $0x0,-0x34(%rbp)
cmpl   $0x6,-0x34(%rbp)
jge    16ab <test_dist_y+0x59b>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    0x30(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    1698 <test_dist_y+0x588>
movl   $0x0,-0x2c(%rbp)
cmpl   $0xa,-0x2c(%rbp)
jge    1685 <test_dist_y+0x575>
movl   $0x0,-0x28(%rbp)
cmpl   $0xc,-0x28(%rbp)
jge    1672 <test_dist_y+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    1607 <test_dist_y+0x4f7>
jmp    1677 <test_dist_y+0x567>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    15f6 <test_dist_y+0x4e6>
jmp    168a <test_dist_y+0x57a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15de <test_dist_y+0x4ce>
jmp    169d <test_dist_y+0x58d>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15cd <test_dist_y+0x4bd>
movl   $0x0,-0x34(%rbp)
cmpl   $0x6,-0x34(%rbp)
jge    178d <test_dist_y+0x67d>
mov    $0x4,%eax
sub    0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x8,-0x30(%rbp)
jge    177a <test_dist_y+0x66a>
movl   $0x0,-0x2c(%rbp)
cmpl   $0xa,-0x2c(%rbp)
jge    1767 <test_dist_y+0x657>
movl   $0x0,-0x28(%rbp)
cmpl   $0xc,-0x28(%rbp)
jge    1754 <test_dist_y+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_y+0x5d9>
jmp    1759 <test_dist_y+0x649>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    16d8 <test_dist_y+0x5c8>
jmp    176c <test_dist_y+0x65c>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    16c7 <test_dist_y+0x5b7>
jmp    177f <test_dist_y+0x66f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    16b2 <test_dist_y+0x5a2>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<test_dist_y>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    0x80(%rsp),%r13d
mov    0x78(%rsp),%r11d
lea    0x3(%r13),%eax
xor    %ecx,%ecx
test   %eax,%eax
cmovle %ecx,%eax
add    $0x1,%eax
lea    0x3b0(%rdi),%rdx
imul   $0x3c0,%rax,%rsi
movaps 0xeb2(%rip),%xmm0
jmp    1165 <test_dist_y+0x55>
add    $0x1,%rcx
add    $0x1e00,%rdx
cmp    $0x6,%rcx
je     1349 <test_dist_y+0x239>
cmp    $0xfffffffd,%r13d
jl     1150 <test_dist_y+0x40>
xor    %ebp,%ebp
nopl   (%rax)
movups %xmm0,-0x3b0(%rdx,%rbp,1)
ff
movups %xmm0,-0x3a0(%rdx,%rbp,1)
ff
movups %xmm0,-0x390(%rdx,%rbp,1)
ff
movups %xmm0,-0x380(%rdx,%rbp,1)
ff
movups %xmm0,-0x370(%rdx,%rbp,1)
ff
movups %xmm0,-0x360(%rdx,%rbp,1)
ff
movups %xmm0,-0x350(%rdx,%rbp,1)
ff
movups %xmm0,-0x340(%rdx,%rbp,1)
ff
movups %xmm0,-0x330(%rdx,%rbp,1)
ff
movups %xmm0,-0x320(%rdx,%rbp,1)
ff
movups %xmm0,-0x310(%rdx,%rbp,1)
ff
movups %xmm0,-0x300(%rdx,%rbp,1)
ff
movups %xmm0,-0x2f0(%rdx,%rbp,1)
ff
movups %xmm0,-0x2e0(%rdx,%rbp,1)
ff
movups %xmm0,-0x2d0(%rdx,%rbp,1)
ff
movups %xmm0,-0x2c0(%rdx,%rbp,1)
ff
movups %xmm0,-0x2b0(%rdx,%rbp,1)
ff
movups %xmm0,-0x2a0(%rdx,%rbp,1)
ff
movups %xmm0,-0x290(%rdx,%rbp,1)
ff
movups %xmm0,-0x280(%rdx,%rbp,1)
ff
movups %xmm0,-0x270(%rdx,%rbp,1)
ff
movups %xmm0,-0x260(%rdx,%rbp,1)
ff
movups %xmm0,-0x250(%rdx,%rbp,1)
ff
movups %xmm0,-0x240(%rdx,%rbp,1)
ff
movups %xmm0,-0x230(%rdx,%rbp,1)
ff
movups %xmm0,-0x220(%rdx,%rbp,1)
ff
movups %xmm0,-0x210(%rdx,%rbp,1)
ff
movups %xmm0,-0x200(%rdx,%rbp,1)
ff
movups %xmm0,-0x1f0(%rdx,%rbp,1)
ff
movups %xmm0,-0x1e0(%rdx,%rbp,1)
ff
movups %xmm0,-0x1d0(%rdx,%rbp,1)
ff
movups %xmm0,-0x1c0(%rdx,%rbp,1)
ff
movups %xmm0,-0x1b0(%rdx,%rbp,1)
ff
movups %xmm0,-0x1a0(%rdx,%rbp,1)
ff
movups %xmm0,-0x190(%rdx,%rbp,1)
ff
movups %xmm0,-0x180(%rdx,%rbp,1)
ff
movups %xmm0,-0x170(%rdx,%rbp,1)
ff
movups %xmm0,-0x160(%rdx,%rbp,1)
ff
movups %xmm0,-0x150(%rdx,%rbp,1)
ff
movups %xmm0,-0x140(%rdx,%rbp,1)
ff
movups %xmm0,-0x130(%rdx,%rbp,1)
ff
movups %xmm0,-0x120(%rdx,%rbp,1)
ff
movups %xmm0,-0x110(%rdx,%rbp,1)
ff
movups %xmm0,-0x100(%rdx,%rbp,1)
ff
movups %xmm0,-0xf0(%rdx,%rbp,1)
ff
movups %xmm0,-0xe0(%rdx,%rbp,1)
ff
movups %xmm0,-0xd0(%rdx,%rbp,1)
ff
movups %xmm0,-0xc0(%rdx,%rbp,1)
ff
movups %xmm0,-0xb0(%rdx,%rbp,1)
ff
movups %xmm0,-0xa0(%rdx,%rbp,1)
ff
movups %xmm0,-0x90(%rdx,%rbp,1)
ff
movups %xmm0,-0x80(%rdx,%rbp,1)
movups %xmm0,-0x70(%rdx,%rbp,1)
movups %xmm0,-0x60(%rdx,%rbp,1)
movups %xmm0,-0x50(%rdx,%rbp,1)
movups %xmm0,-0x40(%rdx,%rbp,1)
movups %xmm0,-0x30(%rdx,%rbp,1)
movups %xmm0,-0x20(%rdx,%rbp,1)
movups %xmm0,-0x10(%rdx,%rbp,1)
movups %xmm0,(%rdx,%rbp,1)
add    $0x3c0,%rbp
cmp    %rbp,%rsi
jne    1170 <test_dist_y+0x60>
jmp    1150 <test_dist_y+0x40>
mov    $0x4,%ecx
sub    %r11d,%ecx
movslq %ecx,%r14
imul   $0x3c0,%r14,%r12
lea    (%rdi,%r12,1),%rbp
add    $0x3b0,%rbp
lea    0x4(%r11),%ebx
xor    %esi,%esi
movaps 0xc9d(%rip),%xmm0
jmp    1395 <test_dist_y+0x285>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rsi
add    $0x1e00,%rbp
cmp    $0x6,%rsi
je     153d <test_dist_y+0x42d>
cmp    $0xfffffffd,%r11d
jl     1380 <test_dist_y+0x270>
mov    %ebx,%edx
mov    %rbp,%rcx
movups %xmm0,-0x3b0(%rcx)
movups %xmm0,-0x3a0(%rcx)
movups %xmm0,-0x390(%rcx)
movups %xmm0,-0x380(%rcx)
movups %xmm0,-0x370(%rcx)
movups %xmm0,-0x360(%rcx)
movups %xmm0,-0x350(%rcx)
movups %xmm0,-0x340(%rcx)
movups %xmm0,-0x330(%rcx)
movups %xmm0,-0x320(%rcx)
movups %xmm0,-0x310(%rcx)
movups %xmm0,-0x300(%rcx)
movups %xmm0,-0x2f0(%rcx)
movups %xmm0,-0x2e0(%rcx)
movups %xmm0,-0x2d0(%rcx)
movups %xmm0,-0x2c0(%rcx)
movups %xmm0,-0x2b0(%rcx)
movups %xmm0,-0x2a0(%rcx)
movups %xmm0,-0x290(%rcx)
movups %xmm0,-0x280(%rcx)
movups %xmm0,-0x270(%rcx)
movups %xmm0,-0x260(%rcx)
movups %xmm0,-0x250(%rcx)
movups %xmm0,-0x240(%rcx)
movups %xmm0,-0x230(%rcx)
movups %xmm0,-0x220(%rcx)
movups %xmm0,-0x210(%rcx)
movups %xmm0,-0x200(%rcx)
movups %xmm0,-0x1f0(%rcx)
movups %xmm0,-0x1e0(%rcx)
movups %xmm0,-0x1d0(%rcx)
movups %xmm0,-0x1c0(%rcx)
movups %xmm0,-0x1b0(%rcx)
movups %xmm0,-0x1a0(%rcx)
movups %xmm0,-0x190(%rcx)
movups %xmm0,-0x180(%rcx)
movups %xmm0,-0x170(%rcx)
movups %xmm0,-0x160(%rcx)
movups %xmm0,-0x150(%rcx)
movups %xmm0,-0x140(%rcx)
movups %xmm0,-0x130(%rcx)
movups %xmm0,-0x120(%rcx)
movups %xmm0,-0x110(%rcx)
movups %xmm0,-0x100(%rcx)
movups %xmm0,-0xf0(%rcx)
movups %xmm0,-0xe0(%rcx)
movups %xmm0,-0xd0(%rcx)
movups %xmm0,-0xc0(%rcx)
movups %xmm0,-0xb0(%rcx)
movups %xmm0,-0xa0(%rcx)
movups %xmm0,-0x90(%rcx)
movups %xmm0,-0x80(%rcx)
movups %xmm0,-0x70(%rcx)
movups %xmm0,-0x60(%rcx)
movups %xmm0,-0x50(%rcx)
movups %xmm0,-0x40(%rcx)
movups %xmm0,-0x30(%rcx)
movups %xmm0,-0x20(%rcx)
movups %xmm0,-0x10(%rcx)
movups %xmm0,(%rcx)
add    $0x3c0,%rcx
add    $0xffffffff,%edx
jne    13a0 <test_dist_y+0x290>
jmp    1380 <test_dist_y+0x270>
mov    %eax,%ecx
lea    0x58(%rdi),%r8
xor    %edx,%edx
movsd  0xadb(%rip),%xmm0
movsd  0xacb(%rip),%xmm1
xor    %eax,%eax
jmp    1575 <test_dist_y+0x465>
nopl   0x0(%rax)
add    $0x1,%rdx
add    $0x1e00,%r8
cmp    $0x6,%rdx
je     1804 <test_dist_y+0x6f4>
cmp    $0xfffffffd,%r13d
jl     1560 <test_dist_y+0x450>
mov    %r8,%rsi
xor    %ebp,%ebp
jmp    15a0 <test_dist_y+0x490>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rbp
add    $0x3c0,%rsi
cmp    %rcx,%rbp
je     1560 <test_dist_y+0x450>
xor    %ebx,%ebx
jmp    15bd <test_dist_y+0x4ad>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x60,%rbx
cmp    $0x3c0,%rbx
je     1590 <test_dist_y+0x480>
movsd  -0x58(%rsi,%rbx,1),%xmm2
cmp    $0x3,%rbp
ja     15e0 <test_dist_y+0x4d0>
ucomisd %xmm0,%xmm2
jne    15e8 <test_dist_y+0x4d8>
jp     15e8 <test_dist_y+0x4d8>
jmp    15eb <test_dist_y+0x4db>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
ucomisd %xmm1,%xmm2
jne    15e8 <test_dist_y+0x4d8>
jnp    15eb <test_dist_y+0x4db>
add    $0x1,%eax
movsd  -0x50(%rsi,%rbx,1),%xmm2
cmp    $0x4,%rbp
jae    1610 <test_dist_y+0x500>
ucomisd %xmm0,%xmm2
jne    1618 <test_dist_y+0x508>
jp     1618 <test_dist_y+0x508>
jmp    161b <test_dist_y+0x50b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
ucomisd %xmm1,%xmm2
jne    1618 <test_dist_y+0x508>
jnp    161b <test_dist_y+0x50b>
add    $0x1,%eax
movsd  -0x48(%rsi,%rbx,1),%xmm2
cmp    $0x4,%rbp
jae    1640 <test_dist_y+0x530>
ucomisd %xmm0,%xmm2
jne    1648 <test_dist_y+0x538>
jp     1648 <test_dist_y+0x538>
jmp    164b <test_dist_y+0x53b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
ucomisd %xmm1,%xmm2
jne    1648 <test_dist_y+0x538>
jnp    164b <test_dist_y+0x53b>
add    $0x1,%eax
movsd  -0x40(%rsi,%rbx,1),%xmm2
cmp    $0x4,%rbp
jae    1670 <test_dist_y+0x560>
ucomisd %xmm0,%xmm2
jne    1678 <test_dist_y+0x568>
jp     1678 <test_dist_y+0x568>
jmp    167b <test_dist_y+0x56b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
ucomisd %xmm1,%xmm2
jne    1678 <test_dist_y+0x568>
jnp    167b <test_dist_y+0x56b>
add    $0x1,%eax
movsd  -0x38(%rsi,%rbx,1),%xmm2
cmp    $0x4,%rbp
jae    16a0 <test_dist_y+0x590>
ucomisd %xmm0,%xmm2
jne    16a8 <test_dist_y+0x598>
jp     16a8 <test_dist_y+0x598>
jmp    16ab <test_dist_y+0x59b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
ucomisd %xmm1,%xmm2
jne    16a8 <test_dist_y+0x598>
jnp    16ab <test_dist_y+0x59b>
add    $0x1,%eax
movsd  -0x30(%rsi,%rbx,1),%xmm2
cmp    $0x4,%rbp
jae    16d0 <test_dist_y+0x5c0>
ucomisd %xmm0,%xmm2
jne    16d8 <test_dist_y+0x5c8>
jp     16d8 <test_dist_y+0x5c8>
jmp    16db <test_dist_y+0x5cb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
ucomisd %xmm1,%xmm2
jne    16d8 <test_dist_y+0x5c8>
jnp    16db <test_dist_y+0x5cb>
add    $0x1,%eax
movsd  -0x28(%rsi,%rbx,1),%xmm2
cmp    $0x4,%rbp
jae    1700 <test_dist_y+0x5f0>
ucomisd %xmm0,%xmm2
jne    1708 <test_dist_y+0x5f8>
jp     1708 <test_dist_y+0x5f8>
jmp    170b <test_dist_y+0x5fb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
ucomisd %xmm1,%xmm2
jne    1708 <test_dist_y+0x5f8>
jnp    170b <test_dist_y+0x5fb>
add    $0x1,%eax
movsd  -0x20(%rsi,%rbx,1),%xmm2
cmp    $0x4,%rbp
jae    1730 <test_dist_y+0x620>
ucomisd %xmm0,%xmm2
jne    1738 <test_dist_y+0x628>
jp     1738 <test_dist_y+0x628>
jmp    173b <test_dist_y+0x62b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
ucomisd %xmm1,%xmm2
jne    1738 <test_dist_y+0x628>
jnp    173b <test_dist_y+0x62b>
add    $0x1,%eax
movsd  -0x18(%rsi,%rbx,1),%xmm2
cmp    $0x4,%rbp
jae    1760 <test_dist_y+0x650>
ucomisd %xmm0,%xmm2
jne    1768 <test_dist_y+0x658>
jp     1768 <test_dist_y+0x658>
jmp    176b <test_dist_y+0x65b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
ucomisd %xmm1,%xmm2
jne    1768 <test_dist_y+0x658>
jnp    176b <test_dist_y+0x65b>
add    $0x1,%eax
movsd  -0x10(%rsi,%rbx,1),%xmm2
cmp    $0x4,%rbp
jae    1790 <test_dist_y+0x680>
ucomisd %xmm0,%xmm2
jne    1798 <test_dist_y+0x688>
jp     1798 <test_dist_y+0x688>
jmp    179b <test_dist_y+0x68b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
ucomisd %xmm1,%xmm2
jne    1798 <test_dist_y+0x688>
jnp    179b <test_dist_y+0x68b>
add    $0x1,%eax
movsd  -0x8(%rsi,%rbx,1),%xmm2
cmp    $0x4,%rbp
jae    17c0 <test_dist_y+0x6b0>
ucomisd %xmm0,%xmm2
jne    17c8 <test_dist_y+0x6b8>
jp     17c8 <test_dist_y+0x6b8>
jmp    17cb <test_dist_y+0x6bb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
ucomisd %xmm1,%xmm2
jne    17c8 <test_dist_y+0x6b8>
jnp    17cb <test_dist_y+0x6bb>
add    $0x1,%eax
movsd  (%rsi,%rbx,1),%xmm2
cmp    $0x4,%rbp
jae    17f0 <test_dist_y+0x6e0>
ucomisd %xmm0,%xmm2
jne    17fc <test_dist_y+0x6ec>
jp     17fc <test_dist_y+0x6ec>
jmp    15b0 <test_dist_y+0x4a0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
ucomisd %xmm1,%xmm2
jne    17fc <test_dist_y+0x6ec>
jnp    15b0 <test_dist_y+0x4a0>
add    $0x1,%eax
jmp    15b0 <test_dist_y+0x4a0>
mov    %rcx,(%rsp)
lea    (%rdi,%r12,1),%r8
xor    %r9d,%r9d
mov    %rdi,%r10
jmp    183c <test_dist_y+0x72c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r9
add    $0x1e00,%r8
add    $0x1e00,%r10
cmp    $0x6,%r9
je     18d2 <test_dist_y+0x7c2>
cmp    $0xfffffffd,%r11d
jl     1820 <test_dist_y+0x710>
mov    %r8,%r15
mov    %r14,%rbp
jmp    1860 <test_dist_y+0x750>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbp
add    $0x3c0,%r15
cmp    $0x8,%ebp
je     1820 <test_dist_y+0x710>
mov    %ebp,%edx
imul   $0x3c0,%rdx,%rbx
add    %r10,%rbx
mov    %r15,%rcx
xor    %edx,%edx
jmp    1892 <test_dist_y+0x782>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rdx
add    $0x60,%rcx
add    $0x60,%rbx
cmp    $0xa,%rdx
je     1850 <test_dist_y+0x740>
xor    %esi,%esi
jmp    18aa <test_dist_y+0x79a>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rsi
cmp    $0xc,%rsi
je     1880 <test_dist_y+0x770>
cmp    $0x4,%rbp
jl     18c0 <test_dist_y+0x7b0>
movsd  (%rbx,%rsi,8),%xmm2
ucomisd %xmm1,%xmm2
jne    18cd <test_dist_y+0x7bd>
jp     18cd <test_dist_y+0x7bd>
jmp    18a0 <test_dist_y+0x790>
nop
movsd  (%rcx,%rsi,8),%xmm2
ucomisd %xmm0,%xmm2
jne    18cd <test_dist_y+0x7bd>
jnp    18a0 <test_dist_y+0x790>
add    $0x1,%eax
jmp    18a0 <test_dist_y+0x790>
test   %eax,%eax
je     1d2c <test_dist_y+0xc1c>
mov    %r12,0x10(%rsp)
mov    %r14,0x20(%rsp)
mov    %rdi,0x18(%rsp)
lea    0x58(%rdi),%rax
mov    %rax,0x8(%rsp)
xor    %r12d,%r12d
lea    0x734(%rip),%r15
jmp    191f <test_dist_y+0x80f>
xchg   %ax,%ax
add    $0x1,%r12
addq   $0x1e00,0x8(%rsp)
cmp    $0x6,%r12
mov    0x80(%rsp),%r13d
je     1b00 <test_dist_y+0x9f0>
cmp    $0xfffffffd,%r13d
jl     1900 <test_dist_y+0x7f0>
mov    0x8(%rsp),%rbp
xor    %r13d,%r13d
nopl   (%rax)
mov    %rbp,%r14
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x58(%r14),%xmm0
mov    %r15,%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    %r13d,%ecx
mov    %ebx,%r8d
xor    %r9d,%r9d
call   1030 <printf@plt>
movsd  -0x50(%r14),%xmm0
mov    %r15,%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    %r13d,%ecx
mov    %ebx,%r8d
mov    $0x1,%r9d
call   1030 <printf@plt>
movsd  -0x48(%r14),%xmm0
mov    %r15,%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    %r13d,%ecx
mov    %ebx,%r8d
mov    $0x2,%r9d
call   1030 <printf@plt>
movsd  -0x40(%r14),%xmm0
mov    %r15,%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    %r13d,%ecx
mov    %ebx,%r8d
mov    $0x3,%r9d
call   1030 <printf@plt>
movsd  -0x38(%r14),%xmm0
mov    %r15,%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    %r13d,%ecx
mov    %ebx,%r8d
mov    $0x4,%r9d
call   1030 <printf@plt>
movsd  -0x30(%r14),%xmm0
mov    %r15,%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    %r13d,%ecx
mov    %ebx,%r8d
mov    $0x5,%r9d
call   1030 <printf@plt>
movsd  -0x28(%r14),%xmm0
mov    %r15,%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    %r13d,%ecx
mov    %ebx,%r8d
mov    $0x6,%r9d
call   1030 <printf@plt>
movsd  -0x20(%r14),%xmm0
mov    %r15,%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    %r13d,%ecx
mov    %ebx,%r8d
mov    $0x7,%r9d
call   1030 <printf@plt>
movsd  -0x18(%r14),%xmm0
mov    %r15,%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    %r13d,%ecx
mov    %ebx,%r8d
mov    $0x8,%r9d
call   1030 <printf@plt>
movsd  -0x10(%r14),%xmm0
mov    %r15,%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    %r13d,%ecx
mov    %ebx,%r8d
mov    $0x9,%r9d
call   1030 <printf@plt>
movsd  -0x8(%r14),%xmm0
mov    %r15,%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    %r13d,%ecx
mov    %ebx,%r8d
mov    $0xa,%r9d
call   1030 <printf@plt>
movsd  (%r14),%xmm0
mov    %r15,%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    %r13d,%ecx
mov    %ebx,%r8d
mov    $0xb,%r9d
call   1030 <printf@plt>
add    $0x1,%rbx
add    $0x60,%r14
cmp    $0xa,%rbx
jne    1940 <test_dist_y+0x830>
add    $0x1,%r13
add    $0x3c0,%rbp
cmp    (%rsp),%r13
jne    1930 <test_dist_y+0x820>
jmp    1900 <test_dist_y+0x7f0>
mov    0x18(%rsp),%rax
mov    0x10(%rsp),%rcx
add    %rcx,%rax
add    $0x58,%rax
mov    %rax,(%rsp)
xor    %r15d,%r15d
lea    0x511(%rip),%r14
jmp    1b46 <test_dist_y+0xa36>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r15
addq   $0x1e00,(%rsp)
cmp    $0x6,%r15
je     1d25 <test_dist_y+0xc15>
mov    0x78(%rsp),%eax
cmp    $0xfffffffd,%eax
jl     1b30 <test_dist_y+0xa20>
mov    (%rsp),%r13
mov    0x20(%rsp),%r12
nopl   0x0(%rax,%rax,1)
mov    %r13,%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x58(%rbp),%xmm0
mov    %r14,%rdi
mov    $0x2,%esi
mov    %r15d,%edx
mov    %r12d,%ecx
mov    %ebx,%r8d
xor    %r9d,%r9d
call   1030 <printf@plt>
movsd  -0x50(%rbp),%xmm0
mov    %r14,%rdi
mov    $0x2,%esi
mov    %r15d,%edx
mov    %r12d,%ecx
mov    %ebx,%r8d
mov    $0x1,%r9d
call   1030 <printf@plt>
movsd  -0x48(%rbp),%xmm0
mov    %r14,%rdi
mov    $0x2,%esi
mov    %r15d,%edx
mov    %r12d,%ecx
mov    %ebx,%r8d
mov    $0x2,%r9d
call   1030 <printf@plt>
movsd  -0x40(%rbp),%xmm0
mov    %r14,%rdi
mov    $0x2,%esi
mov    %r15d,%edx
mov    %r12d,%ecx
mov    %ebx,%r8d
mov    $0x3,%r9d
call   1030 <printf@plt>
movsd  -0x38(%rbp),%xmm0
mov    %r14,%rdi
mov    $0x2,%esi
mov    %r15d,%edx
mov    %r12d,%ecx
mov    %ebx,%r8d
mov    $0x4,%r9d
call   1030 <printf@plt>
movsd  -0x30(%rbp),%xmm0
mov    %r14,%rdi
mov    $0x2,%esi
mov    %r15d,%edx
mov    %r12d,%ecx
mov    %ebx,%r8d
mov    $0x5,%r9d
call   1030 <printf@plt>
movsd  -0x28(%rbp),%xmm0
mov    %r14,%rdi
mov    $0x2,%esi
mov    %r15d,%edx
mov    %r12d,%ecx
mov    %ebx,%r8d
mov    $0x6,%r9d
call   1030 <printf@plt>
movsd  -0x20(%rbp),%xmm0
mov    %r14,%rdi
mov    $0x2,%esi
mov    %r15d,%edx
mov    %r12d,%ecx
mov    %ebx,%r8d
mov    $0x7,%r9d
call   1030 <printf@plt>
movsd  -0x18(%rbp),%xmm0
mov    %r14,%rdi
mov    $0x2,%esi
mov    %r15d,%edx
mov    %r12d,%ecx
mov    %ebx,%r8d
mov    $0x8,%r9d
call   1030 <printf@plt>
movsd  -0x10(%rbp),%xmm0
mov    %r14,%rdi
mov    $0x2,%esi
mov    %r15d,%edx
mov    %r12d,%ecx
mov    %ebx,%r8d
mov    $0x9,%r9d
call   1030 <printf@plt>
movsd  -0x8(%rbp),%xmm0
mov    %r14,%rdi
mov    $0x2,%esi
mov    %r15d,%edx
mov    %r12d,%ecx
mov    %ebx,%r8d
mov    $0xa,%r9d
call   1030 <printf@plt>
movsd  0x0(%rbp),%xmm0
mov    %r14,%rdi
mov    $0x2,%esi
mov    %r15d,%edx
mov    %r12d,%ecx
mov    %ebx,%r8d
mov    $0xb,%r9d
call   1030 <printf@plt>
add    $0x1,%rbx
add    $0x60,%rbp
cmp    $0xa,%rbx
jne    1b70 <test_dist_y+0xa60>
add    $0x1,%r12
add    $0x3c0,%r13
cmp    $0x8,%r12d
jne    1b60 <test_dist_y+0xa50>
jmp    1b30 <test_dist_y+0xa20>
mov    $0x1,%eax
jmp    1d2e <test_dist_y+0xc1e>
xor    %eax,%eax
add    $0x28,%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_y([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 = load i32, i32* %23
%36 = add nsw i32 4, %35
%37 = icmp slt i32 %34, %36
br i1 %37, label %38, label %71
38: ; preds = %33
store i32 0, i32* %25
br label %39
39: ; preds = %64, %38
%40 = load i32, i32* %25
%41 = icmp slt i32 %40, 10
br i1 %41, label %42, label %67
42: ; preds = %39
store i32 0, i32* %24
br label %43
43: ; preds = %60, %42
%44 = load i32, i32* %24
%45 = icmp slt i32 %44, 12
br i1 %45, label %46, label %63
46: ; preds = %43
%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 %43
63: ; preds = %43
br label %64
64: ; preds = %63
%65 = load i32, i32* %25
%66 = add nsw i32 %65, 1
store i32 %66, i32* %25
br label %39
67: ; preds = %39
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
%80 = load i32, i32* %22
%81 = sub nsw i32 4, %80
store i32 %81, i32* %26
br label %82
82: ; preds = %115, %79
%83 = load i32, i32* %26
%84 = icmp slt i32 %83, 8
br i1 %84, label %85, label %118
85: ; preds = %82
store i32 0, i32* %25
br label %86
86: ; preds = %111, %85
%87 = load i32, i32* %25
%88 = icmp slt i32 %87, 10
br i1 %88, label %89, label %114
89: ; preds = %86
store i32 0, i32* %24
br label %90
90: ; preds = %107, %89
%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 %86
114: ; preds = %86
br label %115
115: ; preds = %114
%116 = load i32, i32* %26
%117 = add nsw i32 %116, 1
store i32 %117, i32* %26
br label %82
118: ; preds = %82
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 = load i32, i32* %23
%130 = add nsw i32 4, %129
%131 = icmp slt i32 %128, %130
br i1 %131, label %132, label %198
132: ; preds = %127
store i32 0, i32* %25
br label %133
133: ; preds = %191, %132
%134 = load i32, i32* %25
%135 = icmp slt i32 %134, 10
br i1 %135, label %136, label %194
136: ; preds = %133
store i32 0, i32* %24
br label %137
137: ; preds = %187, %136
%138 = load i32, i32* %24
%139 = icmp slt i32 %138, 12
br i1 %139, label %140, label %190
140: ; preds = %137
%141 = load i32, i32* %26
%142 = icmp sle i32 0, %141
br i1 %142, label %143, label %166
143: ; preds = %140
%144 = load i32, i32* %26
%145 = icmp slt i32 %144, 4
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 %137
190: ; preds = %137
br label %191
191: ; preds = %190
%192 = load i32, i32* %25
%193 = add nsw i32 %192, 1
store i32 %193, i32* %25
br label %133
194: ; preds = %133
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
%207 = load i32, i32* %22
%208 = sub nsw i32 4, %207
store i32 %208, i32* %26
br label %209
209: ; preds = %275, %206
%210 = load i32, i32* %26
%211 = icmp slt i32 %210, 8
br i1 %211, label %212, label %278
212: ; preds = %209
store i32 0, i32* %25
br label %213
213: ; preds = %271, %212
%214 = load i32, i32* %25
%215 = icmp slt i32 %214, 10
br i1 %215, label %216, label %274
216: ; preds = %213
store i32 0, i32* %24
br label %217
217: ; preds = %267, %216
%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* %26
%222 = icmp sle i32 4, %221
br i1 %222, label %223, label %246
223: ; preds = %220
%224 = load i32, i32* %26
%225 = icmp slt i32 %224, 8
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 %213
274: ; preds = %213
br label %275
275: ; preds = %274
%276 = load i32, i32* %26
%277 = add nsw i32 %276, 1
store i32 %277, i32* %26
br label %209
278: ; preds = %209
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 = load i32, i32* %23
%294 = add nsw i32 4, %293
%295 = icmp slt i32 %292, %294
br i1 %295, label %296, label %335
296: ; preds = %291
store i32 0, i32* %25
br label %297
297: ; preds = %328, %296
%298 = load i32, i32* %25
%299 = icmp slt i32 %298, 10
br i1 %299, label %300, label %331
300: ; preds = %297
store i32 0, i32* %24
br label %301
301: ; preds = %324, %300
%302 = load i32, i32* %24
%303 = icmp slt i32 %302, 12
br i1 %303, label %304, label %327
304: ; preds = %301
%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 %301
327: ; preds = %301
br label %328
328: ; preds = %327
%329 = load i32, i32* %25
%330 = add nsw i32 %329, 1
store i32 %330, i32* %25
br label %297
331: ; preds = %297
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
%344 = load i32, i32* %22
%345 = sub nsw i32 4, %344
store i32 %345, i32* %26
br label %346
346: ; preds = %385, %343
%347 = load i32, i32* %26
%348 = icmp slt i32 %347, 8
br i1 %348, label %349, label %388
349: ; preds = %346
store i32 0, i32* %25
br label %350
350: ; preds = %381, %349
%351 = load i32, i32* %25
%352 = icmp slt i32 %351, 10
br i1 %352, label %353, label %384
353: ; preds = %350
store i32 0, i32* %24
br label %354
354: ; preds = %377, %353
%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 %350
384: ; preds = %350
br label %385
385: ; preds = %384
%386 = load i32, i32* %26
%387 = add nsw i32 %386, 1
store i32 %387, i32* %26
br label %346
388: ; preds = %346
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_y([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, -4
%13 = add i32 %10, 3
%14 = call i32 @llvm.smax.i32(i32 %13, i32 0)
%15 = add nuw i32 %14, 1
%16 = zext i32 %15 to i64
br label %17
17: ; preds = %11, %147
%18 = phi i64 [ 0, %11 ], [ %148, %147 ]
br i1 %12, label %23, label %147
19: ; preds = %147
%20 = sub i32 4, %9
%21 = icmp sgt i32 %9, -4
%22 = sext i32 %20 to i64
br label %152
23: ; preds = %17, %23
%24 = phi i64 [ %145, %23 ], [ 0, %17 ]
%25 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 0, i64 0
%26 = bitcast double* %25 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %26
%27 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 0, i64 2
%28 = bitcast double* %27 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %28
%29 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 0, i64 4
%30 = bitcast double* %29 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %30
%31 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 0, i64 6
%32 = bitcast double* %31 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %32
%33 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 0, i64 8
%34 = bitcast double* %33 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %34
%35 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 0, i64 10
%36 = bitcast double* %35 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %36
%37 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 1, i64 0
%38 = bitcast double* %37 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %38
%39 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 1, i64 2
%40 = bitcast double* %39 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %40
%41 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 1, i64 4
%42 = bitcast double* %41 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %42
%43 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 1, i64 6
%44 = bitcast double* %43 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %44
%45 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 1, i64 8
%46 = bitcast double* %45 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %46
%47 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 1, i64 10
%48 = bitcast double* %47 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %48
%49 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 2, i64 0
%50 = bitcast double* %49 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %50
%51 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 2, i64 2
%52 = bitcast double* %51 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %52
%53 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 2, i64 4
%54 = bitcast double* %53 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %54
%55 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 2, i64 6
%56 = bitcast double* %55 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %56
%57 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 2, i64 8
%58 = bitcast double* %57 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %58
%59 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 2, i64 10
%60 = bitcast double* %59 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %60
%61 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 3, i64 0
%62 = bitcast double* %61 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %62
%63 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 3, i64 2
%64 = bitcast double* %63 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %64
%65 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 3, i64 4
%66 = bitcast double* %65 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %66
%67 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 3, i64 6
%68 = bitcast double* %67 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %68
%69 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 3, i64 8
%70 = bitcast double* %69 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %70
%71 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 3, i64 10
%72 = bitcast double* %71 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %72
%73 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 4, i64 0
%74 = bitcast double* %73 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %74
%75 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 4, i64 2
%76 = bitcast double* %75 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %76
%77 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 4, i64 4
%78 = bitcast double* %77 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %78
%79 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 4, i64 6
%80 = bitcast double* %79 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %80
%81 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 4, i64 8
%82 = bitcast double* %81 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %82
%83 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 4, i64 10
%84 = bitcast double* %83 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %84
%85 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 5, i64 0
%86 = bitcast double* %85 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %86
%87 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 5, i64 2
%88 = bitcast double* %87 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %88
%89 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 5, i64 4
%90 = bitcast double* %89 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %90
%91 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 5, i64 6
%92 = bitcast double* %91 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %92
%93 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 5, i64 8
%94 = bitcast double* %93 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %94
%95 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 5, i64 10
%96 = bitcast double* %95 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %96
%97 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 6, i64 0
%98 = bitcast double* %97 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %98
%99 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 6, i64 2
%100 = bitcast double* %99 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %100
%101 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 6, i64 4
%102 = bitcast double* %101 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %102
%103 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 6, i64 6
%104 = bitcast double* %103 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %104
%105 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 6, i64 8
%106 = bitcast double* %105 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %106
%107 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 6, i64 10
%108 = bitcast double* %107 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %108
%109 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 7, i64 0
%110 = bitcast double* %109 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %110
%111 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 7, i64 2
%112 = bitcast double* %111 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %112
%113 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 7, i64 4
%114 = bitcast double* %113 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %114
%115 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 7, i64 6
%116 = bitcast double* %115 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %116
%117 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 7, i64 8
%118 = bitcast double* %117 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %118
%119 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 7, i64 10
%120 = bitcast double* %119 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %120
%121 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 8, i64 0
%122 = bitcast double* %121 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %122
%123 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 8, i64 2
%124 = bitcast double* %123 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %124
%125 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 8, i64 4
%126 = bitcast double* %125 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %126
%127 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 8, i64 6
%128 = bitcast double* %127 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %128
%129 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 8, i64 8
%130 = bitcast double* %129 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %130
%131 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 8, i64 10
%132 = bitcast double* %131 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %132
%133 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 9, i64 0
%134 = bitcast double* %133 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %134
%135 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 9, i64 2
%136 = bitcast double* %135 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %136
%137 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 9, i64 4
%138 = bitcast double* %137 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %138
%139 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 9, i64 6
%140 = bitcast double* %139 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %140
%141 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 9, i64 8
%142 = bitcast double* %141 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %142
%143 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %18, i64 %24, i64 9, i64 10
%144 = bitcast double* %143 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %144
%145 = add nuw nsw i64 %24, 1
%146 = icmp eq i64 %145, %16
br i1 %146, label %147, label %23
147: ; preds = %23, %17
%148 = add nuw nsw i64 %18, 1
%149 = icmp eq i64 %148, 6
br i1 %149, label %19, label %17
150: ; preds = %279
%151 = zext i32 %15 to i64
br label %282
152: ; preds = %19, %279
%153 = phi i64 [ 0, %19 ], [ %280, %279 ]
br i1 %21, label %154, label %279
154: ; preds = %152, %154
%155 = phi i64 [ %276, %154 ], [ %22, %152 ]
%156 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 0, i64 0
%157 = bitcast double* %156 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %157
%158 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 0, i64 2
%159 = bitcast double* %158 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %159
%160 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 0, i64 4
%161 = bitcast double* %160 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %161
%162 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 0, i64 6
%163 = bitcast double* %162 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %163
%164 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 0, i64 8
%165 = bitcast double* %164 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %165
%166 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 0, i64 10
%167 = bitcast double* %166 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %167
%168 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 1, i64 0
%169 = bitcast double* %168 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %169
%170 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 1, i64 2
%171 = bitcast double* %170 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %171
%172 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 1, i64 4
%173 = bitcast double* %172 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %173
%174 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 1, i64 6
%175 = bitcast double* %174 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %175
%176 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 1, i64 8
%177 = bitcast double* %176 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %177
%178 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 1, i64 10
%179 = bitcast double* %178 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %179
%180 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 2, i64 0
%181 = bitcast double* %180 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %181
%182 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 2, i64 2
%183 = bitcast double* %182 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %183
%184 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 2, i64 4
%185 = bitcast double* %184 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %185
%186 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 2, i64 6
%187 = bitcast double* %186 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %187
%188 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 2, i64 8
%189 = bitcast double* %188 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %189
%190 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 2, i64 10
%191 = bitcast double* %190 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %191
%192 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 3, i64 0
%193 = bitcast double* %192 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %193
%194 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 3, i64 2
%195 = bitcast double* %194 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %195
%196 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 3, i64 4
%197 = bitcast double* %196 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %197
%198 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 3, i64 6
%199 = bitcast double* %198 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %199
%200 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 3, i64 8
%201 = bitcast double* %200 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %201
%202 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 3, i64 10
%203 = bitcast double* %202 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %203
%204 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 4, i64 0
%205 = bitcast double* %204 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %205
%206 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 4, i64 2
%207 = bitcast double* %206 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %207
%208 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 4, i64 4
%209 = bitcast double* %208 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %209
%210 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 4, i64 6
%211 = bitcast double* %210 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %211
%212 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 4, i64 8
%213 = bitcast double* %212 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %213
%214 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 4, i64 10
%215 = bitcast double* %214 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %215
%216 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 5, i64 0
%217 = bitcast double* %216 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %217
%218 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 5, i64 2
%219 = bitcast double* %218 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %219
%220 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 5, i64 4
%221 = bitcast double* %220 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %221
%222 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 5, i64 6
%223 = bitcast double* %222 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %223
%224 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 5, i64 8
%225 = bitcast double* %224 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %225
%226 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 5, i64 10
%227 = bitcast double* %226 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %227
%228 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 6, i64 0
%229 = bitcast double* %228 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %229
%230 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 6, i64 2
%231 = bitcast double* %230 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %231
%232 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 6, i64 4
%233 = bitcast double* %232 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %233
%234 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 6, i64 6
%235 = bitcast double* %234 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %235
%236 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 6, i64 8
%237 = bitcast double* %236 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %237
%238 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 6, i64 10
%239 = bitcast double* %238 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %239
%240 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 7, i64 0
%241 = bitcast double* %240 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %241
%242 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 7, i64 2
%243 = bitcast double* %242 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %243
%244 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 7, i64 4
%245 = bitcast double* %244 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %245
%246 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 7, i64 6
%247 = bitcast double* %246 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %247
%248 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 7, i64 8
%249 = bitcast double* %248 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %249
%250 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 7, i64 10
%251 = bitcast double* %250 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %251
%252 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 8, i64 0
%253 = bitcast double* %252 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %253
%254 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 8, i64 2
%255 = bitcast double* %254 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %255
%256 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 8, i64 4
%257 = bitcast double* %256 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %257
%258 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 8, i64 6
%259 = bitcast double* %258 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %259
%260 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 8, i64 8
%261 = bitcast double* %260 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %261
%262 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 8, i64 10
%263 = bitcast double* %262 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %263
%264 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 9, i64 0
%265 = bitcast double* %264 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %265
%266 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 9, i64 2
%267 = bitcast double* %266 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %267
%268 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 9, i64 4
%269 = bitcast double* %268 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %269
%270 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 9, i64 6
%271 = bitcast double* %270 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %271
%272 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 9, i64 8
%273 = bitcast double* %272 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %273
%274 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %153, i64 %155, i64 9, i64 10
%275 = bitcast double* %274 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %275
%276 = add nsw i64 %155, 1
%277 = trunc i64 %276 to i32
%278 = icmp eq i32 %277, 8
br i1 %278, label %279, label %154
279: ; preds = %154, %152
%280 = add nuw nsw i64 %153, 1
%281 = icmp eq i64 %280, 6
br i1 %281, label %150, label %152
282: ; preds = %150, %441
%283 = phi i64 [ 0, %150 ], [ %443, %441 ]
%284 = phi i32 [ 0, %150 ], [ %442, %441 ]
br i1 %12, label %285, label %441
285: ; preds = %282, %438
%286 = phi i64 [ %439, %438 ], [ 0, %282 ]
%287 = phi i32 [ %435, %438 ], [ %284, %282 ]
%288 = icmp ult i64 %286, 4
br label %289
289: ; preds = %285, %434
%290 = phi i64 [ 0, %285 ], [ %436, %434 ]
%291 = phi i32 [ %287, %285 ], [ %435, %434 ]
%292 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %283, i64 %286, i64 %290, i64 0
%293 = load double, double* %292
br i1 %288, label %294, label %298
294: ; preds = %289
%295 = fcmp une double %293, 1.000000e+00
br i1 %295, label %296, label %302
296: ; preds = %294
%297 = add nsw i32 %291, 1
br label %302
298: ; preds = %289
%299 = fcmp une double %293, 2.000000e+00
br i1 %299, label %300, label %302
300: ; preds = %298
%301 = add nsw i32 %291, 1
br label %302
302: ; preds = %296, %294, %300, %298
%303 = phi i32 [ %297, %296 ], [ %291, %294 ], [ %301, %300 ], [ %291, %298 ]
%304 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %283, i64 %286, i64 %290, i64 1
%305 = load double, double* %304
br i1 %288, label %310, label %306
306: ; preds = %302
%307 = fcmp une double %305, 2.000000e+00
br i1 %307, label %308, label %314
308: ; preds = %306
%309 = add nsw i32 %303, 1
br label %314
310: ; preds = %302
%311 = fcmp une double %305, 1.000000e+00
br i1 %311, label %312, label %314
312: ; preds = %310
%313 = add nsw i32 %303, 1
br label %314
314: ; preds = %312, %310, %308, %306
%315 = phi i32 [ %313, %312 ], [ %303, %310 ], [ %309, %308 ], [ %303, %306 ]
%316 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %283, i64 %286, i64 %290, i64 2
%317 = load double, double* %316
br i1 %288, label %322, label %318
318: ; preds = %314
%319 = fcmp une double %317, 2.000000e+00
br i1 %319, label %320, label %326
320: ; preds = %318
%321 = add nsw i32 %315, 1
br label %326
322: ; preds = %314
%323 = fcmp une double %317, 1.000000e+00
br i1 %323, label %324, label %326
324: ; preds = %322
%325 = add nsw i32 %315, 1
br label %326
326: ; preds = %324, %322, %320, %318
%327 = phi i32 [ %325, %324 ], [ %315, %322 ], [ %321, %320 ], [ %315, %318 ]
%328 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %283, i64 %286, i64 %290, i64 3
%329 = load double, double* %328
br i1 %288, label %334, label %330
330: ; preds = %326
%331 = fcmp une double %329, 2.000000e+00
br i1 %331, label %332, label %338
332: ; preds = %330
%333 = add nsw i32 %327, 1
br label %338
334: ; preds = %326
%335 = fcmp une double %329, 1.000000e+00
br i1 %335, label %336, label %338
336: ; preds = %334
%337 = add nsw i32 %327, 1
br label %338
338: ; preds = %336, %334, %332, %330
%339 = phi i32 [ %337, %336 ], [ %327, %334 ], [ %333, %332 ], [ %327, %330 ]
%340 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %283, i64 %286, i64 %290, i64 4
%341 = load double, double* %340
br i1 %288, label %346, label %342
342: ; preds = %338
%343 = fcmp une double %341, 2.000000e+00
br i1 %343, label %344, label %350
344: ; preds = %342
%345 = add nsw i32 %339, 1
br label %350
346: ; preds = %338
%347 = fcmp une double %341, 1.000000e+00
br i1 %347, label %348, label %350
348: ; preds = %346
%349 = add nsw i32 %339, 1
br label %350
350: ; preds = %348, %346, %344, %342
%351 = phi i32 [ %349, %348 ], [ %339, %346 ], [ %345, %344 ], [ %339, %342 ]
%352 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %283, i64 %286, i64 %290, i64 5
%353 = load double, double* %352
br i1 %288, label %358, label %354
354: ; preds = %350
%355 = fcmp une double %353, 2.000000e+00
br i1 %355, label %356, label %362
356: ; preds = %354
%357 = add nsw i32 %351, 1
br label %362
358: ; preds = %350
%359 = fcmp une double %353, 1.000000e+00
br i1 %359, label %360, label %362
360: ; preds = %358
%361 = add nsw i32 %351, 1
br label %362
362: ; preds = %360, %358, %356, %354
%363 = phi i32 [ %361, %360 ], [ %351, %358 ], [ %357, %356 ], [ %351, %354 ]
%364 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %283, i64 %286, i64 %290, i64 6
%365 = load double, double* %364
br i1 %288, label %370, label %366
366: ; preds = %362
%367 = fcmp une double %365, 2.000000e+00
br i1 %367, label %368, label %374
368: ; preds = %366
%369 = add nsw i32 %363, 1
br label %374
370: ; preds = %362
%371 = fcmp une double %365, 1.000000e+00
br i1 %371, label %372, label %374
372: ; preds = %370
%373 = add nsw i32 %363, 1
br label %374
374: ; preds = %372, %370, %368, %366
%375 = phi i32 [ %373, %372 ], [ %363, %370 ], [ %369, %368 ], [ %363, %366 ]
%376 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %283, i64 %286, i64 %290, i64 7
%377 = load double, double* %376
br i1 %288, label %382, label %378
378: ; preds = %374
%379 = fcmp une double %377, 2.000000e+00
br i1 %379, label %380, label %386
380: ; preds = %378
%381 = add nsw i32 %375, 1
br label %386
382: ; preds = %374
%383 = fcmp une double %377, 1.000000e+00
br i1 %383, label %384, label %386
384: ; preds = %382
%385 = add nsw i32 %375, 1
br label %386
386: ; preds = %384, %382, %380, %378
%387 = phi i32 [ %385, %384 ], [ %375, %382 ], [ %381, %380 ], [ %375, %378 ]
%388 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %283, i64 %286, i64 %290, i64 8
%389 = load double, double* %388
br i1 %288, label %394, label %390
390: ; preds = %386
%391 = fcmp une double %389, 2.000000e+00
br i1 %391, label %392, label %398
392: ; preds = %390
%393 = add nsw i32 %387, 1
br label %398
394: ; preds = %386
%395 = fcmp une double %389, 1.000000e+00
br i1 %395, label %396, label %398
396: ; preds = %394
%397 = add nsw i32 %387, 1
br label %398
398: ; preds = %396, %394, %392, %390
%399 = phi i32 [ %397, %396 ], [ %387, %394 ], [ %393, %392 ], [ %387, %390 ]
%400 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %283, i64 %286, i64 %290, i64 9
%401 = load double, double* %400
br i1 %288, label %406, label %402
402: ; preds = %398
%403 = fcmp une double %401, 2.000000e+00
br i1 %403, label %404, label %410
404: ; preds = %402
%405 = add nsw i32 %399, 1
br label %410
406: ; preds = %398
%407 = fcmp une double %401, 1.000000e+00
br i1 %407, label %408, label %410
408: ; preds = %406
%409 = add nsw i32 %399, 1
br label %410
410: ; preds = %408, %406, %404, %402
%411 = phi i32 [ %409, %408 ], [ %399, %406 ], [ %405, %404 ], [ %399, %402 ]
%412 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %283, i64 %286, i64 %290, i64 10
%413 = load double, double* %412
br i1 %288, label %418, label %414
414: ; preds = %410
%415 = fcmp une double %413, 2.000000e+00
br i1 %415, label %416, label %422
416: ; preds = %414
%417 = add nsw i32 %411, 1
br label %422
418: ; preds = %410
%419 = fcmp une double %413, 1.000000e+00
br i1 %419, label %420, label %422
420: ; preds = %418
%421 = add nsw i32 %411, 1
br label %422
422: ; preds = %420, %418, %416, %414
%423 = phi i32 [ %421, %420 ], [ %411, %418 ], [ %417, %416 ], [ %411, %414 ]
%424 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %283, i64 %286, i64 %290, i64 11
%425 = load double, double* %424
br i1 %288, label %430, label %426
426: ; preds = %422
%427 = fcmp une double %425, 2.000000e+00
br i1 %427, label %428, label %434
428: ; preds = %426
%429 = add nsw i32 %423, 1
br label %434
430: ; preds = %422
%431 = fcmp une double %425, 1.000000e+00
br i1 %431, label %432, label %434
432: ; preds = %430
%433 = add nsw i32 %423, 1
br label %434
434: ; preds = %432, %430, %428, %426
%435 = phi i32 [ %433, %432 ], [ %423, %430 ], [ %429, %428 ], [ %423, %426 ]
%436 = add nuw nsw i64 %290, 1
%437 = icmp eq i64 %436, 10
br i1 %437, label %438, label %289
438: ; preds = %434
%439 = add nuw nsw i64 %286, 1
%440 = icmp eq i64 %439, %151
br i1 %440, label %441, label %285
441: ; preds = %438, %282
%442 = phi i32 [ %284, %282 ], [ %435, %438 ]
%443 = add nuw nsw i64 %283, 1
%444 = icmp eq i64 %443, 6
br i1 %444, label %445, label %282
445: ; preds = %441, %482
%446 = phi i64 [ %484, %482 ], [ 0, %441 ]
%447 = phi i32 [ %483, %482 ], [ %442, %441 ]
br i1 %21, label %448, label %482
448: ; preds = %445, %478
%449 = phi i64 [ %479, %478 ], [ %22, %445 ]
%450 = phi i32 [ %472, %478 ], [ %447, %445 ]
%451 = icmp sgt i64 %449, 3
%452 = and i64 %449, 4294967295
br label %453
453: ; preds = %448, %475
%454 = phi i64 [ 0, %448 ], [ %476, %475 ]
%455 = phi i32 [ %450, %448 ], [ %472, %475 ]
br label %456
456: ; preds = %453, %471
%457 = phi i64 [ 0, %453 ], [ %473, %471 ]
%458 = phi i32 [ %455, %453 ], [ %472, %471 ]
br i1 %451, label %459, label %465
459: ; preds = %456
%460 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %446, i64 %452, i64 %454, i64 %457
%461 = load double, double* %460
%462 = fcmp une double %461, 2.000000e+00
br i1 %462, label %463, label %471
463: ; preds = %459
%464 = add nsw i32 %458, 1
br label %471
465: ; preds = %456
%466 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %446, i64 %449, i64 %454, i64 %457
%467 = load double, double* %466
%468 = fcmp une double %467, 1.000000e+00
br i1 %468, label %469, label %471
469: ; preds = %465
%470 = add nsw i32 %458, 1
br label %471
471: ; preds = %463, %459, %469, %465
%472 = phi i32 [ %464, %463 ], [ %458, %459 ], [ %470, %469 ], [ %458, %465 ]
%473 = add nuw nsw i64 %457, 1
%474 = icmp eq i64 %473, 12
br i1 %474, label %475, label %456
475: ; preds = %471
%476 = add nuw nsw i64 %454, 1
%477 = icmp eq i64 %476, 10
br i1 %477, label %478, label %453
478: ; preds = %475
%479 = add nsw i64 %449, 1
%480 = trunc i64 %479 to i32
%481 = icmp eq i32 %480, 8
br i1 %481, label %482, label %448
482: ; preds = %478, %445
%483 = phi i32 [ %447, %445 ], [ %472, %478 ]
%484 = add nuw nsw i64 %446, 1
%485 = icmp eq i64 %484, 6
br i1 %485, label %486, label %445
486: ; preds = %482
%487 = icmp eq i32 %483, 0
br i1 %487, label %599, label %488
488: ; preds = %486
%489 = zext i32 %15 to i64
br label %490
490: ; preds = %488, %541
%491 = phi i64 [ 0, %488 ], [ %542, %541 ]
br i1 %12, label %492, label %541
492: ; preds = %490
%493 = trunc i64 %491 to i32
br label %494
494: ; preds = %492, %538
%495 = phi i64 [ 0, %492 ], [ %539, %538 ]
%496 = trunc i64 %495 to i32
br label %497
497: ; preds = %494, %497
%498 = phi i64 [ 0, %494 ], [ %536, %497 ]
%499 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %491, i64 %495, i64 %498, i64 0
%500 = load double, double* %499
%501 = trunc i64 %498 to i32
%502 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 1, i32 %493, i32 %496, i32 %501, i32 0, double %500)
%503 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %491, i64 %495, i64 %498, i64 1
%504 = load double, double* %503
%505 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 1, i32 %493, i32 %496, i32 %501, i32 1, double %504)
%506 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %491, i64 %495, i64 %498, i64 2
%507 = load double, double* %506
%508 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 1, i32 %493, i32 %496, i32 %501, i32 2, double %507)
%509 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %491, i64 %495, i64 %498, i64 3
%510 = load double, double* %509
%511 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 1, i32 %493, i32 %496, i32 %501, i32 3, double %510)
%512 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %491, i64 %495, i64 %498, i64 4
%513 = load double, double* %512
%514 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 1, i32 %493, i32 %496, i32 %501, i32 4, double %513)
%515 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %491, i64 %495, i64 %498, i64 5
%516 = load double, double* %515
%517 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 1, i32 %493, i32 %496, i32 %501, i32 5, double %516)
%518 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %491, i64 %495, i64 %498, i64 6
%519 = load double, double* %518
%520 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 1, i32 %493, i32 %496, i32 %501, i32 6, double %519)
%521 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %491, i64 %495, i64 %498, i64 7
%522 = load double, double* %521
%523 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 1, i32 %493, i32 %496, i32 %501, i32 7, double %522)
%524 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %491, i64 %495, i64 %498, i64 8
%525 = load double, double* %524
%526 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 1, i32 %493, i32 %496, i32 %501, i32 8, double %525)
%527 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %491, i64 %495, i64 %498, i64 9
%528 = load double, double* %527
%529 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 1, i32 %493, i32 %496, i32 %501, i32 9, double %528)
%530 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %491, i64 %495, i64 %498, i64 10
%531 = load double, double* %530
%532 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 1, i32 %493, i32 %496, i32 %501, i32 10, double %531)
%533 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %491, i64 %495, i64 %498, i64 11
%534 = load double, double* %533
%535 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 1, i32 %493, i32 %496, i32 %501, i32 11, double %534)
%536 = add nuw nsw i64 %498, 1
%537 = icmp eq i64 %536, 10
br i1 %537, label %538, label %497
538: ; preds = %497
%539 = add nuw nsw i64 %495, 1
%540 = icmp eq i64 %539, %489
br i1 %540, label %541, label %494
541: ; preds = %538, %490
%542 = add nuw nsw i64 %491, 1
%543 = icmp eq i64 %542, 6
br i1 %543, label %544, label %490
544: ; preds = %541, %596
%545 = phi i64 [ %597, %596 ], [ 0, %541 ]
br i1 %21, label %546, label %596
546: ; preds = %544
%547 = trunc i64 %545 to i32
br label %548
548: ; preds = %546, %592
%549 = phi i64 [ %22, %546 ], [ %593, %592 ]
%550 = trunc i64 %549 to i32
br label %551
551: ; preds = %548, %551
%552 = phi i64 [ 0, %548 ], [ %590, %551 ]
%553 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %545, i64 %549, i64 %552, i64 0
%554 = load double, double* %553
%555 = trunc i64 %552 to i32
%556 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 2, i32 %547, i32 %550, i32 %555, i32 0, double %554)
%557 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %545, i64 %549, i64 %552, i64 1
%558 = load double, double* %557
%559 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 2, i32 %547, i32 %550, i32 %555, i32 1, double %558)
%560 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %545, i64 %549, i64 %552, i64 2
%561 = load double, double* %560
%562 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 2, i32 %547, i32 %550, i32 %555, i32 2, double %561)
%563 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %545, i64 %549, i64 %552, i64 3
%564 = load double, double* %563
%565 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 2, i32 %547, i32 %550, i32 %555, i32 3, double %564)
%566 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %545, i64 %549, i64 %552, i64 4
%567 = load double, double* %566
%568 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 2, i32 %547, i32 %550, i32 %555, i32 4, double %567)
%569 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %545, i64 %549, i64 %552, i64 5
%570 = load double, double* %569
%571 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 2, i32 %547, i32 %550, i32 %555, i32 5, double %570)
%572 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %545, i64 %549, i64 %552, i64 6
%573 = load double, double* %572
%574 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 2, i32 %547, i32 %550, i32 %555, i32 6, double %573)
%575 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %545, i64 %549, i64 %552, i64 7
%576 = load double, double* %575
%577 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 2, i32 %547, i32 %550, i32 %555, i32 7, double %576)
%578 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %545, i64 %549, i64 %552, i64 8
%579 = load double, double* %578
%580 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 2, i32 %547, i32 %550, i32 %555, i32 8, double %579)
%581 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %545, i64 %549, i64 %552, i64 9
%582 = load double, double* %581
%583 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 2, i32 %547, i32 %550, i32 %555, i32 9, double %582)
%584 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %545, i64 %549, i64 %552, i64 10
%585 = load double, double* %584
%586 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 2, i32 %547, i32 %550, i32 %555, i32 10, double %585)
%587 = getelementptr inbounds [8 x [10 x [12 x double]]], [8 x [10 x [12 x double]]]* %0, i64 %545, i64 %549, i64 %552, i64 11
%588 = load double, double* %587
%589 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 2, i32 %547, i32 %550, i32 %555, i32 11, double %588)
%590 = add nuw nsw i64 %552, 1
%591 = icmp eq i64 %590, 10
br i1 %591, label %592, label %551
592: ; preds = %551
%593 = add nsw i64 %549, 1
%594 = trunc i64 %593 to i32
%595 = icmp eq i32 %594, 8
br i1 %595, label %596, label %548
596: ; preds = %592, %544
%597 = add nuw nsw i64 %545, 1
%598 = icmp eq i64 %597, 6
br i1 %598, label %599, label %544
599: ; preds = %596, %486
%600 = phi i32 [ 0, %486 ], [ 1, %596 ]
ret i32 %600
}