#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*/ abort();
int /*<<< orphan*/ free(float *);
scalar_t__ malloc(int);
int main(int argc, char **argv) {
  int N = 128;
  float *a, *b, *c, *d, *e;
  int i;
  int nbytes;
  nbytes = N * sizeof(float);
  a = (float *)malloc(nbytes);
  b = (float *)malloc(nbytes);
  c = (float *)malloc(nbytes);
  d = (float *)malloc(nbytes);
  e = (float *)malloc(nbytes);
  for (i = 0; i < N; i++) {
    a[i] = 3.0;
    b[i] = 0.0;
  }
#pragma acc enter data copyin(a [0:N]) copyin(b [0:N]) copyin(N) async
#pragma acc parallel present(a [0:N], b [0:N]) async wait
#pragma acc loop
  for (i = 0; i < N; i++)
    b[i] = a[i];
#pragma acc update host(a [0:N], b [0:N]) async wait
#pragma acc wait
  for (i = 0; i < N; i++) {
    if (a[i] != 3.0)
      abort();
    if (b[i] != 3.0)
      abort();
  }
  for (i = 0; i < N; i++) {
    a[i] = 2.0;
    b[i] = 0.0;
  }
#pragma acc update device(a [0:N], b [0:N]) async(1)
#pragma acc parallel present(a [0:N], b [0:N]) async(1)
#pragma acc loop
  for (i = 0; i < N; i++)
    b[i] = a[i];
#pragma acc update host(a [0:N], b [0:N]) async(1) wait(1)
#pragma acc wait(1)
  for (i = 0; i < N; i++) {
    if (a[i] != 2.0)
      abort();
    if (b[i] != 2.0)
      abort();
  }
  for (i = 0; i < N; i++) {
    a[i] = 3.0;
    b[i] = 0.0;
    c[i] = 0.0;
    d[i] = 0.0;
  }
#pragma acc update device(a [0:N]) async(1)
#pragma acc update device(b [0:N]) async(2)
#pragma acc enter data copyin(c [0:N], d [0:N]) async(3)
#pragma acc parallel present(a [0:N], b [0:N]) async(1) wait(1, 2)
#pragma acc loop
  for (i = 0; i < N; i++)
    b[i] = (a[i] * a[i] * a[i]) / a[i];
#pragma acc parallel present(a [0:N], c [0:N]) async(2) wait(1, 3)
#pragma acc loop
  for (i = 0; i < N; i++)
    c[i] = (a[i] + a[i] + a[i] + a[i]) / a[i];
#pragma acc parallel present(a [0:N], d [0:N]) async(3) wait(1, 3)
#pragma acc loop
  for (i = 0; i < N; i++)
    d[i] = ((a[i] * a[i] + a[i]) / a[i]) - a[i];
#pragma acc update host(a [0:N], b [0:N], c [0:N], d [0:N]) async(1)           \
    wait(1, 2, 3)
#pragma acc wait(1)
  for (i = 0; i < N; i++) {
    if (a[i] != 3.0)
      abort();
    if (b[i] != 9.0)
      abort();
    if (c[i] != 4.0)
      abort();
    if (d[i] != 1.0)
      abort();
  }
  for (i = 0; i < N; i++) {
    a[i] = 2.0;
    b[i] = 0.0;
    c[i] = 0.0;
    d[i] = 0.0;
    e[i] = 0.0;
  }
#pragma acc update device(a [0:N], b [0:N], c [0:N], d [0:N]) async(1)
#pragma acc enter data copyin(e [0:N]) async(5)
#pragma acc parallel present(a [0:N], b [0:N]) async(1) wait(1)
  for (int ii = 0; ii < N; ii++)
    b[ii] = (a[ii] * a[ii] * a[ii]) / a[ii];
#pragma acc parallel present(a [0:N], c [0:N]) async(2) wait(1)
  for (int ii = 0; ii < N; ii++)
    c[ii] = (a[ii] + a[ii] + a[ii] + a[ii]) / a[ii];
#pragma acc parallel present(a [0:N], d [0:N]) async(3) wait(1)
  for (int ii = 0; ii < N; ii++)
    d[ii] = ((a[ii] * a[ii] + a[ii]) / a[ii]) - a[ii];
#pragma acc parallel present(a [0:N], b [0:N], c [0:N], d [0:N], e [0:N])      \
    wait(1, 5) async(4)
  for (int ii = 0; ii < N; ii++)
    e[ii] = a[ii] + b[ii] + c[ii] + d[ii];
#pragma acc exit data copyout(a [0:N]) copyout(b [0:N]) copyout(c [0:N])       \
    copyout(d [0:N]) copyout(e [0:N]) wait(1, 2, 3, 4) async(1)
#pragma acc exit data delete (N)
#pragma acc wait(1)
  for (i = 0; i < N; i++) {
    if (a[i] != 2.0)
      abort();
    if (b[i] != 4.0)
      abort();
    if (c[i] != 4.0)
      abort();
    if (d[i] != 1.0)
      abort();
    if (e[i] != 11.0)
      abort();
  }
  free(a);
  free(b);
  free(c);
  free(d);
  free(e);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x80,-0x14(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%edi
call   1050 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x48(%rbp),%edi
call   1050 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x48(%rbp),%edi
call   1050 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x48(%rbp),%edi
call   1050 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x48(%rbp),%edi
call   1050 <malloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11da <main+0xaa>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  0xe7d(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    119b <main+0x6b>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1215 <main+0xe5>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11e1 <main+0xb1>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12a5 <main+0x175>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xddf(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1256 <main+0x126>
jp     1256 <main+0x126>
jmp    125d <main+0x12d>
mov    $0x0,%al
call   1040 <abort@plt>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdaa(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    128b <main+0x15b>
jp     128b <main+0x15b>
jmp    1292 <main+0x162>
mov    $0x0,%al
call   1040 <abort@plt>
jmp    1297 <main+0x167>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    121c <main+0xec>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12eb <main+0x1bb>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  0xd68(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12ac <main+0x17c>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1326 <main+0x1f6>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12f2 <main+0x1c2>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13b6 <main+0x286>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xcae(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1367 <main+0x237>
jp     1367 <main+0x237>
jmp    136e <main+0x23e>
mov    $0x0,%al
call   1040 <abort@plt>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc79(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    139c <main+0x26c>
jp     139c <main+0x26c>
jmp    13a3 <main+0x273>
mov    $0x0,%al
call   1040 <abort@plt>
jmp    13a8 <main+0x278>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    132d <main+0x1fd>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    141c <main+0x2ec>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  0xc5b(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    13bd <main+0x28d>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    147e <main+0x34e>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1423 <main+0x2f3>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14ed <main+0x3bd>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1485 <main+0x355>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1564 <main+0x434>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    14f4 <main+0x3c4>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    165e <main+0x52e>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xa90(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    15a5 <main+0x475>
jp     15a5 <main+0x475>
jmp    15ac <main+0x47c>
mov    $0x0,%al
call   1040 <abort@plt>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xa63(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    15da <main+0x4aa>
jp     15da <main+0x4aa>
jmp    15e1 <main+0x4b1>
mov    $0x0,%al
call   1040 <abort@plt>
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xa0e(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    160f <main+0x4df>
jp     160f <main+0x4df>
jmp    1616 <main+0x4e6>
mov    $0x0,%al
call   1040 <abort@plt>
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x9e1(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1644 <main+0x514>
jp     1644 <main+0x514>
jmp    164b <main+0x51b>
mov    $0x0,%al
call   1040 <abort@plt>
jmp    1650 <main+0x520>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    156b <main+0x43b>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    16d4 <main+0x5a4>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  0x9af(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1665 <main+0x535>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1736 <main+0x606>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    16db <main+0x5ab>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    17a5 <main+0x675>
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    173d <main+0x60d>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    181c <main+0x6ec>
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    17ac <main+0x67c>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    187e <main+0x74e>
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x58(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x58(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x58(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1823 <main+0x6f3>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    19ad <main+0x87d>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x756(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    18bf <main+0x78f>
jp     18bf <main+0x78f>
jmp    18c6 <main+0x796>
mov    $0x0,%al
call   1040 <abort@plt>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x729(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    18f4 <main+0x7c4>
jp     18f4 <main+0x7c4>
jmp    18fb <main+0x7cb>
mov    $0x0,%al
call   1040 <abort@plt>
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x6f4(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1929 <main+0x7f9>
jp     1929 <main+0x7f9>
jmp    1930 <main+0x800>
mov    $0x0,%al
call   1040 <abort@plt>
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x6c7(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    195e <main+0x82e>
jp     195e <main+0x82e>
jmp    1965 <main+0x835>
mov    $0x0,%al
call   1040 <abort@plt>
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x69a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1993 <main+0x863>
jp     1993 <main+0x863>
jmp    199a <main+0x86a>
mov    $0x0,%al
call   1040 <abort@plt>
jmp    199f <main+0x86f>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1885 <main+0x755>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    $0x200,%edi
call   1050 <malloc@plt>
mov    %rax,%rbx
mov    $0x200,%edi
call   1050 <malloc@plt>
mov    %rax,%r14
mov    $0x200,%edi
call   1050 <malloc@plt>
mov    %rax,%r15
mov    $0x200,%edi
call   1050 <malloc@plt>
mov    %rax,%r12
mov    $0x200,%edi
call   1050 <malloc@plt>
mov    %rax,%r13
lea    0x200(%rbx),%rcx
lea    0x200(%r14),%rsi
cmp    %rsi,%rbx
jae    11fc <main+0xcc>
cmp    %rcx,%r14
jae    11fc <main+0xcc>
xor    %eax,%eax
nopl   0x0(%rax)
movl   $0x40400000,(%rbx,%rax,4)
movl   $0x0,(%r14,%rax,4)
movl   $0x40400000,0x4(%rbx,%rax,4)
40
movl   $0x0,0x4(%r14,%rax,4)
movl   $0x40400000,0x8(%rbx,%rax,4)
40
movl   $0x0,0x8(%r14,%rax,4)
movl   $0x40400000,0xc(%rbx,%rax,4)
40
movl   $0x0,0xc(%r14,%rax,4)
add    $0x4,%rax
cmp    $0x80,%rax
jne    11a0 <main+0x70>
cmp    %rcx,%r14
jb     13b9 <main+0x289>
jmp    1403 <main+0x2d3>
movaps 0x1dfd(%rip),%xmm0
movups %xmm0,(%rbx)
movups %xmm0,0x10(%rbx)
xorps  %xmm1,%xmm1
movups %xmm1,(%r14)
movups %xmm1,0x10(%r14)
movups %xmm0,0x20(%rbx)
movups %xmm0,0x30(%rbx)
movups %xmm1,0x20(%r14)
movups %xmm1,0x30(%r14)
movups %xmm0,0x40(%rbx)
movups %xmm0,0x50(%rbx)
movups %xmm1,0x40(%r14)
movups %xmm1,0x50(%r14)
movups %xmm0,0x60(%rbx)
movups %xmm0,0x70(%rbx)
movups %xmm1,0x60(%r14)
movups %xmm1,0x70(%r14)
movups %xmm0,0x80(%rbx)
movups %xmm0,0x90(%rbx)
movups %xmm1,0x80(%r14)
movups %xmm1,0x90(%r14)
movups %xmm0,0xa0(%rbx)
movups %xmm0,0xb0(%rbx)
movups %xmm1,0xa0(%r14)
movups %xmm1,0xb0(%r14)
movups %xmm0,0xc0(%rbx)
movups %xmm0,0xd0(%rbx)
movups %xmm1,0xc0(%r14)
movups %xmm1,0xd0(%r14)
movups %xmm0,0xe0(%rbx)
movups %xmm0,0xf0(%rbx)
movups %xmm1,0xe0(%r14)
movups %xmm1,0xf0(%r14)
movups %xmm0,0x100(%rbx)
movups %xmm0,0x110(%rbx)
movups %xmm1,0x100(%r14)
movups %xmm1,0x110(%r14)
movups %xmm0,0x120(%rbx)
movups %xmm0,0x130(%rbx)
movups %xmm1,0x120(%r14)
movups %xmm1,0x130(%r14)
movups %xmm0,0x140(%rbx)
movups %xmm0,0x150(%rbx)
movups %xmm1,0x140(%r14)
movups %xmm1,0x150(%r14)
movups %xmm0,0x160(%rbx)
movups %xmm0,0x170(%rbx)
movups %xmm1,0x160(%r14)
movups %xmm1,0x170(%r14)
movups %xmm0,0x180(%rbx)
movups %xmm0,0x190(%rbx)
movups %xmm1,0x180(%r14)
movups %xmm1,0x190(%r14)
movups %xmm0,0x1a0(%rbx)
movups %xmm0,0x1b0(%rbx)
movups %xmm1,0x1a0(%r14)
movups %xmm1,0x1b0(%r14)
movups %xmm0,0x1c0(%rbx)
movups %xmm0,0x1d0(%rbx)
movups %xmm1,0x1c0(%r14)
movups %xmm1,0x1d0(%r14)
movups %xmm0,0x1e0(%rbx)
movups %xmm0,0x1f0(%rbx)
movups %xmm1,0x1e0(%r14)
movups %xmm1,0x1f0(%r14)
cmp    %rcx,%r14
jae    1403 <main+0x2d3>
cmp    %rsi,%rbx
jae    1403 <main+0x2d3>
xor    %eax,%eax
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%r14,%rax,4)
movss  0x4(%rbx,%rax,4),%xmm0
movss  %xmm0,0x4(%r14,%rax,4)
movss  0x8(%rbx,%rax,4),%xmm0
movss  %xmm0,0x8(%r14,%rax,4)
movss  0xc(%rbx,%rax,4),%xmm0
movss  %xmm0,0xc(%r14,%rax,4)
add    $0x4,%rax
cmp    $0x80,%rax
jne    13c0 <main+0x290>
jmp    15b1 <main+0x481>
movups (%rbx),%xmm0
movups 0x10(%rbx),%xmm1
movups %xmm0,(%r14)
movups %xmm1,0x10(%r14)
movups 0x20(%rbx),%xmm0
movups 0x30(%rbx),%xmm1
movups %xmm0,0x20(%r14)
movups %xmm1,0x30(%r14)
movups 0x40(%rbx),%xmm0
movups 0x50(%rbx),%xmm1
movups %xmm0,0x40(%r14)
movups %xmm1,0x50(%r14)
movups 0x60(%rbx),%xmm0
movups 0x70(%rbx),%xmm1
movups %xmm0,0x60(%r14)
movups %xmm1,0x70(%r14)
movups 0x80(%rbx),%xmm0
movups 0x90(%rbx),%xmm1
movups %xmm0,0x80(%r14)
movups %xmm1,0x90(%r14)
movups 0xa0(%rbx),%xmm0
movups 0xb0(%rbx),%xmm1
movups %xmm0,0xa0(%r14)
movups %xmm1,0xb0(%r14)
movups 0xc0(%rbx),%xmm0
movups 0xd0(%rbx),%xmm1
movups %xmm0,0xc0(%r14)
movups %xmm1,0xd0(%r14)
movups 0xe0(%rbx),%xmm0
movups 0xf0(%rbx),%xmm1
movups %xmm0,0xe0(%r14)
movups %xmm1,0xf0(%r14)
movups 0x100(%rbx),%xmm0
movups 0x110(%rbx),%xmm1
movups %xmm0,0x100(%r14)
movups %xmm1,0x110(%r14)
movups 0x120(%rbx),%xmm0
movups 0x130(%rbx),%xmm1
movups %xmm0,0x120(%r14)
movups %xmm1,0x130(%r14)
movups 0x140(%rbx),%xmm0
movups 0x150(%rbx),%xmm1
movups %xmm0,0x140(%r14)
movups %xmm1,0x150(%r14)
movups 0x160(%rbx),%xmm0
movups 0x170(%rbx),%xmm1
movups %xmm0,0x160(%r14)
movups %xmm1,0x170(%r14)
movups 0x180(%rbx),%xmm0
movups 0x190(%rbx),%xmm1
movups %xmm0,0x180(%r14)
movups %xmm1,0x190(%r14)
movups 0x1a0(%rbx),%xmm0
movups 0x1b0(%rbx),%xmm1
movups %xmm0,0x1a0(%r14)
movups %xmm1,0x1b0(%r14)
movups 0x1c0(%rbx),%xmm0
movups 0x1d0(%rbx),%xmm1
movups %xmm0,0x1c0(%r14)
movups %xmm1,0x1d0(%r14)
movups 0x1e0(%rbx),%xmm0
movups 0x1f0(%rbx),%xmm1
movups %xmm0,0x1e0(%r14)
movups %xmm1,0x1f0(%r14)
xor    %edx,%edx
movss  0x1a65(%rip),%xmm1
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rdx,4),%xmm0
ucomiss %xmm1,%xmm0
jne    2616 <main+0x14e6>
jp     2616 <main+0x14e6>
movss  (%r14,%rdx,4),%xmm0
ucomiss %xmm1,%xmm0
jne    2616 <main+0x14e6>
jp     2616 <main+0x14e6>
movss  0x4(%rbx,%rdx,4),%xmm0
ucomiss %xmm1,%xmm0
jne    2616 <main+0x14e6>
jp     2616 <main+0x14e6>
movss  0x4(%r14,%rdx,4),%xmm0
ucomiss %xmm1,%xmm0
jne    2616 <main+0x14e6>
jp     2616 <main+0x14e6>
add    $0x2,%rdx
cmp    $0x80,%rdx
jne    15c0 <main+0x490>
cmp    %rsi,%rbx
jae    168c <main+0x55c>
cmp    %rcx,%r14
jae    168c <main+0x55c>
xor    %eax,%eax
nopl   (%rax)
movl   $0x40000000,(%rbx,%rax,4)
movl   $0x0,(%r14,%rax,4)
movl   $0x40000000,0x4(%rbx,%rax,4)
40
movl   $0x0,0x4(%r14,%rax,4)
movl   $0x40000000,0x8(%rbx,%rax,4)
40
movl   $0x0,0x8(%r14,%rax,4)
movl   $0x40000000,0xc(%rbx,%rax,4)
40
movl   $0x0,0xc(%r14,%rax,4)
add    $0x4,%rax
cmp    $0x80,%rax
jne    1630 <main+0x500>
cmp    %rcx,%r14
jb     1849 <main+0x719>
jmp    1893 <main+0x763>
movaps 0x197d(%rip),%xmm0
movups %xmm0,(%rbx)
movups %xmm0,0x10(%rbx)
xorps  %xmm2,%xmm2
movups %xmm2,(%r14)
movups %xmm2,0x10(%r14)
movups %xmm0,0x20(%rbx)
movups %xmm0,0x30(%rbx)
movups %xmm2,0x20(%r14)
movups %xmm2,0x30(%r14)
movups %xmm0,0x40(%rbx)
movups %xmm0,0x50(%rbx)
movups %xmm2,0x40(%r14)
movups %xmm2,0x50(%r14)
movups %xmm0,0x60(%rbx)
movups %xmm0,0x70(%rbx)
movups %xmm2,0x60(%r14)
movups %xmm2,0x70(%r14)
movups %xmm0,0x80(%rbx)
movups %xmm0,0x90(%rbx)
movups %xmm2,0x80(%r14)
movups %xmm2,0x90(%r14)
movups %xmm0,0xa0(%rbx)
movups %xmm0,0xb0(%rbx)
movups %xmm2,0xa0(%r14)
movups %xmm2,0xb0(%r14)
movups %xmm0,0xc0(%rbx)
movups %xmm0,0xd0(%rbx)
movups %xmm2,0xc0(%r14)
movups %xmm2,0xd0(%r14)
movups %xmm0,0xe0(%rbx)
movups %xmm0,0xf0(%rbx)
movups %xmm2,0xe0(%r14)
movups %xmm2,0xf0(%r14)
movups %xmm0,0x100(%rbx)
movups %xmm0,0x110(%rbx)
movups %xmm2,0x100(%r14)
movups %xmm2,0x110(%r14)
movups %xmm0,0x120(%rbx)
movups %xmm0,0x130(%rbx)
movups %xmm2,0x120(%r14)
movups %xmm2,0x130(%r14)
movups %xmm0,0x140(%rbx)
movups %xmm0,0x150(%rbx)
movups %xmm2,0x140(%r14)
movups %xmm2,0x150(%r14)
movups %xmm0,0x160(%rbx)
movups %xmm0,0x170(%rbx)
movups %xmm2,0x160(%r14)
movups %xmm2,0x170(%r14)
movups %xmm0,0x180(%rbx)
movups %xmm0,0x190(%rbx)
movups %xmm2,0x180(%r14)
movups %xmm2,0x190(%r14)
movups %xmm0,0x1a0(%rbx)
movups %xmm0,0x1b0(%rbx)
movups %xmm2,0x1a0(%r14)
movups %xmm2,0x1b0(%r14)
movups %xmm0,0x1c0(%rbx)
movups %xmm0,0x1d0(%rbx)
movups %xmm2,0x1c0(%r14)
movups %xmm2,0x1d0(%r14)
movups %xmm0,0x1e0(%rbx)
movups %xmm0,0x1f0(%rbx)
movups %xmm2,0x1e0(%r14)
movups %xmm2,0x1f0(%r14)
cmp    %rcx,%r14
jae    1893 <main+0x763>
cmp    %rsi,%rbx
jae    1893 <main+0x763>
xor    %eax,%eax
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%r14,%rax,4)
movss  0x4(%rbx,%rax,4),%xmm0
movss  %xmm0,0x4(%r14,%rax,4)
movss  0x8(%rbx,%rax,4),%xmm0
movss  %xmm0,0x8(%r14,%rax,4)
movss  0xc(%rbx,%rax,4),%xmm0
movss  %xmm0,0xc(%r14,%rax,4)
add    $0x4,%rax
cmp    $0x80,%rax
jne    1850 <main+0x720>
jmp    1a41 <main+0x911>
movups (%rbx),%xmm0
movups 0x10(%rbx),%xmm2
movups %xmm0,(%r14)
movups %xmm2,0x10(%r14)
movups 0x20(%rbx),%xmm0
movups 0x30(%rbx),%xmm2
movups %xmm0,0x20(%r14)
movups %xmm2,0x30(%r14)
movups 0x40(%rbx),%xmm0
movups 0x50(%rbx),%xmm2
movups %xmm0,0x40(%r14)
movups %xmm2,0x50(%r14)
movups 0x60(%rbx),%xmm0
movups 0x70(%rbx),%xmm2
movups %xmm0,0x60(%r14)
movups %xmm2,0x70(%r14)
movups 0x80(%rbx),%xmm0
movups 0x90(%rbx),%xmm2
movups %xmm0,0x80(%r14)
movups %xmm2,0x90(%r14)
movups 0xa0(%rbx),%xmm0
movups 0xb0(%rbx),%xmm2
movups %xmm0,0xa0(%r14)
movups %xmm2,0xb0(%r14)
movups 0xc0(%rbx),%xmm0
movups 0xd0(%rbx),%xmm2
movups %xmm0,0xc0(%r14)
movups %xmm2,0xd0(%r14)
movups 0xe0(%rbx),%xmm0
movups 0xf0(%rbx),%xmm2
movups %xmm0,0xe0(%r14)
movups %xmm2,0xf0(%r14)
movups 0x100(%rbx),%xmm0
movups 0x110(%rbx),%xmm2
movups %xmm0,0x100(%r14)
movups %xmm2,0x110(%r14)
movups 0x120(%rbx),%xmm0
movups 0x130(%rbx),%xmm2
movups %xmm0,0x120(%r14)
movups %xmm2,0x130(%r14)
movups 0x140(%rbx),%xmm0
movups 0x150(%rbx),%xmm2
movups %xmm0,0x140(%r14)
movups %xmm2,0x150(%r14)
movups 0x160(%rbx),%xmm0
movups 0x170(%rbx),%xmm2
movups %xmm0,0x160(%r14)
movups %xmm2,0x170(%r14)
movups 0x180(%rbx),%xmm0
movups 0x190(%rbx),%xmm2
movups %xmm0,0x180(%r14)
movups %xmm2,0x190(%r14)
movups 0x1a0(%rbx),%xmm0
movups 0x1b0(%rbx),%xmm2
movups %xmm0,0x1a0(%r14)
movups %xmm2,0x1b0(%r14)
movups 0x1c0(%rbx),%xmm0
movups 0x1d0(%rbx),%xmm2
movups %xmm0,0x1c0(%r14)
movups %xmm2,0x1d0(%r14)
movups 0x1e0(%rbx),%xmm0
movups 0x1f0(%rbx),%xmm2
movups %xmm0,0x1e0(%r14)
movups %xmm2,0x1f0(%r14)
xor    %edx,%edx
movss  0x15d9(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rdx,4),%xmm2
ucomiss %xmm0,%xmm2
jne    2616 <main+0x14e6>
jp     2616 <main+0x14e6>
movss  (%r14,%rdx,4),%xmm2
ucomiss %xmm0,%xmm2
jne    2616 <main+0x14e6>
jp     2616 <main+0x14e6>
movss  0x4(%rbx,%rdx,4),%xmm2
ucomiss %xmm0,%xmm2
jne    2616 <main+0x14e6>
jp     2616 <main+0x14e6>
movss  0x4(%r14,%rdx,4),%xmm2
ucomiss %xmm0,%xmm2
jne    2616 <main+0x14e6>
jp     2616 <main+0x14e6>
add    $0x2,%rdx
cmp    $0x80,%rdx
jne    1a50 <main+0x920>
lea    0x200(%r15),%r9
lea    0x200(%r12),%r11
cmp    %rsi,%rbx
setb   %dil
cmp    %rcx,%r14
setb   %bpl
cmp    %r9,%rbx
setb   %r8b
cmp    %rcx,%r15
setb   %r10b
cmp    %r11,%rbx
setb   %al
mov    %rcx,0x18(%rsp)
cmp    %rcx,%r12
setb   0x7(%rsp)
cmp    %r9,%r14
setb   %cl
cmp    %rsi,%r15
setb   0x6(%rsp)
cmp    %r11,%r14
setb   %dl
mov    %rsi,0x20(%rsp)
cmp    %rsi,%r12
setb   0x5(%rsp)
mov    %r11,0x10(%rsp)
cmp    %r11,%r15
setb   %r11b
mov    %r9,0x8(%rsp)
cmp    %r9,%r12
setb   %sil
test   %bpl,%dil
jne    1f09 <main+0xdd9>
and    %r10b,%r8b
jne    1f09 <main+0xdd9>
and    0x7(%rsp),%al
jne    1f09 <main+0xdd9>
and    0x6(%rsp),%cl
jne    1f09 <main+0xdd9>
and    0x5(%rsp),%dl
jne    1f09 <main+0xdd9>
and    %sil,%r11b
jne    1f09 <main+0xdd9>
movaps 0x1498(%rip),%xmm3
movups %xmm3,(%rbx)
movups %xmm3,0x10(%rbx)
xorps  %xmm2,%xmm2
movups %xmm2,(%r14)
movups %xmm2,0x10(%r14)
movups %xmm2,(%r15)
movups %xmm2,0x10(%r15)
movups %xmm2,(%r12)
movups %xmm2,0x10(%r12)
movups %xmm3,0x20(%rbx)
movups %xmm3,0x30(%rbx)
movups %xmm2,0x20(%r14)
movups %xmm2,0x30(%r14)
movups %xmm2,0x20(%r15)
movups %xmm2,0x30(%r15)
movups %xmm2,0x20(%r12)
movups %xmm2,0x30(%r12)
movups %xmm3,0x40(%rbx)
movups %xmm3,0x50(%rbx)
movups %xmm2,0x40(%r14)
movups %xmm2,0x50(%r14)
movups %xmm2,0x40(%r15)
movups %xmm2,0x50(%r15)
movups %xmm2,0x40(%r12)
movups %xmm2,0x50(%r12)
movups %xmm3,0x60(%rbx)
movups %xmm3,0x70(%rbx)
movups %xmm2,0x60(%r14)
movups %xmm2,0x70(%r14)
movups %xmm2,0x60(%r15)
movups %xmm2,0x70(%r15)
movups %xmm2,0x60(%r12)
movups %xmm2,0x70(%r12)
movups %xmm3,0x80(%rbx)
movups %xmm3,0x90(%rbx)
movups %xmm2,0x80(%r14)
movups %xmm2,0x90(%r14)
movups %xmm2,0x80(%r15)
movups %xmm2,0x90(%r15)
movups %xmm2,0x80(%r12)
movups %xmm2,0x90(%r12)
movups %xmm3,0xa0(%rbx)
movups %xmm3,0xb0(%rbx)
movups %xmm2,0xa0(%r14)
movups %xmm2,0xb0(%r14)
movups %xmm2,0xa0(%r15)
movups %xmm2,0xb0(%r15)
movups %xmm2,0xa0(%r12)
movups %xmm2,0xb0(%r12)
movups %xmm3,0xc0(%rbx)
movups %xmm3,0xd0(%rbx)
movups %xmm2,0xc0(%r14)
movups %xmm2,0xd0(%r14)
movups %xmm2,0xc0(%r15)
movups %xmm2,0xd0(%r15)
movups %xmm2,0xc0(%r12)
movups %xmm2,0xd0(%r12)
movups %xmm3,0xe0(%rbx)
movups %xmm3,0xf0(%rbx)
movups %xmm2,0xe0(%r14)
movups %xmm2,0xf0(%r14)
movups %xmm2,0xe0(%r15)
movups %xmm2,0xf0(%r15)
movups %xmm2,0xe0(%r12)
movups %xmm2,0xf0(%r12)
movups %xmm3,0x100(%rbx)
movups %xmm3,0x110(%rbx)
movups %xmm2,0x100(%r14)
movups %xmm2,0x110(%r14)
movups %xmm2,0x100(%r15)
movups %xmm2,0x110(%r15)
movups %xmm2,0x100(%r12)
movups %xmm2,0x110(%r12)
movups %xmm3,0x120(%rbx)
movups %xmm3,0x130(%rbx)
movups %xmm2,0x120(%r14)
movups %xmm2,0x130(%r14)
movups %xmm2,0x120(%r15)
movups %xmm2,0x130(%r15)
movups %xmm2,0x120(%r12)
movups %xmm2,0x130(%r12)
movups %xmm3,0x140(%rbx)
movups %xmm3,0x150(%rbx)
movups %xmm2,0x140(%r14)
movups %xmm2,0x150(%r14)
movups %xmm2,0x140(%r15)
movups %xmm2,0x150(%r15)
movups %xmm2,0x140(%r12)
movups %xmm2,0x150(%r12)
movups %xmm3,0x160(%rbx)
movups %xmm3,0x170(%rbx)
movups %xmm2,0x160(%r14)
movups %xmm2,0x170(%r14)
movups %xmm2,0x160(%r15)
movups %xmm2,0x170(%r15)
movups %xmm2,0x160(%r12)
movups %xmm2,0x170(%r12)
movups %xmm3,0x180(%rbx)
movups %xmm3,0x190(%rbx)
movups %xmm2,0x180(%r14)
movups %xmm2,0x190(%r14)
movups %xmm2,0x180(%r15)
movups %xmm2,0x190(%r15)
movups %xmm2,0x180(%r12)
movups %xmm2,0x190(%r12)
movups %xmm3,0x1a0(%rbx)
movups %xmm3,0x1b0(%rbx)
movups %xmm2,0x1a0(%r14)
movups %xmm2,0x1b0(%r14)
movups %xmm2,0x1a0(%r15)
movups %xmm2,0x1b0(%r15)
movups %xmm2,0x1a0(%r12)
movups %xmm2,0x1b0(%r12)
movups %xmm3,0x1c0(%rbx)
movups %xmm3,0x1d0(%rbx)
movups %xmm2,0x1c0(%r14)
movups %xmm2,0x1d0(%r14)
movups %xmm2,0x1c0(%r15)
movups %xmm2,0x1d0(%r15)
movups %xmm2,0x1c0(%r12)
movups %xmm2,0x1d0(%r12)
movups %xmm3,0x1e0(%rbx)
movups %xmm3,0x1f0(%rbx)
movups %xmm2,0x1e0(%r14)
movups %xmm2,0x1f0(%r14)
movups %xmm2,0x1e0(%r15)
movups %xmm2,0x1f0(%r15)
movups %xmm2,0x1e0(%r12)
movups %xmm2,0x1f0(%r12)
jmp    1f5e <main+0xe2e>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movl   $0x40400000,(%rbx,%rax,4)
movl   $0x0,(%r14,%rax,4)
movl   $0x0,(%r15,%rax,4)
movl   $0x0,(%r12,%rax,4)
movl   $0x40400000,0x4(%rbx,%rax,4)
40
movl   $0x0,0x4(%r14,%rax,4)
movl   $0x0,0x4(%r15,%rax,4)
movl   $0x0,0x4(%r12,%rax,4)
add    $0x2,%rax
cmp    $0x80,%rax
jne    1f10 <main+0xde0>
mov    0x18(%rsp),%rdx
cmp    %rdx,%r14
mov    0x20(%rsp),%rcx
mov    0x10(%rsp),%r11
mov    0x8(%rsp),%rbp
jae    1fc4 <main+0xe94>
cmp    %rcx,%rbx
jae    1fc4 <main+0xe94>
xor    %eax,%eax
xchg   %ax,%ax
movss  (%rbx,%rax,4),%xmm2
movaps %xmm2,%xmm3
mulss  %xmm2,%xmm3
mulss  %xmm2,%xmm3
divss  %xmm2,%xmm3
movss  %xmm3,(%r14,%rax,4)
movss  0x4(%rbx,%rax,4),%xmm2
movaps %xmm2,%xmm3
mulss  %xmm2,%xmm3
mulss  %xmm2,%xmm3
divss  %xmm2,%xmm3
movss  %xmm3,0x4(%r14,%rax,4)
add    $0x2,%rax
cmp    $0x80,%rax
jne    1f80 <main+0xe50>
jmp    2008 <main+0xed8>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movups (%rbx,%rax,4),%xmm2
movaps %xmm2,%xmm3
mulps  %xmm2,%xmm3
mulps  %xmm2,%xmm3
divps  %xmm2,%xmm3
movups %xmm3,(%r14,%rax,4)
movups 0x10(%rbx,%rax,4),%xmm2
movaps %xmm2,%xmm3
mulps  %xmm2,%xmm3
mulps  %xmm2,%xmm3
divps  %xmm2,%xmm3
movups %xmm3,0x10(%r14,%rax,4)
add    $0x8,%rax
cmp    $0x80,%rax
jne    1fd0 <main+0xea0>
cmp    %rdx,%r15
jae    206d <main+0xf3d>
cmp    %rbp,%rbx
jae    206d <main+0xf3d>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rbx,%rdi,4),%xmm2
movaps %xmm2,%xmm3
addss  %xmm2,%xmm3
addss  %xmm2,%xmm3
addss  %xmm2,%xmm3
divss  %xmm2,%xmm3
movss  %xmm3,(%r15,%rdi,4)
movss  0x4(%rbx,%rdi,4),%xmm2
movaps %xmm2,%xmm3
addss  %xmm2,%xmm3
addss  %xmm2,%xmm3
addss  %xmm2,%xmm3
divss  %xmm2,%xmm3
movss  %xmm3,0x4(%r15,%rdi,4)
add    $0x2,%rdi
cmp    $0x80,%rdi
jne    2020 <main+0xef0>
jmp    20af <main+0xf7f>
xor    %edi,%edi
nop
movups (%rbx,%rdi,4),%xmm2
movaps %xmm2,%xmm3
addps  %xmm2,%xmm3
addps  %xmm2,%xmm3
addps  %xmm2,%xmm3
divps  %xmm2,%xmm3
movups %xmm3,(%r15,%rdi,4)
movups 0x10(%rbx,%rdi,4),%xmm2
movaps %xmm2,%xmm3
addps  %xmm2,%xmm3
addps  %xmm2,%xmm3
addps  %xmm2,%xmm3
divps  %xmm2,%xmm3
movups %xmm3,0x10(%r15,%rdi,4)
add    $0x8,%rdi
cmp    $0x80,%rdi
jne    2070 <main+0xf40>
cmp    %rdx,%r12
jae    210d <main+0xfdd>
cmp    %r11,%rbx
jae    210d <main+0xfdd>
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rdi,4),%xmm2
movaps %xmm2,%xmm3
mulss  %xmm2,%xmm3
addss  %xmm2,%xmm3
divss  %xmm2,%xmm3
subss  %xmm2,%xmm3
movss  %xmm3,(%r12,%rdi,4)
movss  0x4(%rbx,%rdi,4),%xmm2
movaps %xmm2,%xmm3
mulss  %xmm2,%xmm3
addss  %xmm2,%xmm3
divss  %xmm2,%xmm3
subss  %xmm2,%xmm3
movss  %xmm3,0x4(%r12,%rdi,4)
add    $0x2,%rdi
cmp    $0x80,%rdi
jne    20c0 <main+0xf90>
jmp    214f <main+0x101f>
xor    %edi,%edi
nop
movups (%rbx,%rdi,4),%xmm2
movaps %xmm2,%xmm3
mulps  %xmm2,%xmm3
addps  %xmm2,%xmm3
divps  %xmm2,%xmm3
subps  %xmm2,%xmm3
movups %xmm3,(%r12,%rdi,4)
movups 0x10(%rbx,%rdi,4),%xmm2
movaps %xmm2,%xmm3
mulps  %xmm2,%xmm3
addps  %xmm2,%xmm3
divps  %xmm2,%xmm3
subps  %xmm2,%xmm3
movups %xmm3,0x10(%r12,%rdi,4)
add    $0x8,%rdi
cmp    $0x80,%rdi
jne    2110 <main+0xfe0>
xor    %edi,%edi
movss  0xecf(%rip),%xmm4
movss  0xecb(%rip),%xmm2
movss  0xec7(%rip),%xmm3
nopl   0x0(%rax)
movss  (%rbx,%rdi,4),%xmm5
ucomiss %xmm1,%xmm5
jne    2616 <main+0x14e6>
jp     2616 <main+0x14e6>
movss  (%r14,%rdi,4),%xmm5
ucomiss %xmm4,%xmm5
jne    2616 <main+0x14e6>
jp     2616 <main+0x14e6>
movss  (%r15,%rdi,4),%xmm5
ucomiss %xmm2,%xmm5
jne    2616 <main+0x14e6>
jp     2616 <main+0x14e6>
movss  (%r12,%rdi,4),%xmm5
ucomiss %xmm3,%xmm5
jne    2616 <main+0x14e6>
jp     2616 <main+0x14e6>
movss  0x4(%rbx,%rdi,4),%xmm5
ucomiss %xmm1,%xmm5
jne    2616 <main+0x14e6>
jp     2616 <main+0x14e6>
movss  0x4(%r14,%rdi,4),%xmm5
ucomiss %xmm4,%xmm5
jne    2616 <main+0x14e6>
jp     2616 <main+0x14e6>
movss  0x4(%r15,%rdi,4),%xmm5
ucomiss %xmm2,%xmm5
jne    2616 <main+0x14e6>
jp     2616 <main+0x14e6>
movss  0x4(%r12,%rdi,4),%xmm5
ucomiss %xmm3,%xmm5
jne    2616 <main+0x14e6>
jp     2616 <main+0x14e6>
add    $0x2,%rdi
cmp    $0x80,%rdi
jne    2170 <main+0x1040>
xor    %eax,%eax
nopl   (%rax)
movl   $0x40000000,(%rbx,%rax,1)
movl   $0x0,(%r14,%rax,1)
movl   $0x0,(%r15,%rax,1)
movl   $0x0,(%r12,%rax,1)
movl   $0x0,0x0(%r13,%rax,1)
movl   $0x40000000,0x4(%rbx,%rax,1)
40
movl   $0x0,0x4(%r14,%rax,1)
movl   $0x0,0x4(%r15,%rax,1)
movl   $0x0,0x4(%r12,%rax,1)
movl   $0x0,0x4(%r13,%rax,1)
add    $0x8,%rax
cmp    $0x200,%rax
jne    2230 <main+0x1100>
cmp    %rdx,%r14
jae    22e4 <main+0x11b4>
cmp    %rcx,%rbx
jae    22e4 <main+0x11b4>
xor    %eax,%eax
nopl   0x0(%rax)
movss  (%rbx,%rax,4),%xmm1
movaps %xmm1,%xmm4
mulss  %xmm1,%xmm4
mulss  %xmm1,%xmm4
divss  %xmm1,%xmm4
movss  %xmm4,(%r14,%rax,4)
movss  0x4(%rbx,%rax,4),%xmm1
movaps %xmm1,%xmm4
mulss  %xmm1,%xmm4
mulss  %xmm1,%xmm4
divss  %xmm1,%xmm4
movss  %xmm4,0x4(%r14,%rax,4)
add    $0x2,%rax
cmp    $0x80,%rax
jne    22a0 <main+0x1170>
jmp    2328 <main+0x11f8>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movups (%rbx,%rax,4),%xmm1
movaps %xmm1,%xmm4
mulps  %xmm1,%xmm4
mulps  %xmm1,%xmm4
divps  %xmm1,%xmm4
movups %xmm4,(%r14,%rax,4)
movups 0x10(%rbx,%rax,4),%xmm1
movaps %xmm1,%xmm4
mulps  %xmm1,%xmm4
mulps  %xmm1,%xmm4
divps  %xmm1,%xmm4
movups %xmm4,0x10(%r14,%rax,4)
add    $0x8,%rax
cmp    $0x80,%rax
jne    22f0 <main+0x11c0>
cmp    %rdx,%r15
jae    238d <main+0x125d>
cmp    %rbp,%rbx
jae    238d <main+0x125d>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rbx,%rdi,4),%xmm1
movaps %xmm1,%xmm4
addss  %xmm1,%xmm4
addss  %xmm1,%xmm4
addss  %xmm1,%xmm4
divss  %xmm1,%xmm4
movss  %xmm4,(%r15,%rdi,4)
movss  0x4(%rbx,%rdi,4),%xmm1
movaps %xmm1,%xmm4
addss  %xmm1,%xmm4
addss  %xmm1,%xmm4
addss  %xmm1,%xmm4
divss  %xmm1,%xmm4
movss  %xmm4,0x4(%r15,%rdi,4)
add    $0x2,%rdi
cmp    $0x80,%rdi
jne    2340 <main+0x1210>
jmp    23cf <main+0x129f>
xor    %edi,%edi
nop
movups (%rbx,%rdi,4),%xmm1
movaps %xmm1,%xmm4
addps  %xmm1,%xmm4
addps  %xmm1,%xmm4
addps  %xmm1,%xmm4
divps  %xmm1,%xmm4
movups %xmm4,(%r15,%rdi,4)
movups 0x10(%rbx,%rdi,4),%xmm1
movaps %xmm1,%xmm4
addps  %xmm1,%xmm4
addps  %xmm1,%xmm4
addps  %xmm1,%xmm4
divps  %xmm1,%xmm4
movups %xmm4,0x10(%r15,%rdi,4)
add    $0x8,%rdi
cmp    $0x80,%rdi
jne    2390 <main+0x1260>
cmp    %rdx,%r12
jae    242d <main+0x12fd>
cmp    %r11,%rbx
jae    242d <main+0x12fd>
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rdi,4),%xmm1
movaps %xmm1,%xmm4
mulss  %xmm1,%xmm4
addss  %xmm1,%xmm4
divss  %xmm1,%xmm4
subss  %xmm1,%xmm4
movss  %xmm4,(%r12,%rdi,4)
movss  0x4(%rbx,%rdi,4),%xmm1
movaps %xmm1,%xmm4
mulss  %xmm1,%xmm4
addss  %xmm1,%xmm4
divss  %xmm1,%xmm4
subss  %xmm1,%xmm4
movss  %xmm4,0x4(%r12,%rdi,4)
add    $0x2,%rdi
cmp    $0x80,%rdi
jne    23e0 <main+0x12b0>
jmp    246f <main+0x133f>
xor    %edi,%edi
nop
movups (%rbx,%rdi,4),%xmm1
movaps %xmm1,%xmm4
mulps  %xmm1,%xmm4
addps  %xmm1,%xmm4
divps  %xmm1,%xmm4
subps  %xmm1,%xmm4
movups %xmm4,(%r12,%rdi,4)
movups 0x10(%rbx,%rdi,4),%xmm1
movaps %xmm1,%xmm4
mulps  %xmm1,%xmm4
addps  %xmm1,%xmm4
divps  %xmm1,%xmm4
subps  %xmm1,%xmm4
movups %xmm4,0x10(%r12,%rdi,4)
add    $0x8,%rdi
cmp    $0x80,%rdi
jne    2430 <main+0x1300>
lea    0x200(%r13),%rsi
cmp    %rdx,%r13
setb   %r9b
cmp    %rsi,%rbx
setb   %r10b
cmp    %rcx,%r13
setb   %dl
cmp    %rsi,%r14
setb   %r8b
cmp    %rbp,%r13
setb   %cl
cmp    %rsi,%r15
setb   %dil
cmp    %r11,%r13
setb   %al
cmp    %rsi,%r12
setb   %sil
test   %r10b,%r9b
jne    2526 <main+0x13f6>
and    %r8b,%dl
jne    2526 <main+0x13f6>
and    %dil,%cl
jne    2526 <main+0x13f6>
and    %sil,%al
jne    2526 <main+0x13f6>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rbx,%rax,1),%xmm1
movups 0x10(%rbx,%rax,1),%xmm4
movups (%r14,%rax,1),%xmm5
addps  %xmm1,%xmm5
movups 0x10(%r14,%rax,1),%xmm1
addps  %xmm4,%xmm1
movups (%r15,%rax,1),%xmm4
addps  %xmm5,%xmm4
movups 0x10(%r15,%rax,1),%xmm5
addps  %xmm1,%xmm5
movups (%r12,%rax,1),%xmm1
addps  %xmm4,%xmm1
movups 0x10(%r12,%rax,1),%xmm4
addps  %xmm5,%xmm4
movups %xmm1,0x0(%r13,%rax,1)
movups %xmm4,0x10(%r13,%rax,1)
add    $0x20,%rax
cmp    $0x200,%rax
jne    24d0 <main+0x13a0>
jmp    257c <main+0x144c>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rax,1),%xmm1
addss  (%r14,%rax,1),%xmm1
addss  (%r15,%rax,1),%xmm1
addss  (%r12,%rax,1),%xmm1
movss  %xmm1,0x0(%r13,%rax,1)
movss  0x4(%rbx,%rax,1),%xmm1
addss  0x4(%r14,%rax,1),%xmm1
addss  0x4(%r15,%rax,1),%xmm1
addss  0x4(%r12,%rax,1),%xmm1
movss  %xmm1,0x4(%r13,%rax,1)
add    $0x8,%rax
cmp    $0x200,%rax
jne    2530 <main+0x1400>
xor    %eax,%eax
movss  0xaae(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
movss  (%rbx,%rax,4),%xmm4
ucomiss %xmm0,%xmm4
jne    2616 <main+0x14e6>
jp     2616 <main+0x14e6>
movss  (%r14,%rax,4),%xmm4
ucomiss %xmm2,%xmm4
jne    2616 <main+0x14e6>
jp     2616 <main+0x14e6>
movss  (%r15,%rax,4),%xmm4
ucomiss %xmm2,%xmm4
jne    2616 <main+0x14e6>
jp     2616 <main+0x14e6>
movss  (%r12,%rax,4),%xmm4
ucomiss %xmm3,%xmm4
jne    2616 <main+0x14e6>
jp     2616 <main+0x14e6>
movss  0x0(%r13,%rax,4),%xmm4
ucomiss %xmm1,%xmm4
jne    2616 <main+0x14e6>
jp     2616 <main+0x14e6>
add    $0x1,%rax
cmp    $0x80,%rax
jne    2590 <main+0x1460>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %eax,%eax
call   1040 <abort@plt>

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

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