void f(int N, float *a, float *b) {
  int ii;
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) async(1 2)
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) async(1, )
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) async(, 1)
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) async(1, 2, )
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) async(1, 2 3)
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) async(1, 2, , )
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) async(1
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) async(*)
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) async(a)
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) async(1.0)
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) async()
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) async
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) wait(1 2)
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) wait(1, )
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) wait(, 1)
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) wait(1, 2, )
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) wait(1, 2 3)
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) wait(1, 2, , )
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) wait(1
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) wait(1, *)
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) wait(1, a)
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) wait(a)
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) wait(1.0)
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) wait()
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc parallel copyin(a [0:N]) copy(b [0:N]) wait
  {
    for (ii = 0; ii < N; ii++)
      b[ii] = a[ii];
  }
#pragma acc wait(1 2)
#pragma acc wait(1, )
#pragma acc wait(, 1)
#pragma acc wait(1, 2, )
#pragma acc wait(1, 2 3)
#pragma acc wait(1, 2, , )
#pragma acc wait(1
#pragma acc wait(1, *)
#pragma acc wait(1, a)
#pragma acc wait(a)
#pragma acc wait(1.0)
#pragma acc wait 1
#pragma acc wait N
#pragma acc wait async(1 2)
#pragma acc wait async(1 2)
#pragma acc wait async(1, )
#pragma acc wait async(, 1)
#pragma acc wait async(1, 2, )
#pragma acc wait async(1, 2 3)
#pragma acc wait async(1, 2, , )
#pragma acc wait async(1
#pragma acc wait async(*)
#pragma acc wait async(a)
#pragma acc wait async(1.0)
}


x86 assembly (clang, -O0):
<f>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    114a <f+0x4a>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1116 <f+0x16>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1185 <f+0x85>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1151 <f+0x51>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11c0 <f+0xc0>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    118c <f+0x8c>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11fb <f+0xfb>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11c7 <f+0xc7>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1236 <f+0x136>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1202 <f+0x102>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1271 <f+0x171>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    123d <f+0x13d>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12ac <f+0x1ac>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1278 <f+0x178>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12e7 <f+0x1e7>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12b3 <f+0x1b3>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1322 <f+0x222>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12ee <f+0x1ee>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    135d <f+0x25d>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1329 <f+0x229>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1398 <f+0x298>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1364 <f+0x264>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13d3 <f+0x2d3>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    139f <f+0x29f>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    140e <f+0x30e>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    13da <f+0x2da>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1449 <f+0x349>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1415 <f+0x315>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1484 <f+0x384>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1450 <f+0x350>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14bf <f+0x3bf>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    148b <f+0x38b>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14fa <f+0x3fa>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    14c6 <f+0x3c6>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1535 <f+0x435>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1501 <f+0x401>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1570 <f+0x470>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    153c <f+0x43c>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15ab <f+0x4ab>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1577 <f+0x477>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15e6 <f+0x4e6>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    15b2 <f+0x4b2>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1621 <f+0x521>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    15ed <f+0x4ed>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    165c <f+0x55c>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1628 <f+0x528>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1697 <f+0x597>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1663 <f+0x563>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    16d2 <f+0x5d2>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    169e <f+0x59e>
pop    %rbp
ret

x86 assembly (clang, -O2):
<f>:
test   %edi,%edi
jle    3301 <f+0x2201>
mov    %edi,%r8d
cmp    $0x8,%edi
jb     1126 <f+0x26>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    119c <f+0x9c>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    119c <f+0x9c>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     1154 <f+0x54>
nopw   0x0(%rax,%rax,1)
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1140 <f+0x40>
cmp    $0x3,%r9
jb     1278 <f+0x178>
xchg   %ax,%ax
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1160 <f+0x60>
jmp    1278 <f+0x178>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    11c2 <f+0xc2>
xor    %eax,%eax
jmp    1228 <f+0x128>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    11d0 <f+0xd0>
test   %r9,%r9
je     126f <f+0x16f>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    1250 <f+0x150>
cmp    %r8,%rcx
jne    1128 <f+0x28>
test   %edi,%edi
jle    3301 <f+0x2201>
cmp    $0x8,%edi
jb     129b <f+0x19b>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    130c <f+0x20c>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    130c <f+0x20c>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     12c4 <f+0x1c4>
nop
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    12b0 <f+0x1b0>
cmp    $0x3,%r9
jb     13e8 <f+0x2e8>
xchg   %ax,%ax
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    12d0 <f+0x1d0>
jmp    13e8 <f+0x2e8>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    1332 <f+0x232>
xor    %eax,%eax
jmp    1398 <f+0x298>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    1340 <f+0x240>
test   %r9,%r9
je     13df <f+0x2df>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    13c0 <f+0x2c0>
cmp    %r8,%rcx
jne    129d <f+0x19d>
test   %edi,%edi
jle    3301 <f+0x2201>
cmp    $0x8,%edi
jb     140b <f+0x30b>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    147c <f+0x37c>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    147c <f+0x37c>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     1434 <f+0x334>
nop
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1420 <f+0x320>
cmp    $0x3,%r9
jb     1558 <f+0x458>
xchg   %ax,%ax
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1440 <f+0x340>
jmp    1558 <f+0x458>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    14a2 <f+0x3a2>
xor    %eax,%eax
jmp    1508 <f+0x408>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    14b0 <f+0x3b0>
test   %r9,%r9
je     154f <f+0x44f>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    1530 <f+0x430>
cmp    %r8,%rcx
jne    140d <f+0x30d>
test   %edi,%edi
jle    3301 <f+0x2201>
cmp    $0x8,%edi
jb     157b <f+0x47b>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    15ec <f+0x4ec>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    15ec <f+0x4ec>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     15a4 <f+0x4a4>
nop
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1590 <f+0x490>
cmp    $0x3,%r9
jb     16c8 <f+0x5c8>
xchg   %ax,%ax
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    15b0 <f+0x4b0>
jmp    16c8 <f+0x5c8>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    1612 <f+0x512>
xor    %eax,%eax
jmp    1678 <f+0x578>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    1620 <f+0x520>
test   %r9,%r9
je     16bf <f+0x5bf>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    16a0 <f+0x5a0>
cmp    %r8,%rcx
jne    157d <f+0x47d>
test   %edi,%edi
jle    3301 <f+0x2201>
cmp    $0x8,%edi
jb     16eb <f+0x5eb>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    175c <f+0x65c>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    175c <f+0x65c>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     1714 <f+0x614>
nop
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1700 <f+0x600>
cmp    $0x3,%r9
jb     1838 <f+0x738>
xchg   %ax,%ax
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1720 <f+0x620>
jmp    1838 <f+0x738>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    1782 <f+0x682>
xor    %eax,%eax
jmp    17e8 <f+0x6e8>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    1790 <f+0x690>
test   %r9,%r9
je     182f <f+0x72f>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    1810 <f+0x710>
cmp    %r8,%rcx
jne    16ed <f+0x5ed>
test   %edi,%edi
jle    3301 <f+0x2201>
cmp    $0x8,%edi
jb     185b <f+0x75b>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    18cc <f+0x7cc>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    18cc <f+0x7cc>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     1884 <f+0x784>
nop
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1870 <f+0x770>
cmp    $0x3,%r9
jb     19a8 <f+0x8a8>
xchg   %ax,%ax
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1890 <f+0x790>
jmp    19a8 <f+0x8a8>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    18f2 <f+0x7f2>
xor    %eax,%eax
jmp    1958 <f+0x858>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    1900 <f+0x800>
test   %r9,%r9
je     199f <f+0x89f>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    1980 <f+0x880>
cmp    %r8,%rcx
jne    185d <f+0x75d>
test   %edi,%edi
jle    3301 <f+0x2201>
cmp    $0x8,%edi
jb     19cb <f+0x8cb>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    1a3c <f+0x93c>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    1a3c <f+0x93c>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     19f4 <f+0x8f4>
nop
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    19e0 <f+0x8e0>
cmp    $0x3,%r9
jb     1b03 <f+0xa03>
xchg   %ax,%ax
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1a00 <f+0x900>
jmp    1b03 <f+0xa03>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    1a62 <f+0x962>
xor    %eax,%eax
jmp    1ac0 <f+0x9c0>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    1a68 <f+0x968>
test   %r9,%r9
je     1afa <f+0x9fa>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    1adb <f+0x9db>
cmp    %r8,%rcx
jne    19cd <f+0x8cd>
test   %edi,%edi
jle    3301 <f+0x2201>
cmp    $0x8,%edi
jb     1b26 <f+0xa26>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    1b9c <f+0xa9c>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    1b9c <f+0xa9c>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     1b54 <f+0xa54>
nopw   0x0(%rax,%rax,1)
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1b40 <f+0xa40>
cmp    $0x3,%r9
jb     1c63 <f+0xb63>
xchg   %ax,%ax
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1b60 <f+0xa60>
jmp    1c63 <f+0xb63>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    1bc2 <f+0xac2>
xor    %eax,%eax
jmp    1c20 <f+0xb20>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    1bc8 <f+0xac8>
test   %r9,%r9
je     1c5a <f+0xb5a>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    1c3b <f+0xb3b>
cmp    %r8,%rcx
jne    1b28 <f+0xa28>
test   %edi,%edi
jle    3301 <f+0x2201>
cmp    $0x8,%edi
jb     1c86 <f+0xb86>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    1cfc <f+0xbfc>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    1cfc <f+0xbfc>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     1cb4 <f+0xbb4>
nopw   0x0(%rax,%rax,1)
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1ca0 <f+0xba0>
cmp    $0x3,%r9
jb     1dc3 <f+0xcc3>
xchg   %ax,%ax
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1cc0 <f+0xbc0>
jmp    1dc3 <f+0xcc3>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    1d22 <f+0xc22>
xor    %eax,%eax
jmp    1d80 <f+0xc80>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    1d28 <f+0xc28>
test   %r9,%r9
je     1dba <f+0xcba>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    1d9b <f+0xc9b>
cmp    %r8,%rcx
jne    1c88 <f+0xb88>
test   %edi,%edi
jle    3301 <f+0x2201>
cmp    $0x8,%edi
jb     1de2 <f+0xce2>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    1e50 <f+0xd50>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    1e50 <f+0xd50>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     1e0a <f+0xd0a>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1df6 <f+0xcf6>
cmp    $0x3,%r9
jb     1f17 <f+0xe17>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1e14 <f+0xd14>
jmp    1f17 <f+0xe17>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    1e76 <f+0xd76>
xor    %eax,%eax
jmp    1ed4 <f+0xdd4>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    1e7c <f+0xd7c>
test   %r9,%r9
je     1f0e <f+0xe0e>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    1eef <f+0xdef>
cmp    %r8,%rcx
jne    1de4 <f+0xce4>
test   %edi,%edi
jle    3301 <f+0x2201>
cmp    $0x8,%edi
jb     1f36 <f+0xe36>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    1fa4 <f+0xea4>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    1fa4 <f+0xea4>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     1f5e <f+0xe5e>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1f4a <f+0xe4a>
cmp    $0x3,%r9
jb     206b <f+0xf6b>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1f68 <f+0xe68>
jmp    206b <f+0xf6b>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    1fca <f+0xeca>
xor    %eax,%eax
jmp    2028 <f+0xf28>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    1fd0 <f+0xed0>
test   %r9,%r9
je     2062 <f+0xf62>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    2043 <f+0xf43>
cmp    %r8,%rcx
jne    1f38 <f+0xe38>
test   %edi,%edi
jle    3301 <f+0x2201>
cmp    $0x8,%edi
jb     208a <f+0xf8a>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    20f8 <f+0xff8>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    20f8 <f+0xff8>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     20b2 <f+0xfb2>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    209e <f+0xf9e>
cmp    $0x3,%r9
jb     21bf <f+0x10bf>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    20bc <f+0xfbc>
jmp    21bf <f+0x10bf>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    211e <f+0x101e>
xor    %eax,%eax
jmp    217c <f+0x107c>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    2124 <f+0x1024>
test   %r9,%r9
je     21b6 <f+0x10b6>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    2197 <f+0x1097>
cmp    %r8,%rcx
jne    208c <f+0xf8c>
test   %edi,%edi
jle    3301 <f+0x2201>
cmp    $0x8,%edi
jb     21de <f+0x10de>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    224c <f+0x114c>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    224c <f+0x114c>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     2206 <f+0x1106>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    21f2 <f+0x10f2>
cmp    $0x3,%r9
jb     2313 <f+0x1213>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    2210 <f+0x1110>
jmp    2313 <f+0x1213>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    2272 <f+0x1172>
xor    %eax,%eax
jmp    22d0 <f+0x11d0>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    2278 <f+0x1178>
test   %r9,%r9
je     230a <f+0x120a>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    22eb <f+0x11eb>
cmp    %r8,%rcx
jne    21e0 <f+0x10e0>
test   %edi,%edi
jle    3301 <f+0x2201>
cmp    $0x8,%edi
jb     2332 <f+0x1232>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    23a0 <f+0x12a0>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    23a0 <f+0x12a0>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     235a <f+0x125a>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    2346 <f+0x1246>
cmp    $0x3,%r9
jb     2467 <f+0x1367>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    2364 <f+0x1264>
jmp    2467 <f+0x1367>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    23c6 <f+0x12c6>
xor    %eax,%eax
jmp    2424 <f+0x1324>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    23cc <f+0x12cc>
test   %r9,%r9
je     245e <f+0x135e>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    243f <f+0x133f>
cmp    %r8,%rcx
jne    2334 <f+0x1234>
test   %edi,%edi
jle    3301 <f+0x2201>
cmp    $0x8,%edi
jb     2486 <f+0x1386>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    24f4 <f+0x13f4>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    24f4 <f+0x13f4>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     24ae <f+0x13ae>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    249a <f+0x139a>
cmp    $0x3,%r9
jb     25bb <f+0x14bb>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    24b8 <f+0x13b8>
jmp    25bb <f+0x14bb>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    251a <f+0x141a>
xor    %eax,%eax
jmp    2578 <f+0x1478>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    2520 <f+0x1420>
test   %r9,%r9
je     25b2 <f+0x14b2>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    2593 <f+0x1493>
cmp    %r8,%rcx
jne    2488 <f+0x1388>
test   %edi,%edi
jle    3301 <f+0x2201>
cmp    $0x8,%edi
jb     25da <f+0x14da>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    2648 <f+0x1548>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    2648 <f+0x1548>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     2602 <f+0x1502>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    25ee <f+0x14ee>
cmp    $0x3,%r9
jb     270f <f+0x160f>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    260c <f+0x150c>
jmp    270f <f+0x160f>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    266e <f+0x156e>
xor    %eax,%eax
jmp    26cc <f+0x15cc>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    2674 <f+0x1574>
test   %r9,%r9
je     2706 <f+0x1606>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    26e7 <f+0x15e7>
cmp    %r8,%rcx
jne    25dc <f+0x14dc>
test   %edi,%edi
jle    3301 <f+0x2201>
cmp    $0x8,%edi
jb     272e <f+0x162e>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    279c <f+0x169c>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    279c <f+0x169c>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     2756 <f+0x1656>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    2742 <f+0x1642>
cmp    $0x3,%r9
jb     2863 <f+0x1763>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    2760 <f+0x1660>
jmp    2863 <f+0x1763>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    27c2 <f+0x16c2>
xor    %eax,%eax
jmp    2820 <f+0x1720>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    27c8 <f+0x16c8>
test   %r9,%r9
je     285a <f+0x175a>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    283b <f+0x173b>
cmp    %r8,%rcx
jne    2730 <f+0x1630>
test   %edi,%edi
jle    3301 <f+0x2201>
cmp    $0x8,%edi
jb     2882 <f+0x1782>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    28f0 <f+0x17f0>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    28f0 <f+0x17f0>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     28aa <f+0x17aa>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    2896 <f+0x1796>
cmp    $0x3,%r9
jb     29b7 <f+0x18b7>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    28b4 <f+0x17b4>
jmp    29b7 <f+0x18b7>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    2916 <f+0x1816>
xor    %eax,%eax
jmp    2974 <f+0x1874>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    291c <f+0x181c>
test   %r9,%r9
je     29ae <f+0x18ae>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    298f <f+0x188f>
cmp    %r8,%rcx
jne    2884 <f+0x1784>
test   %edi,%edi
jle    3301 <f+0x2201>
cmp    $0x8,%edi
jb     29d6 <f+0x18d6>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    2a44 <f+0x1944>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    2a44 <f+0x1944>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     29fe <f+0x18fe>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    29ea <f+0x18ea>
cmp    $0x3,%r9
jb     2b0b <f+0x1a0b>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    2a08 <f+0x1908>
jmp    2b0b <f+0x1a0b>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    2a6a <f+0x196a>
xor    %eax,%eax
jmp    2ac8 <f+0x19c8>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    2a70 <f+0x1970>
test   %r9,%r9
je     2b02 <f+0x1a02>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    2ae3 <f+0x19e3>
cmp    %r8,%rcx
jne    29d8 <f+0x18d8>
test   %edi,%edi
jle    3301 <f+0x2201>
cmp    $0x8,%edi
jb     2b2a <f+0x1a2a>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    2b98 <f+0x1a98>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    2b98 <f+0x1a98>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     2b52 <f+0x1a52>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    2b3e <f+0x1a3e>
cmp    $0x3,%r9
jb     2c5f <f+0x1b5f>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    2b5c <f+0x1a5c>
jmp    2c5f <f+0x1b5f>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    2bbe <f+0x1abe>
xor    %eax,%eax
jmp    2c1c <f+0x1b1c>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    2bc4 <f+0x1ac4>
test   %r9,%r9
je     2c56 <f+0x1b56>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    2c37 <f+0x1b37>
cmp    %r8,%rcx
jne    2b2c <f+0x1a2c>
test   %edi,%edi
jle    3301 <f+0x2201>
cmp    $0x8,%edi
jb     2c7e <f+0x1b7e>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    2cec <f+0x1bec>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    2cec <f+0x1bec>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     2ca6 <f+0x1ba6>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    2c92 <f+0x1b92>
cmp    $0x3,%r9
jb     2db3 <f+0x1cb3>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    2cb0 <f+0x1bb0>
jmp    2db3 <f+0x1cb3>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    2d12 <f+0x1c12>
xor    %eax,%eax
jmp    2d70 <f+0x1c70>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    2d18 <f+0x1c18>
test   %r9,%r9
je     2daa <f+0x1caa>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    2d8b <f+0x1c8b>
cmp    %r8,%rcx
jne    2c80 <f+0x1b80>
test   %edi,%edi
jle    3301 <f+0x2201>
cmp    $0x8,%edi
jb     2dd2 <f+0x1cd2>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    2e40 <f+0x1d40>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    2e40 <f+0x1d40>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     2dfa <f+0x1cfa>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    2de6 <f+0x1ce6>
cmp    $0x3,%r9
jb     2f07 <f+0x1e07>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    2e04 <f+0x1d04>
jmp    2f07 <f+0x1e07>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    2e66 <f+0x1d66>
xor    %eax,%eax
jmp    2ec4 <f+0x1dc4>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    2e6c <f+0x1d6c>
test   %r9,%r9
je     2efe <f+0x1dfe>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    2edf <f+0x1ddf>
cmp    %r8,%rcx
jne    2dd4 <f+0x1cd4>
test   %edi,%edi
jle    3301 <f+0x2201>
cmp    $0x8,%edi
jb     2f26 <f+0x1e26>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    2f94 <f+0x1e94>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    2f94 <f+0x1e94>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     2f4e <f+0x1e4e>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    2f3a <f+0x1e3a>
cmp    $0x3,%r9
jb     305b <f+0x1f5b>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    2f58 <f+0x1e58>
jmp    305b <f+0x1f5b>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    2fba <f+0x1eba>
xor    %eax,%eax
jmp    3018 <f+0x1f18>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    2fc0 <f+0x1ec0>
test   %r9,%r9
je     3052 <f+0x1f52>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    3033 <f+0x1f33>
cmp    %r8,%rcx
jne    2f28 <f+0x1e28>
test   %edi,%edi
jle    3301 <f+0x2201>
cmp    $0x8,%edi
jb     307a <f+0x1f7a>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    30e8 <f+0x1fe8>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    30e8 <f+0x1fe8>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     30a2 <f+0x1fa2>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    308e <f+0x1f8e>
cmp    $0x3,%r9
jb     31af <f+0x20af>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    30ac <f+0x1fac>
jmp    31af <f+0x20af>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    310e <f+0x200e>
xor    %eax,%eax
jmp    316c <f+0x206c>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    3114 <f+0x2014>
test   %r9,%r9
je     31a6 <f+0x20a6>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %eax,%eax
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    3187 <f+0x2087>
cmp    %r8,%rcx
jne    307c <f+0x1f7c>
test   %edi,%edi
jle    3301 <f+0x2201>
cmp    $0x8,%edi
jb     31ce <f+0x20ce>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    323c <f+0x213c>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    323c <f+0x213c>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
add    %r8,%rax
mov    %r8,%rdi
and    $0x3,%rdi
je     31f6 <f+0x20f6>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    31e2 <f+0x20e2>
cmp    $0x3,%rax
jb     3301 <f+0x2201>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    3200 <f+0x2100>
jmp    3301 <f+0x2201>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    3262 <f+0x2162>
xor    %eax,%eax
jmp    32c0 <f+0x21c0>
and    $0xfffffffffffffffc,%rdi
xor    %eax,%eax
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rdi
jne    3268 <f+0x2168>
test   %r9,%r9
je     32f8 <f+0x21f8>
lea    (%rdx,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%rax
add    $0x10,%rax
shl    $0x5,%r9
xor    %edi,%edi
movups -0x10(%rax,%rdi,1),%xmm0
movups (%rax,%rdi,1),%xmm1
movups %xmm0,-0x10(%r10,%rdi,1)
movups %xmm1,(%r10,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r9
jne    32db <f+0x21db>
cmp    %r8,%rcx
jne    31d0 <f+0x20d0>
ret

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

LLVM IR (-O2):
define void @f(i32 %0, float* %1, float* writeonly %2) {
%4 = icmp sgt i32 %0, 0
br i1 %4, label %5, label %3154
5: ; preds = %3
%6 = zext i32 %0 to i64
%7 = icmp ult i32 %0, 8
br i1 %7, label %93, label %8
8: ; preds = %5
%9 = getelementptr float, float* %2, i64 %6
%10 = getelementptr float, float* %1, i64 %6
%11 = icmp ugt float* %10, %2
%12 = icmp ugt float* %9, %1
%13 = and i1 %11, %12
br i1 %13, label %93, label %14
14: ; preds = %8
%15 = and i64 %6, 4294967288
%16 = add nsw i64 %15, -8
%17 = lshr exact i64 %16, 3
%18 = add nuw nsw i64 %17, 1
%19 = and i64 %18, 3
%20 = icmp ult i64 %16, 24
br i1 %20, label %72, label %21
21: ; preds = %14
%22 = and i64 %18, 4611686018427387900
br label %23
23: ; preds = %23, %21
%24 = phi i64 [ 0, %21 ], [ %69, %23 ]
%25 = phi i64 [ 0, %21 ], [ %70, %23 ]
%26 = getelementptr inbounds float, float* %1, i64 %24
%27 = bitcast float* %26 to <4 x float>*
%28 = load <4 x float>, <4 x float>* %27
%29 = getelementptr inbounds float, float* %26, i64 4
%30 = bitcast float* %29 to <4 x float>*
%31 = load <4 x float>, <4 x float>* %30
%32 = getelementptr inbounds float, float* %2, i64 %24
%33 = bitcast float* %32 to <4 x float>*
store <4 x float> %28, <4 x float>* %33
%34 = getelementptr inbounds float, float* %32, i64 4
%35 = bitcast float* %34 to <4 x float>*
store <4 x float> %31, <4 x float>* %35
%36 = or i64 %24, 8
%37 = getelementptr inbounds float, float* %1, i64 %36
%38 = bitcast float* %37 to <4 x float>*
%39 = load <4 x float>, <4 x float>* %38
%40 = getelementptr inbounds float, float* %37, i64 4
%41 = bitcast float* %40 to <4 x float>*
%42 = load <4 x float>, <4 x float>* %41
%43 = getelementptr inbounds float, float* %2, i64 %36
%44 = bitcast float* %43 to <4 x float>*
store <4 x float> %39, <4 x float>* %44
%45 = getelementptr inbounds float, float* %43, i64 4
%46 = bitcast float* %45 to <4 x float>*
store <4 x float> %42, <4 x float>* %46
%47 = or i64 %24, 16
%48 = getelementptr inbounds float, float* %1, i64 %47
%49 = bitcast float* %48 to <4 x float>*
%50 = load <4 x float>, <4 x float>* %49
%51 = getelementptr inbounds float, float* %48, i64 4
%52 = bitcast float* %51 to <4 x float>*
%53 = load <4 x float>, <4 x float>* %52
%54 = getelementptr inbounds float, float* %2, i64 %47
%55 = bitcast float* %54 to <4 x float>*
store <4 x float> %50, <4 x float>* %55
%56 = getelementptr inbounds float, float* %54, i64 4
%57 = bitcast float* %56 to <4 x float>*
store <4 x float> %53, <4 x float>* %57
%58 = or i64 %24, 24
%59 = getelementptr inbounds float, float* %1, i64 %58
%60 = bitcast float* %59 to <4 x float>*
%61 = load <4 x float>, <4 x float>* %60
%62 = getelementptr inbounds float, float* %59, i64 4
%63 = bitcast float* %62 to <4 x float>*
%64 = load <4 x float>, <4 x float>* %63
%65 = getelementptr inbounds float, float* %2, i64 %58
%66 = bitcast float* %65 to <4 x float>*
store <4 x float> %61, <4 x float>* %66
%67 = getelementptr inbounds float, float* %65, i64 4
%68 = bitcast float* %67 to <4 x float>*
store <4 x float> %64, <4 x float>* %68
%69 = add nuw i64 %24, 32
%70 = add i64 %25, 4
%71 = icmp eq i64 %70, %22
br i1 %71, label %72, label %23
72: ; preds = %23, %14
%73 = phi i64 [ 0, %14 ], [ %69, %23 ]
%74 = icmp eq i64 %19, 0
br i1 %74, label %91, label %75
75: ; preds = %72, %75
%76 = phi i64 [ %88, %75 ], [ %73, %72 ]
%77 = phi i64 [ %89, %75 ], [ 0, %72 ]
%78 = getelementptr inbounds float, float* %1, i64 %76
%79 = bitcast float* %78 to <4 x float>*
%80 = load <4 x float>, <4 x float>* %79
%81 = getelementptr inbounds float, float* %78, i64 4
%82 = bitcast float* %81 to <4 x float>*
%83 = load <4 x float>, <4 x float>* %82
%84 = getelementptr inbounds float, float* %2, i64 %76
%85 = bitcast float* %84 to <4 x float>*
store <4 x float> %80, <4 x float>* %85
%86 = getelementptr inbounds float, float* %84, i64 4
%87 = bitcast float* %86 to <4 x float>*
store <4 x float> %83, <4 x float>* %87
%88 = add nuw i64 %76, 8
%89 = add i64 %77, 1
%90 = icmp eq i64 %89, %19
br i1 %90, label %91, label %75
91: ; preds = %75, %72
%92 = icmp eq i64 %15, %6
br i1 %92, label %111, label %93
93: ; preds = %8, %5, %91
%94 = phi i64 [ 0, %8 ], [ 0, %5 ], [ %15, %91 ]
%95 = xor i64 %94, -1
%96 = add nsw i64 %95, %6
%97 = and i64 %6, 3
%98 = icmp eq i64 %97, 0
br i1 %98, label %108, label %99
99: ; preds = %93, %99
%100 = phi i64 [ %105, %99 ], [ %94, %93 ]
%101 = phi i64 [ %106, %99 ], [ 0, %93 ]
%102 = getelementptr inbounds float, float* %1, i64 %100
%103 = load float, float* %102
%104 = getelementptr inbounds float, float* %2, i64 %100
store float %103, float* %104
%105 = add nuw nsw i64 %100, 1
%106 = add i64 %101, 1
%107 = icmp eq i64 %106, %97
br i1 %107, label %108, label %99
108: ; preds = %99, %93
%109 = phi i64 [ %94, %93 ], [ %105, %99 ]
%110 = icmp ult i64 %96, 3
br i1 %110, label %111, label %218
111: ; preds = %108, %218, %91
br i1 %4, label %112, label %3154
112: ; preds = %111
%113 = zext i32 %0 to i64
%114 = icmp ult i32 %0, 8
br i1 %114, label %200, label %115
115: ; preds = %112
%116 = getelementptr float, float* %2, i64 %6
%117 = getelementptr float, float* %1, i64 %6
%118 = icmp ugt float* %117, %2
%119 = icmp ugt float* %116, %1
%120 = and i1 %118, %119
br i1 %120, label %200, label %121
121: ; preds = %115
%122 = and i64 %6, 4294967288
%123 = add nsw i64 %122, -8
%124 = lshr exact i64 %123, 3
%125 = add nuw nsw i64 %124, 1
%126 = and i64 %125, 3
%127 = icmp ult i64 %123, 24
br i1 %127, label %179, label %128
128: ; preds = %121
%129 = and i64 %125, 4611686018427387900
br label %130
130: ; preds = %130, %128
%131 = phi i64 [ 0, %128 ], [ %176, %130 ]
%132 = phi i64 [ 0, %128 ], [ %177, %130 ]
%133 = getelementptr inbounds float, float* %1, i64 %131
%134 = bitcast float* %133 to <4 x float>*
%135 = load <4 x float>, <4 x float>* %134
%136 = getelementptr inbounds float, float* %133, i64 4
%137 = bitcast float* %136 to <4 x float>*
%138 = load <4 x float>, <4 x float>* %137
%139 = getelementptr inbounds float, float* %2, i64 %131
%140 = bitcast float* %139 to <4 x float>*
store <4 x float> %135, <4 x float>* %140
%141 = getelementptr inbounds float, float* %139, i64 4
%142 = bitcast float* %141 to <4 x float>*
store <4 x float> %138, <4 x float>* %142
%143 = or i64 %131, 8
%144 = getelementptr inbounds float, float* %1, i64 %143
%145 = bitcast float* %144 to <4 x float>*
%146 = load <4 x float>, <4 x float>* %145
%147 = getelementptr inbounds float, float* %144, i64 4
%148 = bitcast float* %147 to <4 x float>*
%149 = load <4 x float>, <4 x float>* %148
%150 = getelementptr inbounds float, float* %2, i64 %143
%151 = bitcast float* %150 to <4 x float>*
store <4 x float> %146, <4 x float>* %151
%152 = getelementptr inbounds float, float* %150, i64 4
%153 = bitcast float* %152 to <4 x float>*
store <4 x float> %149, <4 x float>* %153
%154 = or i64 %131, 16
%155 = getelementptr inbounds float, float* %1, i64 %154
%156 = bitcast float* %155 to <4 x float>*
%157 = load <4 x float>, <4 x float>* %156
%158 = getelementptr inbounds float, float* %155, i64 4
%159 = bitcast float* %158 to <4 x float>*
%160 = load <4 x float>, <4 x float>* %159
%161 = getelementptr inbounds float, float* %2, i64 %154
%162 = bitcast float* %161 to <4 x float>*
store <4 x float> %157, <4 x float>* %162
%163 = getelementptr inbounds float, float* %161, i64 4
%164 = bitcast float* %163 to <4 x float>*
store <4 x float> %160, <4 x float>* %164
%165 = or i64 %131, 24
%166 = getelementptr inbounds float, float* %1, i64 %165
%167 = bitcast float* %166 to <4 x float>*
%168 = load <4 x float>, <4 x float>* %167
%169 = getelementptr inbounds float, float* %166, i64 4
%170 = bitcast float* %169 to <4 x float>*
%171 = load <4 x float>, <4 x float>* %170
%172 = getelementptr inbounds float, float* %2, i64 %165
%173 = bitcast float* %172 to <4 x float>*
store <4 x float> %168, <4 x float>* %173
%174 = getelementptr inbounds float, float* %172, i64 4
%175 = bitcast float* %174 to <4 x float>*
store <4 x float> %171, <4 x float>* %175
%176 = add nuw i64 %131, 32
%177 = add i64 %132, 4
%178 = icmp eq i64 %177, %129
br i1 %178, label %179, label %130
179: ; preds = %130, %121
%180 = phi i64 [ 0, %121 ], [ %176, %130 ]
%181 = icmp eq i64 %126, 0
br i1 %181, label %198, label %182
182: ; preds = %179, %182
%183 = phi i64 [ %195, %182 ], [ %180, %179 ]
%184 = phi i64 [ %196, %182 ], [ 0, %179 ]
%185 = getelementptr inbounds float, float* %1, i64 %183
%186 = bitcast float* %185 to <4 x float>*
%187 = load <4 x float>, <4 x float>* %186
%188 = getelementptr inbounds float, float* %185, i64 4
%189 = bitcast float* %188 to <4 x float>*
%190 = load <4 x float>, <4 x float>* %189
%191 = getelementptr inbounds float, float* %2, i64 %183
%192 = bitcast float* %191 to <4 x float>*
store <4 x float> %187, <4 x float>* %192
%193 = getelementptr inbounds float, float* %191, i64 4
%194 = bitcast float* %193 to <4 x float>*
store <4 x float> %190, <4 x float>* %194
%195 = add nuw i64 %183, 8
%196 = add i64 %184, 1
%197 = icmp eq i64 %196, %126
br i1 %197, label %198, label %182
198: ; preds = %182, %179
%199 = icmp eq i64 %122, %6
br i1 %199, label %237, label %200
200: ; preds = %115, %112, %198
%201 = phi i64 [ 0, %115 ], [ 0, %112 ], [ %122, %198 ]
%202 = xor i64 %201, -1
%203 = add nsw i64 %202, %6
%204 = and i64 %6, 3
%205 = icmp eq i64 %204, 0
br i1 %205, label %215, label %206
206: ; preds = %200, %206
%207 = phi i64 [ %212, %206 ], [ %201, %200 ]
%208 = phi i64 [ %213, %206 ], [ 0, %200 ]
%209 = getelementptr inbounds float, float* %1, i64 %207
%210 = load float, float* %209
%211 = getelementptr inbounds float, float* %2, i64 %207
store float %210, float* %211
%212 = add nuw nsw i64 %207, 1
%213 = add i64 %208, 1
%214 = icmp eq i64 %213, %204
br i1 %214, label %215, label %206
215: ; preds = %206, %200
%216 = phi i64 [ %201, %200 ], [ %212, %206 ]
%217 = icmp ult i64 %203, 3
br i1 %217, label %237, label %344
218: ; preds = %108, %218
%219 = phi i64 [ %235, %218 ], [ %109, %108 ]
%220 = getelementptr inbounds float, float* %1, i64 %219
%221 = load float, float* %220
%222 = getelementptr inbounds float, float* %2, i64 %219
store float %221, float* %222
%223 = add nuw nsw i64 %219, 1
%224 = getelementptr inbounds float, float* %1, i64 %223
%225 = load float, float* %224
%226 = getelementptr inbounds float, float* %2, i64 %223
store float %225, float* %226
%227 = add nuw nsw i64 %219, 2
%228 = getelementptr inbounds float, float* %1, i64 %227
%229 = load float, float* %228
%230 = getelementptr inbounds float, float* %2, i64 %227
store float %229, float* %230
%231 = add nuw nsw i64 %219, 3
%232 = getelementptr inbounds float, float* %1, i64 %231
%233 = load float, float* %232
%234 = getelementptr inbounds float, float* %2, i64 %231
store float %233, float* %234
%235 = add nuw nsw i64 %219, 4
%236 = icmp eq i64 %235, %6
br i1 %236, label %111, label %218
237: ; preds = %215, %344, %198
br i1 %4, label %238, label %3154
238: ; preds = %237
%239 = zext i32 %0 to i64
%240 = icmp ult i32 %0, 8
br i1 %240, label %326, label %241
241: ; preds = %238
%242 = getelementptr float, float* %2, i64 %6
%243 = getelementptr float, float* %1, i64 %6
%244 = icmp ugt float* %243, %2
%245 = icmp ugt float* %242, %1
%246 = and i1 %244, %245
br i1 %246, label %326, label %247
247: ; preds = %241
%248 = and i64 %6, 4294967288
%249 = add nsw i64 %248, -8
%250 = lshr exact i64 %249, 3
%251 = add nuw nsw i64 %250, 1
%252 = and i64 %251, 3
%253 = icmp ult i64 %249, 24
br i1 %253, label %305, label %254
254: ; preds = %247
%255 = and i64 %251, 4611686018427387900
br label %256
256: ; preds = %256, %254
%257 = phi i64 [ 0, %254 ], [ %302, %256 ]
%258 = phi i64 [ 0, %254 ], [ %303, %256 ]
%259 = getelementptr inbounds float, float* %1, i64 %257
%260 = bitcast float* %259 to <4 x float>*
%261 = load <4 x float>, <4 x float>* %260
%262 = getelementptr inbounds float, float* %259, i64 4
%263 = bitcast float* %262 to <4 x float>*
%264 = load <4 x float>, <4 x float>* %263
%265 = getelementptr inbounds float, float* %2, i64 %257
%266 = bitcast float* %265 to <4 x float>*
store <4 x float> %261, <4 x float>* %266
%267 = getelementptr inbounds float, float* %265, i64 4
%268 = bitcast float* %267 to <4 x float>*
store <4 x float> %264, <4 x float>* %268
%269 = or i64 %257, 8
%270 = getelementptr inbounds float, float* %1, i64 %269
%271 = bitcast float* %270 to <4 x float>*
%272 = load <4 x float>, <4 x float>* %271
%273 = getelementptr inbounds float, float* %270, i64 4
%274 = bitcast float* %273 to <4 x float>*
%275 = load <4 x float>, <4 x float>* %274
%276 = getelementptr inbounds float, float* %2, i64 %269
%277 = bitcast float* %276 to <4 x float>*
store <4 x float> %272, <4 x float>* %277
%278 = getelementptr inbounds float, float* %276, i64 4
%279 = bitcast float* %278 to <4 x float>*
store <4 x float> %275, <4 x float>* %279
%280 = or i64 %257, 16
%281 = getelementptr inbounds float, float* %1, i64 %280
%282 = bitcast float* %281 to <4 x float>*
%283 = load <4 x float>, <4 x float>* %282
%284 = getelementptr inbounds float, float* %281, i64 4
%285 = bitcast float* %284 to <4 x float>*
%286 = load <4 x float>, <4 x float>* %285
%287 = getelementptr inbounds float, float* %2, i64 %280
%288 = bitcast float* %287 to <4 x float>*
store <4 x float> %283, <4 x float>* %288
%289 = getelementptr inbounds float, float* %287, i64 4
%290 = bitcast float* %289 to <4 x float>*
store <4 x float> %286, <4 x float>* %290
%291 = or i64 %257, 24
%292 = getelementptr inbounds float, float* %1, i64 %291
%293 = bitcast float* %292 to <4 x float>*
%294 = load <4 x float>, <4 x float>* %293
%295 = getelementptr inbounds float, float* %292, i64 4
%296 = bitcast float* %295 to <4 x float>*
%297 = load <4 x float>, <4 x float>* %296
%298 = getelementptr inbounds float, float* %2, i64 %291
%299 = bitcast float* %298 to <4 x float>*
store <4 x float> %294, <4 x float>* %299
%300 = getelementptr inbounds float, float* %298, i64 4
%301 = bitcast float* %300 to <4 x float>*
store <4 x float> %297, <4 x float>* %301
%302 = add nuw i64 %257, 32
%303 = add i64 %258, 4
%304 = icmp eq i64 %303, %255
br i1 %304, label %305, label %256
305: ; preds = %256, %247
%306 = phi i64 [ 0, %247 ], [ %302, %256 ]
%307 = icmp eq i64 %252, 0
br i1 %307, label %324, label %308
308: ; preds = %305, %308
%309 = phi i64 [ %321, %308 ], [ %306, %305 ]
%310 = phi i64 [ %322, %308 ], [ 0, %305 ]
%311 = getelementptr inbounds float, float* %1, i64 %309
%312 = bitcast float* %311 to <4 x float>*
%313 = load <4 x float>, <4 x float>* %312
%314 = getelementptr inbounds float, float* %311, i64 4
%315 = bitcast float* %314 to <4 x float>*
%316 = load <4 x float>, <4 x float>* %315
%317 = getelementptr inbounds float, float* %2, i64 %309
%318 = bitcast float* %317 to <4 x float>*
store <4 x float> %313, <4 x float>* %318
%319 = getelementptr inbounds float, float* %317, i64 4
%320 = bitcast float* %319 to <4 x float>*
store <4 x float> %316, <4 x float>* %320
%321 = add nuw i64 %309, 8
%322 = add i64 %310, 1
%323 = icmp eq i64 %322, %252
br i1 %323, label %324, label %308
324: ; preds = %308, %305
%325 = icmp eq i64 %248, %6
br i1 %325, label %363, label %326
326: ; preds = %241, %238, %324
%327 = phi i64 [ 0, %241 ], [ 0, %238 ], [ %248, %324 ]
%328 = xor i64 %327, -1
%329 = add nsw i64 %328, %6
%330 = and i64 %6, 3
%331 = icmp eq i64 %330, 0
br i1 %331, label %341, label %332
332: ; preds = %326, %332
%333 = phi i64 [ %338, %332 ], [ %327, %326 ]
%334 = phi i64 [ %339, %332 ], [ 0, %326 ]
%335 = getelementptr inbounds float, float* %1, i64 %333
%336 = load float, float* %335
%337 = getelementptr inbounds float, float* %2, i64 %333
store float %336, float* %337
%338 = add nuw nsw i64 %333, 1
%339 = add i64 %334, 1
%340 = icmp eq i64 %339, %330
br i1 %340, label %341, label %332
341: ; preds = %332, %326
%342 = phi i64 [ %327, %326 ], [ %338, %332 ]
%343 = icmp ult i64 %329, 3
br i1 %343, label %363, label %470
344: ; preds = %215, %344
%345 = phi i64 [ %361, %344 ], [ %216, %215 ]
%346 = getelementptr inbounds float, float* %1, i64 %345
%347 = load float, float* %346
%348 = getelementptr inbounds float, float* %2, i64 %345
store float %347, float* %348
%349 = add nuw nsw i64 %345, 1
%350 = getelementptr inbounds float, float* %1, i64 %349
%351 = load float, float* %350
%352 = getelementptr inbounds float, float* %2, i64 %349
store float %351, float* %352
%353 = add nuw nsw i64 %345, 2
%354 = getelementptr inbounds float, float* %1, i64 %353
%355 = load float, float* %354
%356 = getelementptr inbounds float, float* %2, i64 %353
store float %355, float* %356
%357 = add nuw nsw i64 %345, 3
%358 = getelementptr inbounds float, float* %1, i64 %357
%359 = load float, float* %358
%360 = getelementptr inbounds float, float* %2, i64 %357
store float %359, float* %360
%361 = add nuw nsw i64 %345, 4
%362 = icmp eq i64 %361, %113
br i1 %362, label %237, label %344
363: ; preds = %341, %470, %324
br i1 %4, label %364, label %3154
364: ; preds = %363
%365 = zext i32 %0 to i64
%366 = icmp ult i32 %0, 8
br i1 %366, label %452, label %367
367: ; preds = %364
%368 = getelementptr float, float* %2, i64 %6
%369 = getelementptr float, float* %1, i64 %6
%370 = icmp ugt float* %369, %2
%371 = icmp ugt float* %368, %1
%372 = and i1 %370, %371
br i1 %372, label %452, label %373
373: ; preds = %367
%374 = and i64 %6, 4294967288
%375 = add nsw i64 %374, -8
%376 = lshr exact i64 %375, 3
%377 = add nuw nsw i64 %376, 1
%378 = and i64 %377, 3
%379 = icmp ult i64 %375, 24
br i1 %379, label %431, label %380
380: ; preds = %373
%381 = and i64 %377, 4611686018427387900
br label %382
382: ; preds = %382, %380
%383 = phi i64 [ 0, %380 ], [ %428, %382 ]
%384 = phi i64 [ 0, %380 ], [ %429, %382 ]
%385 = getelementptr inbounds float, float* %1, i64 %383
%386 = bitcast float* %385 to <4 x float>*
%387 = load <4 x float>, <4 x float>* %386
%388 = getelementptr inbounds float, float* %385, i64 4
%389 = bitcast float* %388 to <4 x float>*
%390 = load <4 x float>, <4 x float>* %389
%391 = getelementptr inbounds float, float* %2, i64 %383
%392 = bitcast float* %391 to <4 x float>*
store <4 x float> %387, <4 x float>* %392
%393 = getelementptr inbounds float, float* %391, i64 4
%394 = bitcast float* %393 to <4 x float>*
store <4 x float> %390, <4 x float>* %394
%395 = or i64 %383, 8
%396 = getelementptr inbounds float, float* %1, i64 %395
%397 = bitcast float* %396 to <4 x float>*
%398 = load <4 x float>, <4 x float>* %397
%399 = getelementptr inbounds float, float* %396, i64 4
%400 = bitcast float* %399 to <4 x float>*
%401 = load <4 x float>, <4 x float>* %400
%402 = getelementptr inbounds float, float* %2, i64 %395
%403 = bitcast float* %402 to <4 x float>*
store <4 x float> %398, <4 x float>* %403
%404 = getelementptr inbounds float, float* %402, i64 4
%405 = bitcast float* %404 to <4 x float>*
store <4 x float> %401, <4 x float>* %405
%406 = or i64 %383, 16
%407 = getelementptr inbounds float, float* %1, i64 %406
%408 = bitcast float* %407 to <4 x float>*
%409 = load <4 x float>, <4 x float>* %408
%410 = getelementptr inbounds float, float* %407, i64 4
%411 = bitcast float* %410 to <4 x float>*
%412 = load <4 x float>, <4 x float>* %411
%413 = getelementptr inbounds float, float* %2, i64 %406
%414 = bitcast float* %413 to <4 x float>*
store <4 x float> %409, <4 x float>* %414
%415 = getelementptr inbounds float, float* %413, i64 4
%416 = bitcast float* %415 to <4 x float>*
store <4 x float> %412, <4 x float>* %416
%417 = or i64 %383, 24
%418 = getelementptr inbounds float, float* %1, i64 %417
%419 = bitcast float* %418 to <4 x float>*
%420 = load <4 x float>, <4 x float>* %419
%421 = getelementptr inbounds float, float* %418, i64 4
%422 = bitcast float* %421 to <4 x float>*
%423 = load <4 x float>, <4 x float>* %422
%424 = getelementptr inbounds float, float* %2, i64 %417
%425 = bitcast float* %424 to <4 x float>*
store <4 x float> %420, <4 x float>* %425
%426 = getelementptr inbounds float, float* %424, i64 4
%427 = bitcast float* %426 to <4 x float>*
store <4 x float> %423, <4 x float>* %427
%428 = add nuw i64 %383, 32
%429 = add i64 %384, 4
%430 = icmp eq i64 %429, %381
br i1 %430, label %431, label %382
431: ; preds = %382, %373
%432 = phi i64 [ 0, %373 ], [ %428, %382 ]
%433 = icmp eq i64 %378, 0
br i1 %433, label %450, label %434
434: ; preds = %431, %434
%435 = phi i64 [ %447, %434 ], [ %432, %431 ]
%436 = phi i64 [ %448, %434 ], [ 0, %431 ]
%437 = getelementptr inbounds float, float* %1, i64 %435
%438 = bitcast float* %437 to <4 x float>*
%439 = load <4 x float>, <4 x float>* %438
%440 = getelementptr inbounds float, float* %437, i64 4
%441 = bitcast float* %440 to <4 x float>*
%442 = load <4 x float>, <4 x float>* %441
%443 = getelementptr inbounds float, float* %2, i64 %435
%444 = bitcast float* %443 to <4 x float>*
store <4 x float> %439, <4 x float>* %444
%445 = getelementptr inbounds float, float* %443, i64 4
%446 = bitcast float* %445 to <4 x float>*
store <4 x float> %442, <4 x float>* %446
%447 = add nuw i64 %435, 8
%448 = add i64 %436, 1
%449 = icmp eq i64 %448, %378
br i1 %449, label %450, label %434
450: ; preds = %434, %431
%451 = icmp eq i64 %374, %6
br i1 %451, label %489, label %452
452: ; preds = %367, %364, %450
%453 = phi i64 [ 0, %367 ], [ 0, %364 ], [ %374, %450 ]
%454 = xor i64 %453, -1
%455 = add nsw i64 %454, %6
%456 = and i64 %6, 3
%457 = icmp eq i64 %456, 0
br i1 %457, label %467, label %458
458: ; preds = %452, %458
%459 = phi i64 [ %464, %458 ], [ %453, %452 ]
%460 = phi i64 [ %465, %458 ], [ 0, %452 ]
%461 = getelementptr inbounds float, float* %1, i64 %459
%462 = load float, float* %461
%463 = getelementptr inbounds float, float* %2, i64 %459
store float %462, float* %463
%464 = add nuw nsw i64 %459, 1
%465 = add i64 %460, 1
%466 = icmp eq i64 %465, %456
br i1 %466, label %467, label %458
467: ; preds = %458, %452
%468 = phi i64 [ %453, %452 ], [ %464, %458 ]
%469 = icmp ult i64 %455, 3
br i1 %469, label %489, label %596
470: ; preds = %341, %470
%471 = phi i64 [ %487, %470 ], [ %342, %341 ]
%472 = getelementptr inbounds float, float* %1, i64 %471
%473 = load float, float* %472
%474 = getelementptr inbounds float, float* %2, i64 %471
store float %473, float* %474
%475 = add nuw nsw i64 %471, 1
%476 = getelementptr inbounds float, float* %1, i64 %475
%477 = load float, float* %476
%478 = getelementptr inbounds float, float* %2, i64 %475
store float %477, float* %478
%479 = add nuw nsw i64 %471, 2
%480 = getelementptr inbounds float, float* %1, i64 %479
%481 = load float, float* %480
%482 = getelementptr inbounds float, float* %2, i64 %479
store float %481, float* %482
%483 = add nuw nsw i64 %471, 3
%484 = getelementptr inbounds float, float* %1, i64 %483
%485 = load float, float* %484
%486 = getelementptr inbounds float, float* %2, i64 %483
store float %485, float* %486
%487 = add nuw nsw i64 %471, 4
%488 = icmp eq i64 %487, %239
br i1 %488, label %363, label %470
489: ; preds = %467, %596, %450
br i1 %4, label %490, label %3154
490: ; preds = %489
%491 = zext i32 %0 to i64
%492 = icmp ult i32 %0, 8
br i1 %492, label %578, label %493
493: ; preds = %490
%494 = getelementptr float, float* %2, i64 %6
%495 = getelementptr float, float* %1, i64 %6
%496 = icmp ugt float* %495, %2
%497 = icmp ugt float* %494, %1
%498 = and i1 %496, %497
br i1 %498, label %578, label %499
499: ; preds = %493
%500 = and i64 %6, 4294967288
%501 = add nsw i64 %500, -8
%502 = lshr exact i64 %501, 3
%503 = add nuw nsw i64 %502, 1
%504 = and i64 %503, 3
%505 = icmp ult i64 %501, 24
br i1 %505, label %557, label %506
506: ; preds = %499
%507 = and i64 %503, 4611686018427387900
br label %508
508: ; preds = %508, %506
%509 = phi i64 [ 0, %506 ], [ %554, %508 ]
%510 = phi i64 [ 0, %506 ], [ %555, %508 ]
%511 = getelementptr inbounds float, float* %1, i64 %509
%512 = bitcast float* %511 to <4 x float>*
%513 = load <4 x float>, <4 x float>* %512
%514 = getelementptr inbounds float, float* %511, i64 4
%515 = bitcast float* %514 to <4 x float>*
%516 = load <4 x float>, <4 x float>* %515
%517 = getelementptr inbounds float, float* %2, i64 %509
%518 = bitcast float* %517 to <4 x float>*
store <4 x float> %513, <4 x float>* %518
%519 = getelementptr inbounds float, float* %517, i64 4
%520 = bitcast float* %519 to <4 x float>*
store <4 x float> %516, <4 x float>* %520
%521 = or i64 %509, 8
%522 = getelementptr inbounds float, float* %1, i64 %521
%523 = bitcast float* %522 to <4 x float>*
%524 = load <4 x float>, <4 x float>* %523
%525 = getelementptr inbounds float, float* %522, i64 4
%526 = bitcast float* %525 to <4 x float>*
%527 = load <4 x float>, <4 x float>* %526
%528 = getelementptr inbounds float, float* %2, i64 %521
%529 = bitcast float* %528 to <4 x float>*
store <4 x float> %524, <4 x float>* %529
%530 = getelementptr inbounds float, float* %528, i64 4
%531 = bitcast float* %530 to <4 x float>*
store <4 x float> %527, <4 x float>* %531
%532 = or i64 %509, 16
%533 = getelementptr inbounds float, float* %1, i64 %532
%534 = bitcast float* %533 to <4 x float>*
%535 = load <4 x float>, <4 x float>* %534
%536 = getelementptr inbounds float, float* %533, i64 4
%537 = bitcast float* %536 to <4 x float>*
%538 = load <4 x float>, <4 x float>* %537
%539 = getelementptr inbounds float, float* %2, i64 %532
%540 = bitcast float* %539 to <4 x float>*
store <4 x float> %535, <4 x float>* %540
%541 = getelementptr inbounds float, float* %539, i64 4
%542 = bitcast float* %541 to <4 x float>*
store <4 x float> %538, <4 x float>* %542
%543 = or i64 %509, 24
%544 = getelementptr inbounds float, float* %1, i64 %543
%545 = bitcast float* %544 to <4 x float>*
%546 = load <4 x float>, <4 x float>* %545
%547 = getelementptr inbounds float, float* %544, i64 4
%548 = bitcast float* %547 to <4 x float>*
%549 = load <4 x float>, <4 x float>* %548
%550 = getelementptr inbounds float, float* %2, i64 %543
%551 = bitcast float* %550 to <4 x float>*
store <4 x float> %546, <4 x float>* %551
%552 = getelementptr inbounds float, float* %550, i64 4
%553 = bitcast float* %552 to <4 x float>*
store <4 x float> %549, <4 x float>* %553
%554 = add nuw i64 %509, 32
%555 = add i64 %510, 4
%556 = icmp eq i64 %555, %507
br i1 %556, label %557, label %508
557: ; preds = %508, %499
%558 = phi i64 [ 0, %499 ], [ %554, %508 ]
%559 = icmp eq i64 %504, 0
br i1 %559, label %576, label %560
560: ; preds = %557, %560
%561 = phi i64 [ %573, %560 ], [ %558, %557 ]
%562 = phi i64 [ %574, %560 ], [ 0, %557 ]
%563 = getelementptr inbounds float, float* %1, i64 %561
%564 = bitcast float* %563 to <4 x float>*
%565 = load <4 x float>, <4 x float>* %564
%566 = getelementptr inbounds float, float* %563, i64 4
%567 = bitcast float* %566 to <4 x float>*
%568 = load <4 x float>, <4 x float>* %567
%569 = getelementptr inbounds float, float* %2, i64 %561
%570 = bitcast float* %569 to <4 x float>*
store <4 x float> %565, <4 x float>* %570
%571 = getelementptr inbounds float, float* %569, i64 4
%572 = bitcast float* %571 to <4 x float>*
store <4 x float> %568, <4 x float>* %572
%573 = add nuw i64 %561, 8
%574 = add i64 %562, 1
%575 = icmp eq i64 %574, %504
br i1 %575, label %576, label %560
576: ; preds = %560, %557
%577 = icmp eq i64 %500, %6
br i1 %577, label %615, label %578
578: ; preds = %493, %490, %576
%579 = phi i64 [ 0, %493 ], [ 0, %490 ], [ %500, %576 ]
%580 = xor i64 %579, -1
%581 = add nsw i64 %580, %6
%582 = and i64 %6, 3
%583 = icmp eq i64 %582, 0
br i1 %583, label %593, label %584
584: ; preds = %578, %584
%585 = phi i64 [ %590, %584 ], [ %579, %578 ]
%586 = phi i64 [ %591, %584 ], [ 0, %578 ]
%587 = getelementptr inbounds float, float* %1, i64 %585
%588 = load float, float* %587
%589 = getelementptr inbounds float, float* %2, i64 %585
store float %588, float* %589
%590 = add nuw nsw i64 %585, 1
%591 = add i64 %586, 1
%592 = icmp eq i64 %591, %582
br i1 %592, label %593, label %584
593: ; preds = %584, %578
%594 = phi i64 [ %579, %578 ], [ %590, %584 ]
%595 = icmp ult i64 %581, 3
br i1 %595, label %615, label %722
596: ; preds = %467, %596
%597 = phi i64 [ %613, %596 ], [ %468, %467 ]
%598 = getelementptr inbounds float, float* %1, i64 %597
%599 = load float, float* %598
%600 = getelementptr inbounds float, float* %2, i64 %597
store float %599, float* %600
%601 = add nuw nsw i64 %597, 1
%602 = getelementptr inbounds float, float* %1, i64 %601
%603 = load float, float* %602
%604 = getelementptr inbounds float, float* %2, i64 %601
store float %603, float* %604
%605 = add nuw nsw i64 %597, 2
%606 = getelementptr inbounds float, float* %1, i64 %605
%607 = load float, float* %606
%608 = getelementptr inbounds float, float* %2, i64 %605
store float %607, float* %608
%609 = add nuw nsw i64 %597, 3
%610 = getelementptr inbounds float, float* %1, i64 %609
%611 = load float, float* %610
%612 = getelementptr inbounds float, float* %2, i64 %609
store float %611, float* %612
%613 = add nuw nsw i64 %597, 4
%614 = icmp eq i64 %613, %365
br i1 %614, label %489, label %596
615: ; preds = %593, %722, %576
br i1 %4, label %616, label %3154
616: ; preds = %615
%617 = zext i32 %0 to i64
%618 = icmp ult i32 %0, 8
br i1 %618, label %704, label %619
619: ; preds = %616
%620 = getelementptr float, float* %2, i64 %6
%621 = getelementptr float, float* %1, i64 %6
%622 = icmp ugt float* %621, %2
%623 = icmp ugt float* %620, %1
%624 = and i1 %622, %623
br i1 %624, label %704, label %625
625: ; preds = %619
%626 = and i64 %6, 4294967288
%627 = add nsw i64 %626, -8
%628 = lshr exact i64 %627, 3
%629 = add nuw nsw i64 %628, 1
%630 = and i64 %629, 3
%631 = icmp ult i64 %627, 24
br i1 %631, label %683, label %632
632: ; preds = %625
%633 = and i64 %629, 4611686018427387900
br label %634
634: ; preds = %634, %632
%635 = phi i64 [ 0, %632 ], [ %680, %634 ]
%636 = phi i64 [ 0, %632 ], [ %681, %634 ]
%637 = getelementptr inbounds float, float* %1, i64 %635
%638 = bitcast float* %637 to <4 x float>*
%639 = load <4 x float>, <4 x float>* %638
%640 = getelementptr inbounds float, float* %637, i64 4
%641 = bitcast float* %640 to <4 x float>*
%642 = load <4 x float>, <4 x float>* %641
%643 = getelementptr inbounds float, float* %2, i64 %635
%644 = bitcast float* %643 to <4 x float>*
store <4 x float> %639, <4 x float>* %644
%645 = getelementptr inbounds float, float* %643, i64 4
%646 = bitcast float* %645 to <4 x float>*
store <4 x float> %642, <4 x float>* %646
%647 = or i64 %635, 8
%648 = getelementptr inbounds float, float* %1, i64 %647
%649 = bitcast float* %648 to <4 x float>*
%650 = load <4 x float>, <4 x float>* %649
%651 = getelementptr inbounds float, float* %648, i64 4
%652 = bitcast float* %651 to <4 x float>*
%653 = load <4 x float>, <4 x float>* %652
%654 = getelementptr inbounds float, float* %2, i64 %647
%655 = bitcast float* %654 to <4 x float>*
store <4 x float> %650, <4 x float>* %655
%656 = getelementptr inbounds float, float* %654, i64 4
%657 = bitcast float* %656 to <4 x float>*
store <4 x float> %653, <4 x float>* %657
%658 = or i64 %635, 16
%659 = getelementptr inbounds float, float* %1, i64 %658
%660 = bitcast float* %659 to <4 x float>*
%661 = load <4 x float>, <4 x float>* %660
%662 = getelementptr inbounds float, float* %659, i64 4
%663 = bitcast float* %662 to <4 x float>*
%664 = load <4 x float>, <4 x float>* %663
%665 = getelementptr inbounds float, float* %2, i64 %658
%666 = bitcast float* %665 to <4 x float>*
store <4 x float> %661, <4 x float>* %666
%667 = getelementptr inbounds float, float* %665, i64 4
%668 = bitcast float* %667 to <4 x float>*
store <4 x float> %664, <4 x float>* %668
%669 = or i64 %635, 24
%670 = getelementptr inbounds float, float* %1, i64 %669
%671 = bitcast float* %670 to <4 x float>*
%672 = load <4 x float>, <4 x float>* %671
%673 = getelementptr inbounds float, float* %670, i64 4
%674 = bitcast float* %673 to <4 x float>*
%675 = load <4 x float>, <4 x float>* %674
%676 = getelementptr inbounds float, float* %2, i64 %669
%677 = bitcast float* %676 to <4 x float>*
store <4 x float> %672, <4 x float>* %677
%678 = getelementptr inbounds float, float* %676, i64 4
%679 = bitcast float* %678 to <4 x float>*
store <4 x float> %675, <4 x float>* %679
%680 = add nuw i64 %635, 32
%681 = add i64 %636, 4
%682 = icmp eq i64 %681, %633
br i1 %682, label %683, label %634
683: ; preds = %634, %625
%684 = phi i64 [ 0, %625 ], [ %680, %634 ]
%685 = icmp eq i64 %630, 0
br i1 %685, label %702, label %686
686: ; preds = %683, %686
%687 = phi i64 [ %699, %686 ], [ %684, %683 ]
%688 = phi i64 [ %700, %686 ], [ 0, %683 ]
%689 = getelementptr inbounds float, float* %1, i64 %687
%690 = bitcast float* %689 to <4 x float>*
%691 = load <4 x float>, <4 x float>* %690
%692 = getelementptr inbounds float, float* %689, i64 4
%693 = bitcast float* %692 to <4 x float>*
%694 = load <4 x float>, <4 x float>* %693
%695 = getelementptr inbounds float, float* %2, i64 %687
%696 = bitcast float* %695 to <4 x float>*
store <4 x float> %691, <4 x float>* %696
%697 = getelementptr inbounds float, float* %695, i64 4
%698 = bitcast float* %697 to <4 x float>*
store <4 x float> %694, <4 x float>* %698
%699 = add nuw i64 %687, 8
%700 = add i64 %688, 1
%701 = icmp eq i64 %700, %630
br i1 %701, label %702, label %686
702: ; preds = %686, %683
%703 = icmp eq i64 %626, %6
br i1 %703, label %741, label %704
704: ; preds = %619, %616, %702
%705 = phi i64 [ 0, %619 ], [ 0, %616 ], [ %626, %702 ]
%706 = xor i64 %705, -1
%707 = add nsw i64 %706, %6
%708 = and i64 %6, 3
%709 = icmp eq i64 %708, 0
br i1 %709, label %719, label %710
710: ; preds = %704, %710
%711 = phi i64 [ %716, %710 ], [ %705, %704 ]
%712 = phi i64 [ %717, %710 ], [ 0, %704 ]
%713 = getelementptr inbounds float, float* %1, i64 %711
%714 = load float, float* %713
%715 = getelementptr inbounds float, float* %2, i64 %711
store float %714, float* %715
%716 = add nuw nsw i64 %711, 1
%717 = add i64 %712, 1
%718 = icmp eq i64 %717, %708
br i1 %718, label %719, label %710
719: ; preds = %710, %704
%720 = phi i64 [ %705, %704 ], [ %716, %710 ]
%721 = icmp ult i64 %707, 3
br i1 %721, label %741, label %848
722: ; preds = %593, %722
%723 = phi i64 [ %739, %722 ], [ %594, %593 ]
%724 = getelementptr inbounds float, float* %1, i64 %723
%725 = load float, float* %724
%726 = getelementptr inbounds float, float* %2, i64 %723
store float %725, float* %726
%727 = add nuw nsw i64 %723, 1
%728 = getelementptr inbounds float, float* %1, i64 %727
%729 = load float, float* %728
%730 = getelementptr inbounds float, float* %2, i64 %727
store float %729, float* %730
%731 = add nuw nsw i64 %723, 2
%732 = getelementptr inbounds float, float* %1, i64 %731
%733 = load float, float* %732
%734 = getelementptr inbounds float, float* %2, i64 %731
store float %733, float* %734
%735 = add nuw nsw i64 %723, 3
%736 = getelementptr inbounds float, float* %1, i64 %735
%737 = load float, float* %736
%738 = getelementptr inbounds float, float* %2, i64 %735
store float %737, float* %738
%739 = add nuw nsw i64 %723, 4
%740 = icmp eq i64 %739, %491
br i1 %740, label %615, label %722
741: ; preds = %719, %848, %702
br i1 %4, label %742, label %3154
742: ; preds = %741
%743 = zext i32 %0 to i64
%744 = icmp ult i32 %0, 8
br i1 %744, label %830, label %745
745: ; preds = %742
%746 = getelementptr float, float* %2, i64 %6
%747 = getelementptr float, float* %1, i64 %6
%748 = icmp ugt float* %747, %2
%749 = icmp ugt float* %746, %1
%750 = and i1 %748, %749
br i1 %750, label %830, label %751
751: ; preds = %745
%752 = and i64 %6, 4294967288
%753 = add nsw i64 %752, -8
%754 = lshr exact i64 %753, 3
%755 = add nuw nsw i64 %754, 1
%756 = and i64 %755, 3
%757 = icmp ult i64 %753, 24
br i1 %757, label %809, label %758
758: ; preds = %751
%759 = and i64 %755, 4611686018427387900
br label %760
760: ; preds = %760, %758
%761 = phi i64 [ 0, %758 ], [ %806, %760 ]
%762 = phi i64 [ 0, %758 ], [ %807, %760 ]
%763 = getelementptr inbounds float, float* %1, i64 %761
%764 = bitcast float* %763 to <4 x float>*
%765 = load <4 x float>, <4 x float>* %764
%766 = getelementptr inbounds float, float* %763, i64 4
%767 = bitcast float* %766 to <4 x float>*
%768 = load <4 x float>, <4 x float>* %767
%769 = getelementptr inbounds float, float* %2, i64 %761
%770 = bitcast float* %769 to <4 x float>*
store <4 x float> %765, <4 x float>* %770
%771 = getelementptr inbounds float, float* %769, i64 4
%772 = bitcast float* %771 to <4 x float>*
store <4 x float> %768, <4 x float>* %772
%773 = or i64 %761, 8
%774 = getelementptr inbounds float, float* %1, i64 %773
%775 = bitcast float* %774 to <4 x float>*
%776 = load <4 x float>, <4 x float>* %775
%777 = getelementptr inbounds float, float* %774, i64 4
%778 = bitcast float* %777 to <4 x float>*
%779 = load <4 x float>, <4 x float>* %778
%780 = getelementptr inbounds float, float* %2, i64 %773
%781 = bitcast float* %780 to <4 x float>*
store <4 x float> %776, <4 x float>* %781
%782 = getelementptr inbounds float, float* %780, i64 4
%783 = bitcast float* %782 to <4 x float>*
store <4 x float> %779, <4 x float>* %783
%784 = or i64 %761, 16
%785 = getelementptr inbounds float, float* %1, i64 %784
%786 = bitcast float* %785 to <4 x float>*
%787 = load <4 x float>, <4 x float>* %786
%788 = getelementptr inbounds float, float* %785, i64 4
%789 = bitcast float* %788 to <4 x float>*
%790 = load <4 x float>, <4 x float>* %789
%791 = getelementptr inbounds float, float* %2, i64 %784
%792 = bitcast float* %791 to <4 x float>*
store <4 x float> %787, <4 x float>* %792
%793 = getelementptr inbounds float, float* %791, i64 4
%794 = bitcast float* %793 to <4 x float>*
store <4 x float> %790, <4 x float>* %794
%795 = or i64 %761, 24
%796 = getelementptr inbounds float, float* %1, i64 %795
%797 = bitcast float* %796 to <4 x float>*
%798 = load <4 x float>, <4 x float>* %797
%799 = getelementptr inbounds float, float* %796, i64 4
%800 = bitcast float* %799 to <4 x float>*
%801 = load <4 x float>, <4 x float>* %800
%802 = getelementptr inbounds float, float* %2, i64 %795
%803 = bitcast float* %802 to <4 x float>*
store <4 x float> %798, <4 x float>* %803
%804 = getelementptr inbounds float, float* %802, i64 4
%805 = bitcast float* %804 to <4 x float>*
store <4 x float> %801, <4 x float>* %805
%806 = add nuw i64 %761, 32
%807 = add i64 %762, 4
%808 = icmp eq i64 %807, %759
br i1 %808, label %809, label %760
809: ; preds = %760, %751
%810 = phi i64 [ 0, %751 ], [ %806, %760 ]
%811 = icmp eq i64 %756, 0
br i1 %811, label %828, label %812
812: ; preds = %809, %812
%813 = phi i64 [ %825, %812 ], [ %810, %809 ]
%814 = phi i64 [ %826, %812 ], [ 0, %809 ]
%815 = getelementptr inbounds float, float* %1, i64 %813
%816 = bitcast float* %815 to <4 x float>*
%817 = load <4 x float>, <4 x float>* %816
%818 = getelementptr inbounds float, float* %815, i64 4
%819 = bitcast float* %818 to <4 x float>*
%820 = load <4 x float>, <4 x float>* %819
%821 = getelementptr inbounds float, float* %2, i64 %813
%822 = bitcast float* %821 to <4 x float>*
store <4 x float> %817, <4 x float>* %822
%823 = getelementptr inbounds float, float* %821, i64 4
%824 = bitcast float* %823 to <4 x float>*
store <4 x float> %820, <4 x float>* %824
%825 = add nuw i64 %813, 8
%826 = add i64 %814, 1
%827 = icmp eq i64 %826, %756
br i1 %827, label %828, label %812
828: ; preds = %812, %809
%829 = icmp eq i64 %752, %6
br i1 %829, label %867, label %830
830: ; preds = %745, %742, %828
%831 = phi i64 [ 0, %745 ], [ 0, %742 ], [ %752, %828 ]
%832 = xor i64 %831, -1
%833 = add nsw i64 %832, %6
%834 = and i64 %6, 3
%835 = icmp eq i64 %834, 0
br i1 %835, label %845, label %836
836: ; preds = %830, %836
%837 = phi i64 [ %842, %836 ], [ %831, %830 ]
%838 = phi i64 [ %843, %836 ], [ 0, %830 ]
%839 = getelementptr inbounds float, float* %1, i64 %837
%840 = load float, float* %839
%841 = getelementptr inbounds float, float* %2, i64 %837
store float %840, float* %841
%842 = add nuw nsw i64 %837, 1
%843 = add i64 %838, 1
%844 = icmp eq i64 %843, %834
br i1 %844, label %845, label %836
845: ; preds = %836, %830
%846 = phi i64 [ %831, %830 ], [ %842, %836 ]
%847 = icmp ult i64 %833, 3
br i1 %847, label %867, label %974
848: ; preds = %719, %848
%849 = phi i64 [ %865, %848 ], [ %720, %719 ]
%850 = getelementptr inbounds float, float* %1, i64 %849
%851 = load float, float* %850
%852 = getelementptr inbounds float, float* %2, i64 %849
store float %851, float* %852
%853 = add nuw nsw i64 %849, 1
%854 = getelementptr inbounds float, float* %1, i64 %853
%855 = load float, float* %854
%856 = getelementptr inbounds float, float* %2, i64 %853
store float %855, float* %856
%857 = add nuw nsw i64 %849, 2
%858 = getelementptr inbounds float, float* %1, i64 %857
%859 = load float, float* %858
%860 = getelementptr inbounds float, float* %2, i64 %857
store float %859, float* %860
%861 = add nuw nsw i64 %849, 3
%862 = getelementptr inbounds float, float* %1, i64 %861
%863 = load float, float* %862
%864 = getelementptr inbounds float, float* %2, i64 %861
store float %863, float* %864
%865 = add nuw nsw i64 %849, 4
%866 = icmp eq i64 %865, %617
br i1 %866, label %741, label %848
867: ; preds = %845, %974, %828
br i1 %4, label %868, label %3154
868: ; preds = %867
%869 = zext i32 %0 to i64
%870 = icmp ult i32 %0, 8
br i1 %870, label %956, label %871
871: ; preds = %868
%872 = getelementptr float, float* %2, i64 %6
%873 = getelementptr float, float* %1, i64 %6
%874 = icmp ugt float* %873, %2
%875 = icmp ugt float* %872, %1
%876 = and i1 %874, %875
br i1 %876, label %956, label %877
877: ; preds = %871
%878 = and i64 %6, 4294967288
%879 = add nsw i64 %878, -8
%880 = lshr exact i64 %879, 3
%881 = add nuw nsw i64 %880, 1
%882 = and i64 %881, 3
%883 = icmp ult i64 %879, 24
br i1 %883, label %935, label %884
884: ; preds = %877
%885 = and i64 %881, 4611686018427387900
br label %886
886: ; preds = %886, %884
%887 = phi i64 [ 0, %884 ], [ %932, %886 ]
%888 = phi i64 [ 0, %884 ], [ %933, %886 ]
%889 = getelementptr inbounds float, float* %1, i64 %887
%890 = bitcast float* %889 to <4 x float>*
%891 = load <4 x float>, <4 x float>* %890
%892 = getelementptr inbounds float, float* %889, i64 4
%893 = bitcast float* %892 to <4 x float>*
%894 = load <4 x float>, <4 x float>* %893
%895 = getelementptr inbounds float, float* %2, i64 %887
%896 = bitcast float* %895 to <4 x float>*
store <4 x float> %891, <4 x float>* %896
%897 = getelementptr inbounds float, float* %895, i64 4
%898 = bitcast float* %897 to <4 x float>*
store <4 x float> %894, <4 x float>* %898
%899 = or i64 %887, 8
%900 = getelementptr inbounds float, float* %1, i64 %899
%901 = bitcast float* %900 to <4 x float>*
%902 = load <4 x float>, <4 x float>* %901
%903 = getelementptr inbounds float, float* %900, i64 4
%904 = bitcast float* %903 to <4 x float>*
%905 = load <4 x float>, <4 x float>* %904
%906 = getelementptr inbounds float, float* %2, i64 %899
%907 = bitcast float* %906 to <4 x float>*
store <4 x float> %902, <4 x float>* %907
%908 = getelementptr inbounds float, float* %906, i64 4
%909 = bitcast float* %908 to <4 x float>*
store <4 x float> %905, <4 x float>* %909
%910 = or i64 %887, 16
%911 = getelementptr inbounds float, float* %1, i64 %910
%912 = bitcast float* %911 to <4 x float>*
%913 = load <4 x float>, <4 x float>* %912
%914 = getelementptr inbounds float, float* %911, i64 4
%915 = bitcast float* %914 to <4 x float>*
%916 = load <4 x float>, <4 x float>* %915
%917 = getelementptr inbounds float, float* %2, i64 %910
%918 = bitcast float* %917 to <4 x float>*
store <4 x float> %913, <4 x float>* %918
%919 = getelementptr inbounds float, float* %917, i64 4
%920 = bitcast float* %919 to <4 x float>*
store <4 x float> %916, <4 x float>* %920
%921 = or i64 %887, 24
%922 = getelementptr inbounds float, float* %1, i64 %921
%923 = bitcast float* %922 to <4 x float>*
%924 = load <4 x float>, <4 x float>* %923
%925 = getelementptr inbounds float, float* %922, i64 4
%926 = bitcast float* %925 to <4 x float>*
%927 = load <4 x float>, <4 x float>* %926
%928 = getelementptr inbounds float, float* %2, i64 %921
%929 = bitcast float* %928 to <4 x float>*
store <4 x float> %924, <4 x float>* %929
%930 = getelementptr inbounds float, float* %928, i64 4
%931 = bitcast float* %930 to <4 x float>*
store <4 x float> %927, <4 x float>* %931
%932 = add nuw i64 %887, 32
%933 = add i64 %888, 4
%934 = icmp eq i64 %933, %885
br i1 %934, label %935, label %886
935: ; preds = %886, %877
%936 = phi i64 [ 0, %877 ], [ %932, %886 ]
%937 = icmp eq i64 %882, 0
br i1 %937, label %954, label %938
938: ; preds = %935, %938
%939 = phi i64 [ %951, %938 ], [ %936, %935 ]
%940 = phi i64 [ %952, %938 ], [ 0, %935 ]
%941 = getelementptr inbounds float, float* %1, i64 %939
%942 = bitcast float* %941 to <4 x float>*
%943 = load <4 x float>, <4 x float>* %942
%944 = getelementptr inbounds float, float* %941, i64 4
%945 = bitcast float* %944 to <4 x float>*
%946 = load <4 x float>, <4 x float>* %945
%947 = getelementptr inbounds float, float* %2, i64 %939
%948 = bitcast float* %947 to <4 x float>*
store <4 x float> %943, <4 x float>* %948
%949 = getelementptr inbounds float, float* %947, i64 4
%950 = bitcast float* %949 to <4 x float>*
store <4 x float> %946, <4 x float>* %950
%951 = add nuw i64 %939, 8
%952 = add i64 %940, 1
%953 = icmp eq i64 %952, %882
br i1 %953, label %954, label %938
954: ; preds = %938, %935
%955 = icmp eq i64 %878, %6
br i1 %955, label %993, label %956
956: ; preds = %871, %868, %954
%957 = phi i64 [ 0, %871 ], [ 0, %868 ], [ %878, %954 ]
%958 = xor i64 %957, -1
%959 = add nsw i64 %958, %6
%960 = and i64 %6, 3
%961 = icmp eq i64 %960, 0
br i1 %961, label %971, label %962
962: ; preds = %956, %962
%963 = phi i64 [ %968, %962 ], [ %957, %956 ]
%964 = phi i64 [ %969, %962 ], [ 0, %956 ]
%965 = getelementptr inbounds float, float* %1, i64 %963
%966 = load float, float* %965
%967 = getelementptr inbounds float, float* %2, i64 %963
store float %966, float* %967
%968 = add nuw nsw i64 %963, 1
%969 = add i64 %964, 1
%970 = icmp eq i64 %969, %960
br i1 %970, label %971, label %962
971: ; preds = %962, %956
%972 = phi i64 [ %957, %956 ], [ %968, %962 ]
%973 = icmp ult i64 %959, 3
br i1 %973, label %993, label %1100
974: ; preds = %845, %974
%975 = phi i64 [ %991, %974 ], [ %846, %845 ]
%976 = getelementptr inbounds float, float* %1, i64 %975
%977 = load float, float* %976
%978 = getelementptr inbounds float, float* %2, i64 %975
store float %977, float* %978
%979 = add nuw nsw i64 %975, 1
%980 = getelementptr inbounds float, float* %1, i64 %979
%981 = load float, float* %980
%982 = getelementptr inbounds float, float* %2, i64 %979
store float %981, float* %982
%983 = add nuw nsw i64 %975, 2
%984 = getelementptr inbounds float, float* %1, i64 %983
%985 = load float, float* %984
%986 = getelementptr inbounds float, float* %2, i64 %983
store float %985, float* %986
%987 = add nuw nsw i64 %975, 3
%988 = getelementptr inbounds float, float* %1, i64 %987
%989 = load float, float* %988
%990 = getelementptr inbounds float, float* %2, i64 %987
store float %989, float* %990
%991 = add nuw nsw i64 %975, 4
%992 = icmp eq i64 %991, %743
br i1 %992, label %867, label %974
993: ; preds = %971, %1100, %954
br i1 %4, label %994, label %3154
994: ; preds = %993
%995 = zext i32 %0 to i64
%996 = icmp ult i32 %0, 8
br i1 %996, label %1082, label %997
997: ; preds = %994
%998 = getelementptr float, float* %2, i64 %6
%999 = getelementptr float, float* %1, i64 %6
%1000 = icmp ugt float* %999, %2
%1001 = icmp ugt float* %998, %1
%1002 = and i1 %1000, %1001
br i1 %1002, label %1082, label %1003
1003: ; preds = %997
%1004 = and i64 %6, 4294967288
%1005 = add nsw i64 %1004, -8
%1006 = lshr exact i64 %1005, 3
%1007 = add nuw nsw i64 %1006, 1
%1008 = and i64 %1007, 3
%1009 = icmp ult i64 %1005, 24
br i1 %1009, label %1061, label %1010
1010: ; preds = %1003
%1011 = and i64 %1007, 4611686018427387900
br label %1012
1012: ; preds = %1012, %1010
%1013 = phi i64 [ 0, %1010 ], [ %1058, %1012 ]
%1014 = phi i64 [ 0, %1010 ], [ %1059, %1012 ]
%1015 = getelementptr inbounds float, float* %1, i64 %1013
%1016 = bitcast float* %1015 to <4 x float>*
%1017 = load <4 x float>, <4 x float>* %1016
%1018 = getelementptr inbounds float, float* %1015, i64 4
%1019 = bitcast float* %1018 to <4 x float>*
%1020 = load <4 x float>, <4 x float>* %1019
%1021 = getelementptr inbounds float, float* %2, i64 %1013
%1022 = bitcast float* %1021 to <4 x float>*
store <4 x float> %1017, <4 x float>* %1022
%1023 = getelementptr inbounds float, float* %1021, i64 4
%1024 = bitcast float* %1023 to <4 x float>*
store <4 x float> %1020, <4 x float>* %1024
%1025 = or i64 %1013, 8
%1026 = getelementptr inbounds float, float* %1, i64 %1025
%1027 = bitcast float* %1026 to <4 x float>*
%1028 = load <4 x float>, <4 x float>* %1027
%1029 = getelementptr inbounds float, float* %1026, i64 4
%1030 = bitcast float* %1029 to <4 x float>*
%1031 = load <4 x float>, <4 x float>* %1030
%1032 = getelementptr inbounds float, float* %2, i64 %1025
%1033 = bitcast float* %1032 to <4 x float>*
store <4 x float> %1028, <4 x float>* %1033
%1034 = getelementptr inbounds float, float* %1032, i64 4
%1035 = bitcast float* %1034 to <4 x float>*
store <4 x float> %1031, <4 x float>* %1035
%1036 = or i64 %1013, 16
%1037 = getelementptr inbounds float, float* %1, i64 %1036
%1038 = bitcast float* %1037 to <4 x float>*
%1039 = load <4 x float>, <4 x float>* %1038
%1040 = getelementptr inbounds float, float* %1037, i64 4
%1041 = bitcast float* %1040 to <4 x float>*
%1042 = load <4 x float>, <4 x float>* %1041
%1043 = getelementptr inbounds float, float* %2, i64 %1036
%1044 = bitcast float* %1043 to <4 x float>*
store <4 x float> %1039, <4 x float>* %1044
%1045 = getelementptr inbounds float, float* %1043, i64 4
%1046 = bitcast float* %1045 to <4 x float>*
store <4 x float> %1042, <4 x float>* %1046
%1047 = or i64 %1013, 24
%1048 = getelementptr inbounds float, float* %1, i64 %1047
%1049 = bitcast float* %1048 to <4 x float>*
%1050 = load <4 x float>, <4 x float>* %1049
%1051 = getelementptr inbounds float, float* %1048, i64 4
%1052 = bitcast float* %1051 to <4 x float>*
%1053 = load <4 x float>, <4 x float>* %1052
%1054 = getelementptr inbounds float, float* %2, i64 %1047
%1055 = bitcast float* %1054 to <4 x float>*
store <4 x float> %1050, <4 x float>* %1055
%1056 = getelementptr inbounds float, float* %1054, i64 4
%1057 = bitcast float* %1056 to <4 x float>*
store <4 x float> %1053, <4 x float>* %1057
%1058 = add nuw i64 %1013, 32
%1059 = add i64 %1014, 4
%1060 = icmp eq i64 %1059, %1011
br i1 %1060, label %1061, label %1012
1061: ; preds = %1012, %1003
%1062 = phi i64 [ 0, %1003 ], [ %1058, %1012 ]
%1063 = icmp eq i64 %1008, 0
br i1 %1063, label %1080, label %1064
1064: ; preds = %1061, %1064
%1065 = phi i64 [ %1077, %1064 ], [ %1062, %1061 ]
%1066 = phi i64 [ %1078, %1064 ], [ 0, %1061 ]
%1067 = getelementptr inbounds float, float* %1, i64 %1065
%1068 = bitcast float* %1067 to <4 x float>*
%1069 = load <4 x float>, <4 x float>* %1068
%1070 = getelementptr inbounds float, float* %1067, i64 4
%1071 = bitcast float* %1070 to <4 x float>*
%1072 = load <4 x float>, <4 x float>* %1071
%1073 = getelementptr inbounds float, float* %2, i64 %1065
%1074 = bitcast float* %1073 to <4 x float>*
store <4 x float> %1069, <4 x float>* %1074
%1075 = getelementptr inbounds float, float* %1073, i64 4
%1076 = bitcast float* %1075 to <4 x float>*
store <4 x float> %1072, <4 x float>* %1076
%1077 = add nuw i64 %1065, 8
%1078 = add i64 %1066, 1
%1079 = icmp eq i64 %1078, %1008
br i1 %1079, label %1080, label %1064
1080: ; preds = %1064, %1061
%1081 = icmp eq i64 %1004, %6
br i1 %1081, label %1119, label %1082
1082: ; preds = %997, %994, %1080
%1083 = phi i64 [ 0, %997 ], [ 0, %994 ], [ %1004, %1080 ]
%1084 = xor i64 %1083, -1
%1085 = add nsw i64 %1084, %6
%1086 = and i64 %6, 3
%1087 = icmp eq i64 %1086, 0
br i1 %1087, label %1097, label %1088
1088: ; preds = %1082, %1088
%1089 = phi i64 [ %1094, %1088 ], [ %1083, %1082 ]
%1090 = phi i64 [ %1095, %1088 ], [ 0, %1082 ]
%1091 = getelementptr inbounds float, float* %1, i64 %1089
%1092 = load float, float* %1091
%1093 = getelementptr inbounds float, float* %2, i64 %1089
store float %1092, float* %1093
%1094 = add nuw nsw i64 %1089, 1
%1095 = add i64 %1090, 1
%1096 = icmp eq i64 %1095, %1086
br i1 %1096, label %1097, label %1088
1097: ; preds = %1088, %1082
%1098 = phi i64 [ %1083, %1082 ], [ %1094, %1088 ]
%1099 = icmp ult i64 %1085, 3
br i1 %1099, label %1119, label %1226
1100: ; preds = %971, %1100
%1101 = phi i64 [ %1117, %1100 ], [ %972, %971 ]
%1102 = getelementptr inbounds float, float* %1, i64 %1101
%1103 = load float, float* %1102
%1104 = getelementptr inbounds float, float* %2, i64 %1101
store float %1103, float* %1104
%1105 = add nuw nsw i64 %1101, 1
%1106 = getelementptr inbounds float, float* %1, i64 %1105
%1107 = load float, float* %1106
%1108 = getelementptr inbounds float, float* %2, i64 %1105
store float %1107, float* %1108
%1109 = add nuw nsw i64 %1101, 2
%1110 = getelementptr inbounds float, float* %1, i64 %1109
%1111 = load float, float* %1110
%1112 = getelementptr inbounds float, float* %2, i64 %1109
store float %1111, float* %1112
%1113 = add nuw nsw i64 %1101, 3
%1114 = getelementptr inbounds float, float* %1, i64 %1113
%1115 = load float, float* %1114
%1116 = getelementptr inbounds float, float* %2, i64 %1113
store float %1115, float* %1116
%1117 = add nuw nsw i64 %1101, 4
%1118 = icmp eq i64 %1117, %869
br i1 %1118, label %993, label %1100
1119: ; preds = %1097, %1226, %1080
br i1 %4, label %1120, label %3154
1120: ; preds = %1119
%1121 = zext i32 %0 to i64
%1122 = icmp ult i32 %0, 8
br i1 %1122, label %1208, label %1123
1123: ; preds = %1120
%1124 = getelementptr float, float* %2, i64 %6
%1125 = getelementptr float, float* %1, i64 %6
%1126 = icmp ugt float* %1125, %2
%1127 = icmp ugt float* %1124, %1
%1128 = and i1 %1126, %1127
br i1 %1128, label %1208, label %1129
1129: ; preds = %1123
%1130 = and i64 %6, 4294967288
%1131 = add nsw i64 %1130, -8
%1132 = lshr exact i64 %1131, 3
%1133 = add nuw nsw i64 %1132, 1
%1134 = and i64 %1133, 3
%1135 = icmp ult i64 %1131, 24
br i1 %1135, label %1187, label %1136
1136: ; preds = %1129
%1137 = and i64 %1133, 4611686018427387900
br label %1138
1138: ; preds = %1138, %1136
%1139 = phi i64 [ 0, %1136 ], [ %1184, %1138 ]
%1140 = phi i64 [ 0, %1136 ], [ %1185, %1138 ]
%1141 = getelementptr inbounds float, float* %1, i64 %1139
%1142 = bitcast float* %1141 to <4 x float>*
%1143 = load <4 x float>, <4 x float>* %1142
%1144 = getelementptr inbounds float, float* %1141, i64 4
%1145 = bitcast float* %1144 to <4 x float>*
%1146 = load <4 x float>, <4 x float>* %1145
%1147 = getelementptr inbounds float, float* %2, i64 %1139
%1148 = bitcast float* %1147 to <4 x float>*
store <4 x float> %1143, <4 x float>* %1148
%1149 = getelementptr inbounds float, float* %1147, i64 4
%1150 = bitcast float* %1149 to <4 x float>*
store <4 x float> %1146, <4 x float>* %1150
%1151 = or i64 %1139, 8
%1152 = getelementptr inbounds float, float* %1, i64 %1151
%1153 = bitcast float* %1152 to <4 x float>*
%1154 = load <4 x float>, <4 x float>* %1153
%1155 = getelementptr inbounds float, float* %1152, i64 4
%1156 = bitcast float* %1155 to <4 x float>*
%1157 = load <4 x float>, <4 x float>* %1156
%1158 = getelementptr inbounds float, float* %2, i64 %1151
%1159 = bitcast float* %1158 to <4 x float>*
store <4 x float> %1154, <4 x float>* %1159
%1160 = getelementptr inbounds float, float* %1158, i64 4
%1161 = bitcast float* %1160 to <4 x float>*
store <4 x float> %1157, <4 x float>* %1161
%1162 = or i64 %1139, 16
%1163 = getelementptr inbounds float, float* %1, i64 %1162
%1164 = bitcast float* %1163 to <4 x float>*
%1165 = load <4 x float>, <4 x float>* %1164
%1166 = getelementptr inbounds float, float* %1163, i64 4
%1167 = bitcast float* %1166 to <4 x float>*
%1168 = load <4 x float>, <4 x float>* %1167
%1169 = getelementptr inbounds float, float* %2, i64 %1162
%1170 = bitcast float* %1169 to <4 x float>*
store <4 x float> %1165, <4 x float>* %1170
%1171 = getelementptr inbounds float, float* %1169, i64 4
%1172 = bitcast float* %1171 to <4 x float>*
store <4 x float> %1168, <4 x float>* %1172
%1173 = or i64 %1139, 24
%1174 = getelementptr inbounds float, float* %1, i64 %1173
%1175 = bitcast float* %1174 to <4 x float>*
%1176 = load <4 x float>, <4 x float>* %1175
%1177 = getelementptr inbounds float, float* %1174, i64 4
%1178 = bitcast float* %1177 to <4 x float>*
%1179 = load <4 x float>, <4 x float>* %1178
%1180 = getelementptr inbounds float, float* %2, i64 %1173
%1181 = bitcast float* %1180 to <4 x float>*
store <4 x float> %1176, <4 x float>* %1181
%1182 = getelementptr inbounds float, float* %1180, i64 4
%1183 = bitcast float* %1182 to <4 x float>*
store <4 x float> %1179, <4 x float>* %1183
%1184 = add nuw i64 %1139, 32
%1185 = add i64 %1140, 4
%1186 = icmp eq i64 %1185, %1137
br i1 %1186, label %1187, label %1138
1187: ; preds = %1138, %1129
%1188 = phi i64 [ 0, %1129 ], [ %1184, %1138 ]
%1189 = icmp eq i64 %1134, 0
br i1 %1189, label %1206, label %1190
1190: ; preds = %1187, %1190
%1191 = phi i64 [ %1203, %1190 ], [ %1188, %1187 ]
%1192 = phi i64 [ %1204, %1190 ], [ 0, %1187 ]
%1193 = getelementptr inbounds float, float* %1, i64 %1191
%1194 = bitcast float* %1193 to <4 x float>*
%1195 = load <4 x float>, <4 x float>* %1194
%1196 = getelementptr inbounds float, float* %1193, i64 4
%1197 = bitcast float* %1196 to <4 x float>*
%1198 = load <4 x float>, <4 x float>* %1197
%1199 = getelementptr inbounds float, float* %2, i64 %1191
%1200 = bitcast float* %1199 to <4 x float>*
store <4 x float> %1195, <4 x float>* %1200
%1201 = getelementptr inbounds float, float* %1199, i64 4
%1202 = bitcast float* %1201 to <4 x float>*
store <4 x float> %1198, <4 x float>* %1202
%1203 = add nuw i64 %1191, 8
%1204 = add i64 %1192, 1
%1205 = icmp eq i64 %1204, %1134
br i1 %1205, label %1206, label %1190
1206: ; preds = %1190, %1187
%1207 = icmp eq i64 %1130, %6
br i1 %1207, label %1245, label %1208
1208: ; preds = %1123, %1120, %1206
%1209 = phi i64 [ 0, %1123 ], [ 0, %1120 ], [ %1130, %1206 ]
%1210 = xor i64 %1209, -1
%1211 = add nsw i64 %1210, %6
%1212 = and i64 %6, 3
%1213 = icmp eq i64 %1212, 0
br i1 %1213, label %1223, label %1214
1214: ; preds = %1208, %1214
%1215 = phi i64 [ %1220, %1214 ], [ %1209, %1208 ]
%1216 = phi i64 [ %1221, %1214 ], [ 0, %1208 ]
%1217 = getelementptr inbounds float, float* %1, i64 %1215
%1218 = load float, float* %1217
%1219 = getelementptr inbounds float, float* %2, i64 %1215
store float %1218, float* %1219
%1220 = add nuw nsw i64 %1215, 1
%1221 = add i64 %1216, 1
%1222 = icmp eq i64 %1221, %1212
br i1 %1222, label %1223, label %1214
1223: ; preds = %1214, %1208
%1224 = phi i64 [ %1209, %1208 ], [ %1220, %1214 ]
%1225 = icmp ult i64 %1211, 3
br i1 %1225, label %1245, label %1352
1226: ; preds = %1097, %1226
%1227 = phi i64 [ %1243, %1226 ], [ %1098, %1097 ]
%1228 = getelementptr inbounds float, float* %1, i64 %1227
%1229 = load float, float* %1228
%1230 = getelementptr inbounds float, float* %2, i64 %1227
store float %1229, float* %1230
%1231 = add nuw nsw i64 %1227, 1
%1232 = getelementptr inbounds float, float* %1, i64 %1231
%1233 = load float, float* %1232
%1234 = getelementptr inbounds float, float* %2, i64 %1231
store float %1233, float* %1234
%1235 = add nuw nsw i64 %1227, 2
%1236 = getelementptr inbounds float, float* %1, i64 %1235
%1237 = load float, float* %1236
%1238 = getelementptr inbounds float, float* %2, i64 %1235
store float %1237, float* %1238
%1239 = add nuw nsw i64 %1227, 3
%1240 = getelementptr inbounds float, float* %1, i64 %1239
%1241 = load float, float* %1240
%1242 = getelementptr inbounds float, float* %2, i64 %1239
store float %1241, float* %1242
%1243 = add nuw nsw i64 %1227, 4
%1244 = icmp eq i64 %1243, %995
br i1 %1244, label %1119, label %1226
1245: ; preds = %1223, %1352, %1206
br i1 %4, label %1246, label %3154
1246: ; preds = %1245
%1247 = zext i32 %0 to i64
%1248 = icmp ult i32 %0, 8
br i1 %1248, label %1334, label %1249
1249: ; preds = %1246
%1250 = getelementptr float, float* %2, i64 %6
%1251 = getelementptr float, float* %1, i64 %6
%1252 = icmp ugt float* %1251, %2
%1253 = icmp ugt float* %1250, %1
%1254 = and i1 %1252, %1253
br i1 %1254, label %1334, label %1255
1255: ; preds = %1249
%1256 = and i64 %6, 4294967288
%1257 = add nsw i64 %1256, -8
%1258 = lshr exact i64 %1257, 3
%1259 = add nuw nsw i64 %1258, 1
%1260 = and i64 %1259, 3
%1261 = icmp ult i64 %1257, 24
br i1 %1261, label %1313, label %1262
1262: ; preds = %1255
%1263 = and i64 %1259, 4611686018427387900
br label %1264
1264: ; preds = %1264, %1262
%1265 = phi i64 [ 0, %1262 ], [ %1310, %1264 ]
%1266 = phi i64 [ 0, %1262 ], [ %1311, %1264 ]
%1267 = getelementptr inbounds float, float* %1, i64 %1265
%1268 = bitcast float* %1267 to <4 x float>*
%1269 = load <4 x float>, <4 x float>* %1268
%1270 = getelementptr inbounds float, float* %1267, i64 4
%1271 = bitcast float* %1270 to <4 x float>*
%1272 = load <4 x float>, <4 x float>* %1271
%1273 = getelementptr inbounds float, float* %2, i64 %1265
%1274 = bitcast float* %1273 to <4 x float>*
store <4 x float> %1269, <4 x float>* %1274
%1275 = getelementptr inbounds float, float* %1273, i64 4
%1276 = bitcast float* %1275 to <4 x float>*
store <4 x float> %1272, <4 x float>* %1276
%1277 = or i64 %1265, 8
%1278 = getelementptr inbounds float, float* %1, i64 %1277
%1279 = bitcast float* %1278 to <4 x float>*
%1280 = load <4 x float>, <4 x float>* %1279
%1281 = getelementptr inbounds float, float* %1278, i64 4
%1282 = bitcast float* %1281 to <4 x float>*
%1283 = load <4 x float>, <4 x float>* %1282
%1284 = getelementptr inbounds float, float* %2, i64 %1277
%1285 = bitcast float* %1284 to <4 x float>*
store <4 x float> %1280, <4 x float>* %1285
%1286 = getelementptr inbounds float, float* %1284, i64 4
%1287 = bitcast float* %1286 to <4 x float>*
store <4 x float> %1283, <4 x float>* %1287
%1288 = or i64 %1265, 16
%1289 = getelementptr inbounds float, float* %1, i64 %1288
%1290 = bitcast float* %1289 to <4 x float>*
%1291 = load <4 x float>, <4 x float>* %1290
%1292 = getelementptr inbounds float, float* %1289, i64 4
%1293 = bitcast float* %1292 to <4 x float>*
%1294 = load <4 x float>, <4 x float>* %1293
%1295 = getelementptr inbounds float, float* %2, i64 %1288
%1296 = bitcast float* %1295 to <4 x float>*
store <4 x float> %1291, <4 x float>* %1296
%1297 = getelementptr inbounds float, float* %1295, i64 4
%1298 = bitcast float* %1297 to <4 x float>*
store <4 x float> %1294, <4 x float>* %1298
%1299 = or i64 %1265, 24
%1300 = getelementptr inbounds float, float* %1, i64 %1299
%1301 = bitcast float* %1300 to <4 x float>*
%1302 = load <4 x float>, <4 x float>* %1301
%1303 = getelementptr inbounds float, float* %1300, i64 4
%1304 = bitcast float* %1303 to <4 x float>*
%1305 = load <4 x float>, <4 x float>* %1304
%1306 = getelementptr inbounds float, float* %2, i64 %1299
%1307 = bitcast float* %1306 to <4 x float>*
store <4 x float> %1302, <4 x float>* %1307
%1308 = getelementptr inbounds float, float* %1306, i64 4
%1309 = bitcast float* %1308 to <4 x float>*
store <4 x float> %1305, <4 x float>* %1309
%1310 = add nuw i64 %1265, 32
%1311 = add i64 %1266, 4
%1312 = icmp eq i64 %1311, %1263
br i1 %1312, label %1313, label %1264
1313: ; preds = %1264, %1255
%1314 = phi i64 [ 0, %1255 ], [ %1310, %1264 ]
%1315 = icmp eq i64 %1260, 0
br i1 %1315, label %1332, label %1316
1316: ; preds = %1313, %1316
%1317 = phi i64 [ %1329, %1316 ], [ %1314, %1313 ]
%1318 = phi i64 [ %1330, %1316 ], [ 0, %1313 ]
%1319 = getelementptr inbounds float, float* %1, i64 %1317
%1320 = bitcast float* %1319 to <4 x float>*
%1321 = load <4 x float>, <4 x float>* %1320
%1322 = getelementptr inbounds float, float* %1319, i64 4
%1323 = bitcast float* %1322 to <4 x float>*
%1324 = load <4 x float>, <4 x float>* %1323
%1325 = getelementptr inbounds float, float* %2, i64 %1317
%1326 = bitcast float* %1325 to <4 x float>*
store <4 x float> %1321, <4 x float>* %1326
%1327 = getelementptr inbounds float, float* %1325, i64 4
%1328 = bitcast float* %1327 to <4 x float>*
store <4 x float> %1324, <4 x float>* %1328
%1329 = add nuw i64 %1317, 8
%1330 = add i64 %1318, 1
%1331 = icmp eq i64 %1330, %1260
br i1 %1331, label %1332, label %1316
1332: ; preds = %1316, %1313
%1333 = icmp eq i64 %1256, %6
br i1 %1333, label %1371, label %1334
1334: ; preds = %1249, %1246, %1332
%1335 = phi i64 [ 0, %1249 ], [ 0, %1246 ], [ %1256, %1332 ]
%1336 = xor i64 %1335, -1
%1337 = add nsw i64 %1336, %6
%1338 = and i64 %6, 3
%1339 = icmp eq i64 %1338, 0
br i1 %1339, label %1349, label %1340
1340: ; preds = %1334, %1340
%1341 = phi i64 [ %1346, %1340 ], [ %1335, %1334 ]
%1342 = phi i64 [ %1347, %1340 ], [ 0, %1334 ]
%1343 = getelementptr inbounds float, float* %1, i64 %1341
%1344 = load float, float* %1343
%1345 = getelementptr inbounds float, float* %2, i64 %1341
store float %1344, float* %1345
%1346 = add nuw nsw i64 %1341, 1
%1347 = add i64 %1342, 1
%1348 = icmp eq i64 %1347, %1338
br i1 %1348, label %1349, label %1340
1349: ; preds = %1340, %1334
%1350 = phi i64 [ %1335, %1334 ], [ %1346, %1340 ]
%1351 = icmp ult i64 %1337, 3
br i1 %1351, label %1371, label %1478
1352: ; preds = %1223, %1352
%1353 = phi i64 [ %1369, %1352 ], [ %1224, %1223 ]
%1354 = getelementptr inbounds float, float* %1, i64 %1353
%1355 = load float, float* %1354
%1356 = getelementptr inbounds float, float* %2, i64 %1353
store float %1355, float* %1356
%1357 = add nuw nsw i64 %1353, 1
%1358 = getelementptr inbounds float, float* %1, i64 %1357
%1359 = load float, float* %1358
%1360 = getelementptr inbounds float, float* %2, i64 %1357
store float %1359, float* %1360
%1361 = add nuw nsw i64 %1353, 2
%1362 = getelementptr inbounds float, float* %1, i64 %1361
%1363 = load float, float* %1362
%1364 = getelementptr inbounds float, float* %2, i64 %1361
store float %1363, float* %1364
%1365 = add nuw nsw i64 %1353, 3
%1366 = getelementptr inbounds float, float* %1, i64 %1365
%1367 = load float, float* %1366
%1368 = getelementptr inbounds float, float* %2, i64 %1365
store float %1367, float* %1368
%1369 = add nuw nsw i64 %1353, 4
%1370 = icmp eq i64 %1369, %1121
br i1 %1370, label %1245, label %1352
1371: ; preds = %1349, %1478, %1332
br i1 %4, label %1372, label %3154
1372: ; preds = %1371
%1373 = zext i32 %0 to i64
%1374 = icmp ult i32 %0, 8
br i1 %1374, label %1460, label %1375
1375: ; preds = %1372
%1376 = getelementptr float, float* %2, i64 %6
%1377 = getelementptr float, float* %1, i64 %6
%1378 = icmp ugt float* %1377, %2
%1379 = icmp ugt float* %1376, %1
%1380 = and i1 %1378, %1379
br i1 %1380, label %1460, label %1381
1381: ; preds = %1375
%1382 = and i64 %6, 4294967288
%1383 = add nsw i64 %1382, -8
%1384 = lshr exact i64 %1383, 3
%1385 = add nuw nsw i64 %1384, 1
%1386 = and i64 %1385, 3
%1387 = icmp ult i64 %1383, 24
br i1 %1387, label %1439, label %1388
1388: ; preds = %1381
%1389 = and i64 %1385, 4611686018427387900
br label %1390
1390: ; preds = %1390, %1388
%1391 = phi i64 [ 0, %1388 ], [ %1436, %1390 ]
%1392 = phi i64 [ 0, %1388 ], [ %1437, %1390 ]
%1393 = getelementptr inbounds float, float* %1, i64 %1391
%1394 = bitcast float* %1393 to <4 x float>*
%1395 = load <4 x float>, <4 x float>* %1394
%1396 = getelementptr inbounds float, float* %1393, i64 4
%1397 = bitcast float* %1396 to <4 x float>*
%1398 = load <4 x float>, <4 x float>* %1397
%1399 = getelementptr inbounds float, float* %2, i64 %1391
%1400 = bitcast float* %1399 to <4 x float>*
store <4 x float> %1395, <4 x float>* %1400
%1401 = getelementptr inbounds float, float* %1399, i64 4
%1402 = bitcast float* %1401 to <4 x float>*
store <4 x float> %1398, <4 x float>* %1402
%1403 = or i64 %1391, 8
%1404 = getelementptr inbounds float, float* %1, i64 %1403
%1405 = bitcast float* %1404 to <4 x float>*
%1406 = load <4 x float>, <4 x float>* %1405
%1407 = getelementptr inbounds float, float* %1404, i64 4
%1408 = bitcast float* %1407 to <4 x float>*
%1409 = load <4 x float>, <4 x float>* %1408
%1410 = getelementptr inbounds float, float* %2, i64 %1403
%1411 = bitcast float* %1410 to <4 x float>*
store <4 x float> %1406, <4 x float>* %1411
%1412 = getelementptr inbounds float, float* %1410, i64 4
%1413 = bitcast float* %1412 to <4 x float>*
store <4 x float> %1409, <4 x float>* %1413
%1414 = or i64 %1391, 16
%1415 = getelementptr inbounds float, float* %1, i64 %1414
%1416 = bitcast float* %1415 to <4 x float>*
%1417 = load <4 x float>, <4 x float>* %1416
%1418 = getelementptr inbounds float, float* %1415, i64 4
%1419 = bitcast float* %1418 to <4 x float>*
%1420 = load <4 x float>, <4 x float>* %1419
%1421 = getelementptr inbounds float, float* %2, i64 %1414
%1422 = bitcast float* %1421 to <4 x float>*
store <4 x float> %1417, <4 x float>* %1422
%1423 = getelementptr inbounds float, float* %1421, i64 4
%1424 = bitcast float* %1423 to <4 x float>*
store <4 x float> %1420, <4 x float>* %1424
%1425 = or i64 %1391, 24
%1426 = getelementptr inbounds float, float* %1, i64 %1425
%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 = getelementptr inbounds float, float* %2, i64 %1425
%1433 = bitcast float* %1432 to <4 x float>*
store <4 x float> %1428, <4 x float>* %1433
%1434 = getelementptr inbounds float, float* %1432, i64 4
%1435 = bitcast float* %1434 to <4 x float>*
store <4 x float> %1431, <4 x float>* %1435
%1436 = add nuw i64 %1391, 32
%1437 = add i64 %1392, 4
%1438 = icmp eq i64 %1437, %1389
br i1 %1438, label %1439, label %1390
1439: ; preds = %1390, %1381
%1440 = phi i64 [ 0, %1381 ], [ %1436, %1390 ]
%1441 = icmp eq i64 %1386, 0
br i1 %1441, label %1458, label %1442
1442: ; preds = %1439, %1442
%1443 = phi i64 [ %1455, %1442 ], [ %1440, %1439 ]
%1444 = phi i64 [ %1456, %1442 ], [ 0, %1439 ]
%1445 = getelementptr inbounds float, float* %1, i64 %1443
%1446 = bitcast float* %1445 to <4 x float>*
%1447 = load <4 x float>, <4 x float>* %1446
%1448 = getelementptr inbounds float, float* %1445, i64 4
%1449 = bitcast float* %1448 to <4 x float>*
%1450 = load <4 x float>, <4 x float>* %1449
%1451 = getelementptr inbounds float, float* %2, i64 %1443
%1452 = bitcast float* %1451 to <4 x float>*
store <4 x float> %1447, <4 x float>* %1452
%1453 = getelementptr inbounds float, float* %1451, i64 4
%1454 = bitcast float* %1453 to <4 x float>*
store <4 x float> %1450, <4 x float>* %1454
%1455 = add nuw i64 %1443, 8
%1456 = add i64 %1444, 1
%1457 = icmp eq i64 %1456, %1386
br i1 %1457, label %1458, label %1442
1458: ; preds = %1442, %1439
%1459 = icmp eq i64 %1382, %6
br i1 %1459, label %1497, label %1460
1460: ; preds = %1375, %1372, %1458
%1461 = phi i64 [ 0, %1375 ], [ 0, %1372 ], [ %1382, %1458 ]
%1462 = xor i64 %1461, -1
%1463 = add nsw i64 %1462, %6
%1464 = and i64 %6, 3
%1465 = icmp eq i64 %1464, 0
br i1 %1465, label %1475, label %1466
1466: ; preds = %1460, %1466
%1467 = phi i64 [ %1472, %1466 ], [ %1461, %1460 ]
%1468 = phi i64 [ %1473, %1466 ], [ 0, %1460 ]
%1469 = getelementptr inbounds float, float* %1, i64 %1467
%1470 = load float, float* %1469
%1471 = getelementptr inbounds float, float* %2, i64 %1467
store float %1470, float* %1471
%1472 = add nuw nsw i64 %1467, 1
%1473 = add i64 %1468, 1
%1474 = icmp eq i64 %1473, %1464
br i1 %1474, label %1475, label %1466
1475: ; preds = %1466, %1460
%1476 = phi i64 [ %1461, %1460 ], [ %1472, %1466 ]
%1477 = icmp ult i64 %1463, 3
br i1 %1477, label %1497, label %1604
1478: ; preds = %1349, %1478
%1479 = phi i64 [ %1495, %1478 ], [ %1350, %1349 ]
%1480 = getelementptr inbounds float, float* %1, i64 %1479
%1481 = load float, float* %1480
%1482 = getelementptr inbounds float, float* %2, i64 %1479
store float %1481, float* %1482
%1483 = add nuw nsw i64 %1479, 1
%1484 = getelementptr inbounds float, float* %1, i64 %1483
%1485 = load float, float* %1484
%1486 = getelementptr inbounds float, float* %2, i64 %1483
store float %1485, float* %1486
%1487 = add nuw nsw i64 %1479, 2
%1488 = getelementptr inbounds float, float* %1, i64 %1487
%1489 = load float, float* %1488
%1490 = getelementptr inbounds float, float* %2, i64 %1487
store float %1489, float* %1490
%1491 = add nuw nsw i64 %1479, 3
%1492 = getelementptr inbounds float, float* %1, i64 %1491
%1493 = load float, float* %1492
%1494 = getelementptr inbounds float, float* %2, i64 %1491
store float %1493, float* %1494
%1495 = add nuw nsw i64 %1479, 4
%1496 = icmp eq i64 %1495, %1247
br i1 %1496, label %1371, label %1478
1497: ; preds = %1475, %1604, %1458
br i1 %4, label %1498, label %3154
1498: ; preds = %1497
%1499 = zext i32 %0 to i64
%1500 = icmp ult i32 %0, 8
br i1 %1500, label %1586, label %1501
1501: ; preds = %1498
%1502 = getelementptr float, float* %2, i64 %6
%1503 = getelementptr float, float* %1, i64 %6
%1504 = icmp ugt float* %1503, %2
%1505 = icmp ugt float* %1502, %1
%1506 = and i1 %1504, %1505
br i1 %1506, label %1586, label %1507
1507: ; preds = %1501
%1508 = and i64 %6, 4294967288
%1509 = add nsw i64 %1508, -8
%1510 = lshr exact i64 %1509, 3
%1511 = add nuw nsw i64 %1510, 1
%1512 = and i64 %1511, 3
%1513 = icmp ult i64 %1509, 24
br i1 %1513, label %1565, label %1514
1514: ; preds = %1507
%1515 = and i64 %1511, 4611686018427387900
br label %1516
1516: ; preds = %1516, %1514
%1517 = phi i64 [ 0, %1514 ], [ %1562, %1516 ]
%1518 = phi i64 [ 0, %1514 ], [ %1563, %1516 ]
%1519 = getelementptr inbounds float, float* %1, i64 %1517
%1520 = bitcast float* %1519 to <4 x float>*
%1521 = load <4 x float>, <4 x float>* %1520
%1522 = getelementptr inbounds float, float* %1519, i64 4
%1523 = bitcast float* %1522 to <4 x float>*
%1524 = load <4 x float>, <4 x float>* %1523
%1525 = getelementptr inbounds float, float* %2, i64 %1517
%1526 = bitcast float* %1525 to <4 x float>*
store <4 x float> %1521, <4 x float>* %1526
%1527 = getelementptr inbounds float, float* %1525, i64 4
%1528 = bitcast float* %1527 to <4 x float>*
store <4 x float> %1524, <4 x float>* %1528
%1529 = or i64 %1517, 8
%1530 = getelementptr inbounds float, float* %1, i64 %1529
%1531 = bitcast float* %1530 to <4 x float>*
%1532 = load <4 x float>, <4 x float>* %1531
%1533 = getelementptr inbounds float, float* %1530, i64 4
%1534 = bitcast float* %1533 to <4 x float>*
%1535 = load <4 x float>, <4 x float>* %1534
%1536 = getelementptr inbounds float, float* %2, i64 %1529
%1537 = bitcast float* %1536 to <4 x float>*
store <4 x float> %1532, <4 x float>* %1537
%1538 = getelementptr inbounds float, float* %1536, i64 4
%1539 = bitcast float* %1538 to <4 x float>*
store <4 x float> %1535, <4 x float>* %1539
%1540 = or i64 %1517, 16
%1541 = getelementptr inbounds float, float* %1, i64 %1540
%1542 = bitcast float* %1541 to <4 x float>*
%1543 = load <4 x float>, <4 x float>* %1542
%1544 = getelementptr inbounds float, float* %1541, i64 4
%1545 = bitcast float* %1544 to <4 x float>*
%1546 = load <4 x float>, <4 x float>* %1545
%1547 = getelementptr inbounds float, float* %2, i64 %1540
%1548 = bitcast float* %1547 to <4 x float>*
store <4 x float> %1543, <4 x float>* %1548
%1549 = getelementptr inbounds float, float* %1547, i64 4
%1550 = bitcast float* %1549 to <4 x float>*
store <4 x float> %1546, <4 x float>* %1550
%1551 = or i64 %1517, 24
%1552 = getelementptr inbounds float, float* %1, i64 %1551
%1553 = bitcast float* %1552 to <4 x float>*
%1554 = load <4 x float>, <4 x float>* %1553
%1555 = getelementptr inbounds float, float* %1552, i64 4
%1556 = bitcast float* %1555 to <4 x float>*
%1557 = load <4 x float>, <4 x float>* %1556
%1558 = getelementptr inbounds float, float* %2, i64 %1551
%1559 = bitcast float* %1558 to <4 x float>*
store <4 x float> %1554, <4 x float>* %1559
%1560 = getelementptr inbounds float, float* %1558, i64 4
%1561 = bitcast float* %1560 to <4 x float>*
store <4 x float> %1557, <4 x float>* %1561
%1562 = add nuw i64 %1517, 32
%1563 = add i64 %1518, 4
%1564 = icmp eq i64 %1563, %1515
br i1 %1564, label %1565, label %1516
1565: ; preds = %1516, %1507
%1566 = phi i64 [ 0, %1507 ], [ %1562, %1516 ]
%1567 = icmp eq i64 %1512, 0
br i1 %1567, label %1584, label %1568
1568: ; preds = %1565, %1568
%1569 = phi i64 [ %1581, %1568 ], [ %1566, %1565 ]
%1570 = phi i64 [ %1582, %1568 ], [ 0, %1565 ]
%1571 = getelementptr inbounds float, float* %1, i64 %1569
%1572 = bitcast float* %1571 to <4 x float>*
%1573 = load <4 x float>, <4 x float>* %1572
%1574 = getelementptr inbounds float, float* %1571, i64 4
%1575 = bitcast float* %1574 to <4 x float>*
%1576 = load <4 x float>, <4 x float>* %1575
%1577 = getelementptr inbounds float, float* %2, i64 %1569
%1578 = bitcast float* %1577 to <4 x float>*
store <4 x float> %1573, <4 x float>* %1578
%1579 = getelementptr inbounds float, float* %1577, i64 4
%1580 = bitcast float* %1579 to <4 x float>*
store <4 x float> %1576, <4 x float>* %1580
%1581 = add nuw i64 %1569, 8
%1582 = add i64 %1570, 1
%1583 = icmp eq i64 %1582, %1512
br i1 %1583, label %1584, label %1568
1584: ; preds = %1568, %1565
%1585 = icmp eq i64 %1508, %6
br i1 %1585, label %1623, label %1586
1586: ; preds = %1501, %1498, %1584
%1587 = phi i64 [ 0, %1501 ], [ 0, %1498 ], [ %1508, %1584 ]
%1588 = xor i64 %1587, -1
%1589 = add nsw i64 %1588, %6
%1590 = and i64 %6, 3
%1591 = icmp eq i64 %1590, 0
br i1 %1591, label %1601, label %1592
1592: ; preds = %1586, %1592
%1593 = phi i64 [ %1598, %1592 ], [ %1587, %1586 ]
%1594 = phi i64 [ %1599, %1592 ], [ 0, %1586 ]
%1595 = getelementptr inbounds float, float* %1, i64 %1593
%1596 = load float, float* %1595
%1597 = getelementptr inbounds float, float* %2, i64 %1593
store float %1596, float* %1597
%1598 = add nuw nsw i64 %1593, 1
%1599 = add i64 %1594, 1
%1600 = icmp eq i64 %1599, %1590
br i1 %1600, label %1601, label %1592
1601: ; preds = %1592, %1586
%1602 = phi i64 [ %1587, %1586 ], [ %1598, %1592 ]
%1603 = icmp ult i64 %1589, 3
br i1 %1603, label %1623, label %1730
1604: ; preds = %1475, %1604
%1605 = phi i64 [ %1621, %1604 ], [ %1476, %1475 ]
%1606 = getelementptr inbounds float, float* %1, i64 %1605
%1607 = load float, float* %1606
%1608 = getelementptr inbounds float, float* %2, i64 %1605
store float %1607, float* %1608
%1609 = add nuw nsw i64 %1605, 1
%1610 = getelementptr inbounds float, float* %1, i64 %1609
%1611 = load float, float* %1610
%1612 = getelementptr inbounds float, float* %2, i64 %1609
store float %1611, float* %1612
%1613 = add nuw nsw i64 %1605, 2
%1614 = getelementptr inbounds float, float* %1, i64 %1613
%1615 = load float, float* %1614
%1616 = getelementptr inbounds float, float* %2, i64 %1613
store float %1615, float* %1616
%1617 = add nuw nsw i64 %1605, 3
%1618 = getelementptr inbounds float, float* %1, i64 %1617
%1619 = load float, float* %1618
%1620 = getelementptr inbounds float, float* %2, i64 %1617
store float %1619, float* %1620
%1621 = add nuw nsw i64 %1605, 4
%1622 = icmp eq i64 %1621, %1373
br i1 %1622, label %1497, label %1604
1623: ; preds = %1601, %1730, %1584
br i1 %4, label %1624, label %3154
1624: ; preds = %1623
%1625 = zext i32 %0 to i64
%1626 = icmp ult i32 %0, 8
br i1 %1626, label %1712, label %1627
1627: ; preds = %1624
%1628 = getelementptr float, float* %2, i64 %6
%1629 = getelementptr float, float* %1, i64 %6
%1630 = icmp ugt float* %1629, %2
%1631 = icmp ugt float* %1628, %1
%1632 = and i1 %1630, %1631
br i1 %1632, label %1712, label %1633
1633: ; preds = %1627
%1634 = and i64 %6, 4294967288
%1635 = add nsw i64 %1634, -8
%1636 = lshr exact i64 %1635, 3
%1637 = add nuw nsw i64 %1636, 1
%1638 = and i64 %1637, 3
%1639 = icmp ult i64 %1635, 24
br i1 %1639, label %1691, label %1640
1640: ; preds = %1633
%1641 = and i64 %1637, 4611686018427387900
br label %1642
1642: ; preds = %1642, %1640
%1643 = phi i64 [ 0, %1640 ], [ %1688, %1642 ]
%1644 = phi i64 [ 0, %1640 ], [ %1689, %1642 ]
%1645 = getelementptr inbounds float, float* %1, i64 %1643
%1646 = bitcast float* %1645 to <4 x float>*
%1647 = load <4 x float>, <4 x float>* %1646
%1648 = getelementptr inbounds float, float* %1645, i64 4
%1649 = bitcast float* %1648 to <4 x float>*
%1650 = load <4 x float>, <4 x float>* %1649
%1651 = getelementptr inbounds float, float* %2, i64 %1643
%1652 = bitcast float* %1651 to <4 x float>*
store <4 x float> %1647, <4 x float>* %1652
%1653 = getelementptr inbounds float, float* %1651, i64 4
%1654 = bitcast float* %1653 to <4 x float>*
store <4 x float> %1650, <4 x float>* %1654
%1655 = or i64 %1643, 8
%1656 = getelementptr inbounds float, float* %1, i64 %1655
%1657 = bitcast float* %1656 to <4 x float>*
%1658 = load <4 x float>, <4 x float>* %1657
%1659 = getelementptr inbounds float, float* %1656, i64 4
%1660 = bitcast float* %1659 to <4 x float>*
%1661 = load <4 x float>, <4 x float>* %1660
%1662 = getelementptr inbounds float, float* %2, i64 %1655
%1663 = bitcast float* %1662 to <4 x float>*
store <4 x float> %1658, <4 x float>* %1663
%1664 = getelementptr inbounds float, float* %1662, i64 4
%1665 = bitcast float* %1664 to <4 x float>*
store <4 x float> %1661, <4 x float>* %1665
%1666 = or i64 %1643, 16
%1667 = getelementptr inbounds float, float* %1, i64 %1666
%1668 = bitcast float* %1667 to <4 x float>*
%1669 = load <4 x float>, <4 x float>* %1668
%1670 = getelementptr inbounds float, float* %1667, i64 4
%1671 = bitcast float* %1670 to <4 x float>*
%1672 = load <4 x float>, <4 x float>* %1671
%1673 = getelementptr inbounds float, float* %2, i64 %1666
%1674 = bitcast float* %1673 to <4 x float>*
store <4 x float> %1669, <4 x float>* %1674
%1675 = getelementptr inbounds float, float* %1673, i64 4
%1676 = bitcast float* %1675 to <4 x float>*
store <4 x float> %1672, <4 x float>* %1676
%1677 = or i64 %1643, 24
%1678 = getelementptr inbounds float, float* %1, i64 %1677
%1679 = bitcast float* %1678 to <4 x float>*
%1680 = load <4 x float>, <4 x float>* %1679
%1681 = getelementptr inbounds float, float* %1678, i64 4
%1682 = bitcast float* %1681 to <4 x float>*
%1683 = load <4 x float>, <4 x float>* %1682
%1684 = getelementptr inbounds float, float* %2, i64 %1677
%1685 = bitcast float* %1684 to <4 x float>*
store <4 x float> %1680, <4 x float>* %1685
%1686 = getelementptr inbounds float, float* %1684, i64 4
%1687 = bitcast float* %1686 to <4 x float>*
store <4 x float> %1683, <4 x float>* %1687
%1688 = add nuw i64 %1643, 32
%1689 = add i64 %1644, 4
%1690 = icmp eq i64 %1689, %1641
br i1 %1690, label %1691, label %1642
1691: ; preds = %1642, %1633
%1692 = phi i64 [ 0, %1633 ], [ %1688, %1642 ]
%1693 = icmp eq i64 %1638, 0
br i1 %1693, label %1710, label %1694
1694: ; preds = %1691, %1694
%1695 = phi i64 [ %1707, %1694 ], [ %1692, %1691 ]
%1696 = phi i64 [ %1708, %1694 ], [ 0, %1691 ]
%1697 = getelementptr inbounds float, float* %1, i64 %1695
%1698 = bitcast float* %1697 to <4 x float>*
%1699 = load <4 x float>, <4 x float>* %1698
%1700 = getelementptr inbounds float, float* %1697, i64 4
%1701 = bitcast float* %1700 to <4 x float>*
%1702 = load <4 x float>, <4 x float>* %1701
%1703 = getelementptr inbounds float, float* %2, i64 %1695
%1704 = bitcast float* %1703 to <4 x float>*
store <4 x float> %1699, <4 x float>* %1704
%1705 = getelementptr inbounds float, float* %1703, i64 4
%1706 = bitcast float* %1705 to <4 x float>*
store <4 x float> %1702, <4 x float>* %1706
%1707 = add nuw i64 %1695, 8
%1708 = add i64 %1696, 1
%1709 = icmp eq i64 %1708, %1638
br i1 %1709, label %1710, label %1694
1710: ; preds = %1694, %1691
%1711 = icmp eq i64 %1634, %6
br i1 %1711, label %1749, label %1712
1712: ; preds = %1627, %1624, %1710
%1713 = phi i64 [ 0, %1627 ], [ 0, %1624 ], [ %1634, %1710 ]
%1714 = xor i64 %1713, -1
%1715 = add nsw i64 %1714, %6
%1716 = and i64 %6, 3
%1717 = icmp eq i64 %1716, 0
br i1 %1717, label %1727, label %1718
1718: ; preds = %1712, %1718
%1719 = phi i64 [ %1724, %1718 ], [ %1713, %1712 ]
%1720 = phi i64 [ %1725, %1718 ], [ 0, %1712 ]
%1721 = getelementptr inbounds float, float* %1, i64 %1719
%1722 = load float, float* %1721
%1723 = getelementptr inbounds float, float* %2, i64 %1719
store float %1722, float* %1723
%1724 = add nuw nsw i64 %1719, 1
%1725 = add i64 %1720, 1
%1726 = icmp eq i64 %1725, %1716
br i1 %1726, label %1727, label %1718
1727: ; preds = %1718, %1712
%1728 = phi i64 [ %1713, %1712 ], [ %1724, %1718 ]
%1729 = icmp ult i64 %1715, 3
br i1 %1729, label %1749, label %1856
1730: ; preds = %1601, %1730
%1731 = phi i64 [ %1747, %1730 ], [ %1602, %1601 ]
%1732 = getelementptr inbounds float, float* %1, i64 %1731
%1733 = load float, float* %1732
%1734 = getelementptr inbounds float, float* %2, i64 %1731
store float %1733, float* %1734
%1735 = add nuw nsw i64 %1731, 1
%1736 = getelementptr inbounds float, float* %1, i64 %1735
%1737 = load float, float* %1736
%1738 = getelementptr inbounds float, float* %2, i64 %1735
store float %1737, float* %1738
%1739 = add nuw nsw i64 %1731, 2
%1740 = getelementptr inbounds float, float* %1, i64 %1739
%1741 = load float, float* %1740
%1742 = getelementptr inbounds float, float* %2, i64 %1739
store float %1741, float* %1742
%1743 = add nuw nsw i64 %1731, 3
%1744 = getelementptr inbounds float, float* %1, i64 %1743
%1745 = load float, float* %1744
%1746 = getelementptr inbounds float, float* %2, i64 %1743
store float %1745, float* %1746
%1747 = add nuw nsw i64 %1731, 4
%1748 = icmp eq i64 %1747, %1499
br i1 %1748, label %1623, label %1730
1749: ; preds = %1727, %1856, %1710
br i1 %4, label %1750, label %3154
1750: ; preds = %1749
%1751 = zext i32 %0 to i64
%1752 = icmp ult i32 %0, 8
br i1 %1752, label %1838, label %1753
1753: ; preds = %1750
%1754 = getelementptr float, float* %2, i64 %6
%1755 = getelementptr float, float* %1, i64 %6
%1756 = icmp ugt float* %1755, %2
%1757 = icmp ugt float* %1754, %1
%1758 = and i1 %1756, %1757
br i1 %1758, label %1838, label %1759
1759: ; preds = %1753
%1760 = and i64 %6, 4294967288
%1761 = add nsw i64 %1760, -8
%1762 = lshr exact i64 %1761, 3
%1763 = add nuw nsw i64 %1762, 1
%1764 = and i64 %1763, 3
%1765 = icmp ult i64 %1761, 24
br i1 %1765, label %1817, label %1766
1766: ; preds = %1759
%1767 = and i64 %1763, 4611686018427387900
br label %1768
1768: ; preds = %1768, %1766
%1769 = phi i64 [ 0, %1766 ], [ %1814, %1768 ]
%1770 = phi i64 [ 0, %1766 ], [ %1815, %1768 ]
%1771 = getelementptr inbounds float, float* %1, i64 %1769
%1772 = bitcast float* %1771 to <4 x float>*
%1773 = load <4 x float>, <4 x float>* %1772
%1774 = getelementptr inbounds float, float* %1771, i64 4
%1775 = bitcast float* %1774 to <4 x float>*
%1776 = load <4 x float>, <4 x float>* %1775
%1777 = getelementptr inbounds float, float* %2, i64 %1769
%1778 = bitcast float* %1777 to <4 x float>*
store <4 x float> %1773, <4 x float>* %1778
%1779 = getelementptr inbounds float, float* %1777, i64 4
%1780 = bitcast float* %1779 to <4 x float>*
store <4 x float> %1776, <4 x float>* %1780
%1781 = or i64 %1769, 8
%1782 = getelementptr inbounds float, float* %1, i64 %1781
%1783 = bitcast float* %1782 to <4 x float>*
%1784 = load <4 x float>, <4 x float>* %1783
%1785 = getelementptr inbounds float, float* %1782, i64 4
%1786 = bitcast float* %1785 to <4 x float>*
%1787 = load <4 x float>, <4 x float>* %1786
%1788 = getelementptr inbounds float, float* %2, i64 %1781
%1789 = bitcast float* %1788 to <4 x float>*
store <4 x float> %1784, <4 x float>* %1789
%1790 = getelementptr inbounds float, float* %1788, i64 4
%1791 = bitcast float* %1790 to <4 x float>*
store <4 x float> %1787, <4 x float>* %1791
%1792 = or i64 %1769, 16
%1793 = getelementptr inbounds float, float* %1, i64 %1792
%1794 = bitcast float* %1793 to <4 x float>*
%1795 = load <4 x float>, <4 x float>* %1794
%1796 = getelementptr inbounds float, float* %1793, i64 4
%1797 = bitcast float* %1796 to <4 x float>*
%1798 = load <4 x float>, <4 x float>* %1797
%1799 = getelementptr inbounds float, float* %2, i64 %1792
%1800 = bitcast float* %1799 to <4 x float>*
store <4 x float> %1795, <4 x float>* %1800
%1801 = getelementptr inbounds float, float* %1799, i64 4
%1802 = bitcast float* %1801 to <4 x float>*
store <4 x float> %1798, <4 x float>* %1802
%1803 = or i64 %1769, 24
%1804 = getelementptr inbounds float, float* %1, i64 %1803
%1805 = bitcast float* %1804 to <4 x float>*
%1806 = load <4 x float>, <4 x float>* %1805
%1807 = getelementptr inbounds float, float* %1804, i64 4
%1808 = bitcast float* %1807 to <4 x float>*
%1809 = load <4 x float>, <4 x float>* %1808
%1810 = getelementptr inbounds float, float* %2, i64 %1803
%1811 = bitcast float* %1810 to <4 x float>*
store <4 x float> %1806, <4 x float>* %1811
%1812 = getelementptr inbounds float, float* %1810, i64 4
%1813 = bitcast float* %1812 to <4 x float>*
store <4 x float> %1809, <4 x float>* %1813
%1814 = add nuw i64 %1769, 32
%1815 = add i64 %1770, 4
%1816 = icmp eq i64 %1815, %1767
br i1 %1816, label %1817, label %1768
1817: ; preds = %1768, %1759
%1818 = phi i64 [ 0, %1759 ], [ %1814, %1768 ]
%1819 = icmp eq i64 %1764, 0
br i1 %1819, label %1836, label %1820
1820: ; preds = %1817, %1820
%1821 = phi i64 [ %1833, %1820 ], [ %1818, %1817 ]
%1822 = phi i64 [ %1834, %1820 ], [ 0, %1817 ]
%1823 = getelementptr inbounds float, float* %1, i64 %1821
%1824 = bitcast float* %1823 to <4 x float>*
%1825 = load <4 x float>, <4 x float>* %1824
%1826 = getelementptr inbounds float, float* %1823, i64 4
%1827 = bitcast float* %1826 to <4 x float>*
%1828 = load <4 x float>, <4 x float>* %1827
%1829 = getelementptr inbounds float, float* %2, i64 %1821
%1830 = bitcast float* %1829 to <4 x float>*
store <4 x float> %1825, <4 x float>* %1830
%1831 = getelementptr inbounds float, float* %1829, i64 4
%1832 = bitcast float* %1831 to <4 x float>*
store <4 x float> %1828, <4 x float>* %1832
%1833 = add nuw i64 %1821, 8
%1834 = add i64 %1822, 1
%1835 = icmp eq i64 %1834, %1764
br i1 %1835, label %1836, label %1820
1836: ; preds = %1820, %1817
%1837 = icmp eq i64 %1760, %6
br i1 %1837, label %1875, label %1838
1838: ; preds = %1753, %1750, %1836
%1839 = phi i64 [ 0, %1753 ], [ 0, %1750 ], [ %1760, %1836 ]
%1840 = xor i64 %1839, -1
%1841 = add nsw i64 %1840, %6
%1842 = and i64 %6, 3
%1843 = icmp eq i64 %1842, 0
br i1 %1843, label %1853, label %1844
1844: ; preds = %1838, %1844
%1845 = phi i64 [ %1850, %1844 ], [ %1839, %1838 ]
%1846 = phi i64 [ %1851, %1844 ], [ 0, %1838 ]
%1847 = getelementptr inbounds float, float* %1, i64 %1845
%1848 = load float, float* %1847
%1849 = getelementptr inbounds float, float* %2, i64 %1845
store float %1848, float* %1849
%1850 = add nuw nsw i64 %1845, 1
%1851 = add i64 %1846, 1
%1852 = icmp eq i64 %1851, %1842
br i1 %1852, label %1853, label %1844
1853: ; preds = %1844, %1838
%1854 = phi i64 [ %1839, %1838 ], [ %1850, %1844 ]
%1855 = icmp ult i64 %1841, 3
br i1 %1855, label %1875, label %1982
1856: ; preds = %1727, %1856
%1857 = phi i64 [ %1873, %1856 ], [ %1728, %1727 ]
%1858 = getelementptr inbounds float, float* %1, i64 %1857
%1859 = load float, float* %1858
%1860 = getelementptr inbounds float, float* %2, i64 %1857
store float %1859, float* %1860
%1861 = add nuw nsw i64 %1857, 1
%1862 = getelementptr inbounds float, float* %1, i64 %1861
%1863 = load float, float* %1862
%1864 = getelementptr inbounds float, float* %2, i64 %1861
store float %1863, float* %1864
%1865 = add nuw nsw i64 %1857, 2
%1866 = getelementptr inbounds float, float* %1, i64 %1865
%1867 = load float, float* %1866
%1868 = getelementptr inbounds float, float* %2, i64 %1865
store float %1867, float* %1868
%1869 = add nuw nsw i64 %1857, 3
%1870 = getelementptr inbounds float, float* %1, i64 %1869
%1871 = load float, float* %1870
%1872 = getelementptr inbounds float, float* %2, i64 %1869
store float %1871, float* %1872
%1873 = add nuw nsw i64 %1857, 4
%1874 = icmp eq i64 %1873, %1625
br i1 %1874, label %1749, label %1856
1875: ; preds = %1853, %1982, %1836
br i1 %4, label %1876, label %3154
1876: ; preds = %1875
%1877 = zext i32 %0 to i64
%1878 = icmp ult i32 %0, 8
br i1 %1878, label %1964, label %1879
1879: ; preds = %1876
%1880 = getelementptr float, float* %2, i64 %6
%1881 = getelementptr float, float* %1, i64 %6
%1882 = icmp ugt float* %1881, %2
%1883 = icmp ugt float* %1880, %1
%1884 = and i1 %1882, %1883
br i1 %1884, label %1964, label %1885
1885: ; preds = %1879
%1886 = and i64 %6, 4294967288
%1887 = add nsw i64 %1886, -8
%1888 = lshr exact i64 %1887, 3
%1889 = add nuw nsw i64 %1888, 1
%1890 = and i64 %1889, 3
%1891 = icmp ult i64 %1887, 24
br i1 %1891, label %1943, label %1892
1892: ; preds = %1885
%1893 = and i64 %1889, 4611686018427387900
br label %1894
1894: ; preds = %1894, %1892
%1895 = phi i64 [ 0, %1892 ], [ %1940, %1894 ]
%1896 = phi i64 [ 0, %1892 ], [ %1941, %1894 ]
%1897 = getelementptr inbounds float, float* %1, i64 %1895
%1898 = bitcast float* %1897 to <4 x float>*
%1899 = load <4 x float>, <4 x float>* %1898
%1900 = getelementptr inbounds float, float* %1897, i64 4
%1901 = bitcast float* %1900 to <4 x float>*
%1902 = load <4 x float>, <4 x float>* %1901
%1903 = getelementptr inbounds float, float* %2, i64 %1895
%1904 = bitcast float* %1903 to <4 x float>*
store <4 x float> %1899, <4 x float>* %1904
%1905 = getelementptr inbounds float, float* %1903, i64 4
%1906 = bitcast float* %1905 to <4 x float>*
store <4 x float> %1902, <4 x float>* %1906
%1907 = or i64 %1895, 8
%1908 = getelementptr inbounds float, float* %1, i64 %1907
%1909 = bitcast float* %1908 to <4 x float>*
%1910 = load <4 x float>, <4 x float>* %1909
%1911 = getelementptr inbounds float, float* %1908, i64 4
%1912 = bitcast float* %1911 to <4 x float>*
%1913 = load <4 x float>, <4 x float>* %1912
%1914 = getelementptr inbounds float, float* %2, i64 %1907
%1915 = bitcast float* %1914 to <4 x float>*
store <4 x float> %1910, <4 x float>* %1915
%1916 = getelementptr inbounds float, float* %1914, i64 4
%1917 = bitcast float* %1916 to <4 x float>*
store <4 x float> %1913, <4 x float>* %1917
%1918 = or i64 %1895, 16
%1919 = getelementptr inbounds float, float* %1, i64 %1918
%1920 = bitcast float* %1919 to <4 x float>*
%1921 = load <4 x float>, <4 x float>* %1920
%1922 = getelementptr inbounds float, float* %1919, i64 4
%1923 = bitcast float* %1922 to <4 x float>*
%1924 = load <4 x float>, <4 x float>* %1923
%1925 = getelementptr inbounds float, float* %2, i64 %1918
%1926 = bitcast float* %1925 to <4 x float>*
store <4 x float> %1921, <4 x float>* %1926
%1927 = getelementptr inbounds float, float* %1925, i64 4
%1928 = bitcast float* %1927 to <4 x float>*
store <4 x float> %1924, <4 x float>* %1928
%1929 = or i64 %1895, 24
%1930 = getelementptr inbounds float, float* %1, i64 %1929
%1931 = bitcast float* %1930 to <4 x float>*
%1932 = load <4 x float>, <4 x float>* %1931
%1933 = getelementptr inbounds float, float* %1930, i64 4
%1934 = bitcast float* %1933 to <4 x float>*
%1935 = load <4 x float>, <4 x float>* %1934
%1936 = getelementptr inbounds float, float* %2, i64 %1929
%1937 = bitcast float* %1936 to <4 x float>*
store <4 x float> %1932, <4 x float>* %1937
%1938 = getelementptr inbounds float, float* %1936, i64 4
%1939 = bitcast float* %1938 to <4 x float>*
store <4 x float> %1935, <4 x float>* %1939
%1940 = add nuw i64 %1895, 32
%1941 = add i64 %1896, 4
%1942 = icmp eq i64 %1941, %1893
br i1 %1942, label %1943, label %1894
1943: ; preds = %1894, %1885
%1944 = phi i64 [ 0, %1885 ], [ %1940, %1894 ]
%1945 = icmp eq i64 %1890, 0
br i1 %1945, label %1962, label %1946
1946: ; preds = %1943, %1946
%1947 = phi i64 [ %1959, %1946 ], [ %1944, %1943 ]
%1948 = phi i64 [ %1960, %1946 ], [ 0, %1943 ]
%1949 = getelementptr inbounds float, float* %1, i64 %1947
%1950 = bitcast float* %1949 to <4 x float>*
%1951 = load <4 x float>, <4 x float>* %1950
%1952 = getelementptr inbounds float, float* %1949, i64 4
%1953 = bitcast float* %1952 to <4 x float>*
%1954 = load <4 x float>, <4 x float>* %1953
%1955 = getelementptr inbounds float, float* %2, i64 %1947
%1956 = bitcast float* %1955 to <4 x float>*
store <4 x float> %1951, <4 x float>* %1956
%1957 = getelementptr inbounds float, float* %1955, i64 4
%1958 = bitcast float* %1957 to <4 x float>*
store <4 x float> %1954, <4 x float>* %1958
%1959 = add nuw i64 %1947, 8
%1960 = add i64 %1948, 1
%1961 = icmp eq i64 %1960, %1890
br i1 %1961, label %1962, label %1946
1962: ; preds = %1946, %1943
%1963 = icmp eq i64 %1886, %6
br i1 %1963, label %2001, label %1964
1964: ; preds = %1879, %1876, %1962
%1965 = phi i64 [ 0, %1879 ], [ 0, %1876 ], [ %1886, %1962 ]
%1966 = xor i64 %1965, -1
%1967 = add nsw i64 %1966, %6
%1968 = and i64 %6, 3
%1969 = icmp eq i64 %1968, 0
br i1 %1969, label %1979, label %1970
1970: ; preds = %1964, %1970
%1971 = phi i64 [ %1976, %1970 ], [ %1965, %1964 ]
%1972 = phi i64 [ %1977, %1970 ], [ 0, %1964 ]
%1973 = getelementptr inbounds float, float* %1, i64 %1971
%1974 = load float, float* %1973
%1975 = getelementptr inbounds float, float* %2, i64 %1971
store float %1974, float* %1975
%1976 = add nuw nsw i64 %1971, 1
%1977 = add i64 %1972, 1
%1978 = icmp eq i64 %1977, %1968
br i1 %1978, label %1979, label %1970
1979: ; preds = %1970, %1964
%1980 = phi i64 [ %1965, %1964 ], [ %1976, %1970 ]
%1981 = icmp ult i64 %1967, 3
br i1 %1981, label %2001, label %2108
1982: ; preds = %1853, %1982
%1983 = phi i64 [ %1999, %1982 ], [ %1854, %1853 ]
%1984 = getelementptr inbounds float, float* %1, i64 %1983
%1985 = load float, float* %1984
%1986 = getelementptr inbounds float, float* %2, i64 %1983
store float %1985, float* %1986
%1987 = add nuw nsw i64 %1983, 1
%1988 = getelementptr inbounds float, float* %1, i64 %1987
%1989 = load float, float* %1988
%1990 = getelementptr inbounds float, float* %2, i64 %1987
store float %1989, float* %1990
%1991 = add nuw nsw i64 %1983, 2
%1992 = getelementptr inbounds float, float* %1, i64 %1991
%1993 = load float, float* %1992
%1994 = getelementptr inbounds float, float* %2, i64 %1991
store float %1993, float* %1994
%1995 = add nuw nsw i64 %1983, 3
%1996 = getelementptr inbounds float, float* %1, i64 %1995
%1997 = load float, float* %1996
%1998 = getelementptr inbounds float, float* %2, i64 %1995
store float %1997, float* %1998
%1999 = add nuw nsw i64 %1983, 4
%2000 = icmp eq i64 %1999, %1751
br i1 %2000, label %1875, label %1982
2001: ; preds = %1979, %2108, %1962
br i1 %4, label %2002, label %3154
2002: ; preds = %2001
%2003 = zext i32 %0 to i64
%2004 = icmp ult i32 %0, 8
br i1 %2004, label %2090, label %2005
2005: ; preds = %2002
%2006 = getelementptr float, float* %2, i64 %6
%2007 = getelementptr float, float* %1, i64 %6
%2008 = icmp ugt float* %2007, %2
%2009 = icmp ugt float* %2006, %1
%2010 = and i1 %2008, %2009
br i1 %2010, label %2090, label %2011
2011: ; preds = %2005
%2012 = and i64 %6, 4294967288
%2013 = add nsw i64 %2012, -8
%2014 = lshr exact i64 %2013, 3
%2015 = add nuw nsw i64 %2014, 1
%2016 = and i64 %2015, 3
%2017 = icmp ult i64 %2013, 24
br i1 %2017, label %2069, label %2018
2018: ; preds = %2011
%2019 = and i64 %2015, 4611686018427387900
br label %2020
2020: ; preds = %2020, %2018
%2021 = phi i64 [ 0, %2018 ], [ %2066, %2020 ]
%2022 = phi i64 [ 0, %2018 ], [ %2067, %2020 ]
%2023 = getelementptr inbounds float, float* %1, i64 %2021
%2024 = bitcast float* %2023 to <4 x float>*
%2025 = load <4 x float>, <4 x float>* %2024
%2026 = getelementptr inbounds float, float* %2023, i64 4
%2027 = bitcast float* %2026 to <4 x float>*
%2028 = load <4 x float>, <4 x float>* %2027
%2029 = getelementptr inbounds float, float* %2, i64 %2021
%2030 = bitcast float* %2029 to <4 x float>*
store <4 x float> %2025, <4 x float>* %2030
%2031 = getelementptr inbounds float, float* %2029, i64 4
%2032 = bitcast float* %2031 to <4 x float>*
store <4 x float> %2028, <4 x float>* %2032
%2033 = or i64 %2021, 8
%2034 = getelementptr inbounds float, float* %1, i64 %2033
%2035 = bitcast float* %2034 to <4 x float>*
%2036 = load <4 x float>, <4 x float>* %2035
%2037 = getelementptr inbounds float, float* %2034, i64 4
%2038 = bitcast float* %2037 to <4 x float>*
%2039 = load <4 x float>, <4 x float>* %2038
%2040 = getelementptr inbounds float, float* %2, i64 %2033
%2041 = bitcast float* %2040 to <4 x float>*
store <4 x float> %2036, <4 x float>* %2041
%2042 = getelementptr inbounds float, float* %2040, i64 4
%2043 = bitcast float* %2042 to <4 x float>*
store <4 x float> %2039, <4 x float>* %2043
%2044 = or i64 %2021, 16
%2045 = getelementptr inbounds float, float* %1, i64 %2044
%2046 = bitcast float* %2045 to <4 x float>*
%2047 = load <4 x float>, <4 x float>* %2046
%2048 = getelementptr inbounds float, float* %2045, i64 4
%2049 = bitcast float* %2048 to <4 x float>*
%2050 = load <4 x float>, <4 x float>* %2049
%2051 = getelementptr inbounds float, float* %2, i64 %2044
%2052 = bitcast float* %2051 to <4 x float>*
store <4 x float> %2047, <4 x float>* %2052
%2053 = getelementptr inbounds float, float* %2051, i64 4
%2054 = bitcast float* %2053 to <4 x float>*
store <4 x float> %2050, <4 x float>* %2054
%2055 = or i64 %2021, 24
%2056 = getelementptr inbounds float, float* %1, i64 %2055
%2057 = bitcast float* %2056 to <4 x float>*
%2058 = load <4 x float>, <4 x float>* %2057
%2059 = getelementptr inbounds float, float* %2056, i64 4
%2060 = bitcast float* %2059 to <4 x float>*
%2061 = load <4 x float>, <4 x float>* %2060
%2062 = getelementptr inbounds float, float* %2, i64 %2055
%2063 = bitcast float* %2062 to <4 x float>*
store <4 x float> %2058, <4 x float>* %2063
%2064 = getelementptr inbounds float, float* %2062, i64 4
%2065 = bitcast float* %2064 to <4 x float>*
store <4 x float> %2061, <4 x float>* %2065
%2066 = add nuw i64 %2021, 32
%2067 = add i64 %2022, 4
%2068 = icmp eq i64 %2067, %2019
br i1 %2068, label %2069, label %2020
2069: ; preds = %2020, %2011
%2070 = phi i64 [ 0, %2011 ], [ %2066, %2020 ]
%2071 = icmp eq i64 %2016, 0
br i1 %2071, label %2088, label %2072
2072: ; preds = %2069, %2072
%2073 = phi i64 [ %2085, %2072 ], [ %2070, %2069 ]
%2074 = phi i64 [ %2086, %2072 ], [ 0, %2069 ]
%2075 = getelementptr inbounds float, float* %1, i64 %2073
%2076 = bitcast float* %2075 to <4 x float>*
%2077 = load <4 x float>, <4 x float>* %2076
%2078 = getelementptr inbounds float, float* %2075, i64 4
%2079 = bitcast float* %2078 to <4 x float>*
%2080 = load <4 x float>, <4 x float>* %2079
%2081 = getelementptr inbounds float, float* %2, i64 %2073
%2082 = bitcast float* %2081 to <4 x float>*
store <4 x float> %2077, <4 x float>* %2082
%2083 = getelementptr inbounds float, float* %2081, i64 4
%2084 = bitcast float* %2083 to <4 x float>*
store <4 x float> %2080, <4 x float>* %2084
%2085 = add nuw i64 %2073, 8
%2086 = add i64 %2074, 1
%2087 = icmp eq i64 %2086, %2016
br i1 %2087, label %2088, label %2072
2088: ; preds = %2072, %2069
%2089 = icmp eq i64 %2012, %6
br i1 %2089, label %2127, label %2090
2090: ; preds = %2005, %2002, %2088
%2091 = phi i64 [ 0, %2005 ], [ 0, %2002 ], [ %2012, %2088 ]
%2092 = xor i64 %2091, -1
%2093 = add nsw i64 %2092, %6
%2094 = and i64 %6, 3
%2095 = icmp eq i64 %2094, 0
br i1 %2095, label %2105, label %2096
2096: ; preds = %2090, %2096
%2097 = phi i64 [ %2102, %2096 ], [ %2091, %2090 ]
%2098 = phi i64 [ %2103, %2096 ], [ 0, %2090 ]
%2099 = getelementptr inbounds float, float* %1, i64 %2097
%2100 = load float, float* %2099
%2101 = getelementptr inbounds float, float* %2, i64 %2097
store float %2100, float* %2101
%2102 = add nuw nsw i64 %2097, 1
%2103 = add i64 %2098, 1
%2104 = icmp eq i64 %2103, %2094
br i1 %2104, label %2105, label %2096
2105: ; preds = %2096, %2090
%2106 = phi i64 [ %2091, %2090 ], [ %2102, %2096 ]
%2107 = icmp ult i64 %2093, 3
br i1 %2107, label %2127, label %2234
2108: ; preds = %1979, %2108
%2109 = phi i64 [ %2125, %2108 ], [ %1980, %1979 ]
%2110 = getelementptr inbounds float, float* %1, i64 %2109
%2111 = load float, float* %2110
%2112 = getelementptr inbounds float, float* %2, i64 %2109
store float %2111, float* %2112
%2113 = add nuw nsw i64 %2109, 1
%2114 = getelementptr inbounds float, float* %1, i64 %2113
%2115 = load float, float* %2114
%2116 = getelementptr inbounds float, float* %2, i64 %2113
store float %2115, float* %2116
%2117 = add nuw nsw i64 %2109, 2
%2118 = getelementptr inbounds float, float* %1, i64 %2117
%2119 = load float, float* %2118
%2120 = getelementptr inbounds float, float* %2, i64 %2117
store float %2119, float* %2120
%2121 = add nuw nsw i64 %2109, 3
%2122 = getelementptr inbounds float, float* %1, i64 %2121
%2123 = load float, float* %2122
%2124 = getelementptr inbounds float, float* %2, i64 %2121
store float %2123, float* %2124
%2125 = add nuw nsw i64 %2109, 4
%2126 = icmp eq i64 %2125, %1877
br i1 %2126, label %2001, label %2108
2127: ; preds = %2105, %2234, %2088
br i1 %4, label %2128, label %3154
2128: ; preds = %2127
%2129 = zext i32 %0 to i64
%2130 = icmp ult i32 %0, 8
br i1 %2130, label %2216, label %2131
2131: ; preds = %2128
%2132 = getelementptr float, float* %2, i64 %6
%2133 = getelementptr float, float* %1, i64 %6
%2134 = icmp ugt float* %2133, %2
%2135 = icmp ugt float* %2132, %1
%2136 = and i1 %2134, %2135
br i1 %2136, label %2216, label %2137
2137: ; preds = %2131
%2138 = and i64 %6, 4294967288
%2139 = add nsw i64 %2138, -8
%2140 = lshr exact i64 %2139, 3
%2141 = add nuw nsw i64 %2140, 1
%2142 = and i64 %2141, 3
%2143 = icmp ult i64 %2139, 24
br i1 %2143, label %2195, label %2144
2144: ; preds = %2137
%2145 = and i64 %2141, 4611686018427387900
br label %2146
2146: ; preds = %2146, %2144
%2147 = phi i64 [ 0, %2144 ], [ %2192, %2146 ]
%2148 = phi i64 [ 0, %2144 ], [ %2193, %2146 ]
%2149 = getelementptr inbounds float, float* %1, i64 %2147
%2150 = bitcast float* %2149 to <4 x float>*
%2151 = load <4 x float>, <4 x float>* %2150
%2152 = getelementptr inbounds float, float* %2149, i64 4
%2153 = bitcast float* %2152 to <4 x float>*
%2154 = load <4 x float>, <4 x float>* %2153
%2155 = getelementptr inbounds float, float* %2, i64 %2147
%2156 = bitcast float* %2155 to <4 x float>*
store <4 x float> %2151, <4 x float>* %2156
%2157 = getelementptr inbounds float, float* %2155, i64 4
%2158 = bitcast float* %2157 to <4 x float>*
store <4 x float> %2154, <4 x float>* %2158
%2159 = or i64 %2147, 8
%2160 = getelementptr inbounds float, float* %1, i64 %2159
%2161 = bitcast float* %2160 to <4 x float>*
%2162 = load <4 x float>, <4 x float>* %2161
%2163 = getelementptr inbounds float, float* %2160, i64 4
%2164 = bitcast float* %2163 to <4 x float>*
%2165 = load <4 x float>, <4 x float>* %2164
%2166 = getelementptr inbounds float, float* %2, i64 %2159
%2167 = bitcast float* %2166 to <4 x float>*
store <4 x float> %2162, <4 x float>* %2167
%2168 = getelementptr inbounds float, float* %2166, i64 4
%2169 = bitcast float* %2168 to <4 x float>*
store <4 x float> %2165, <4 x float>* %2169
%2170 = or i64 %2147, 16
%2171 = getelementptr inbounds float, float* %1, i64 %2170
%2172 = bitcast float* %2171 to <4 x float>*
%2173 = load <4 x float>, <4 x float>* %2172
%2174 = getelementptr inbounds float, float* %2171, i64 4
%2175 = bitcast float* %2174 to <4 x float>*
%2176 = load <4 x float>, <4 x float>* %2175
%2177 = getelementptr inbounds float, float* %2, i64 %2170
%2178 = bitcast float* %2177 to <4 x float>*
store <4 x float> %2173, <4 x float>* %2178
%2179 = getelementptr inbounds float, float* %2177, i64 4
%2180 = bitcast float* %2179 to <4 x float>*
store <4 x float> %2176, <4 x float>* %2180
%2181 = or i64 %2147, 24
%2182 = getelementptr inbounds float, float* %1, i64 %2181
%2183 = bitcast float* %2182 to <4 x float>*
%2184 = load <4 x float>, <4 x float>* %2183
%2185 = getelementptr inbounds float, float* %2182, i64 4
%2186 = bitcast float* %2185 to <4 x float>*
%2187 = load <4 x float>, <4 x float>* %2186
%2188 = getelementptr inbounds float, float* %2, i64 %2181
%2189 = bitcast float* %2188 to <4 x float>*
store <4 x float> %2184, <4 x float>* %2189
%2190 = getelementptr inbounds float, float* %2188, i64 4
%2191 = bitcast float* %2190 to <4 x float>*
store <4 x float> %2187, <4 x float>* %2191
%2192 = add nuw i64 %2147, 32
%2193 = add i64 %2148, 4
%2194 = icmp eq i64 %2193, %2145
br i1 %2194, label %2195, label %2146
2195: ; preds = %2146, %2137
%2196 = phi i64 [ 0, %2137 ], [ %2192, %2146 ]
%2197 = icmp eq i64 %2142, 0
br i1 %2197, label %2214, label %2198
2198: ; preds = %2195, %2198
%2199 = phi i64 [ %2211, %2198 ], [ %2196, %2195 ]
%2200 = phi i64 [ %2212, %2198 ], [ 0, %2195 ]
%2201 = getelementptr inbounds float, float* %1, i64 %2199
%2202 = bitcast float* %2201 to <4 x float>*
%2203 = load <4 x float>, <4 x float>* %2202
%2204 = getelementptr inbounds float, float* %2201, i64 4
%2205 = bitcast float* %2204 to <4 x float>*
%2206 = load <4 x float>, <4 x float>* %2205
%2207 = getelementptr inbounds float, float* %2, i64 %2199
%2208 = bitcast float* %2207 to <4 x float>*
store <4 x float> %2203, <4 x float>* %2208
%2209 = getelementptr inbounds float, float* %2207, i64 4
%2210 = bitcast float* %2209 to <4 x float>*
store <4 x float> %2206, <4 x float>* %2210
%2211 = add nuw i64 %2199, 8
%2212 = add i64 %2200, 1
%2213 = icmp eq i64 %2212, %2142
br i1 %2213, label %2214, label %2198
2214: ; preds = %2198, %2195
%2215 = icmp eq i64 %2138, %6
br i1 %2215, label %2253, label %2216
2216: ; preds = %2131, %2128, %2214
%2217 = phi i64 [ 0, %2131 ], [ 0, %2128 ], [ %2138, %2214 ]
%2218 = xor i64 %2217, -1
%2219 = add nsw i64 %2218, %6
%2220 = and i64 %6, 3
%2221 = icmp eq i64 %2220, 0
br i1 %2221, label %2231, label %2222
2222: ; preds = %2216, %2222
%2223 = phi i64 [ %2228, %2222 ], [ %2217, %2216 ]
%2224 = phi i64 [ %2229, %2222 ], [ 0, %2216 ]
%2225 = getelementptr inbounds float, float* %1, i64 %2223
%2226 = load float, float* %2225
%2227 = getelementptr inbounds float, float* %2, i64 %2223
store float %2226, float* %2227
%2228 = add nuw nsw i64 %2223, 1
%2229 = add i64 %2224, 1
%2230 = icmp eq i64 %2229, %2220
br i1 %2230, label %2231, label %2222
2231: ; preds = %2222, %2216
%2232 = phi i64 [ %2217, %2216 ], [ %2228, %2222 ]
%2233 = icmp ult i64 %2219, 3
br i1 %2233, label %2253, label %2360
2234: ; preds = %2105, %2234
%2235 = phi i64 [ %2251, %2234 ], [ %2106, %2105 ]
%2236 = getelementptr inbounds float, float* %1, i64 %2235
%2237 = load float, float* %2236
%2238 = getelementptr inbounds float, float* %2, i64 %2235
store float %2237, float* %2238
%2239 = add nuw nsw i64 %2235, 1
%2240 = getelementptr inbounds float, float* %1, i64 %2239
%2241 = load float, float* %2240
%2242 = getelementptr inbounds float, float* %2, i64 %2239
store float %2241, float* %2242
%2243 = add nuw nsw i64 %2235, 2
%2244 = getelementptr inbounds float, float* %1, i64 %2243
%2245 = load float, float* %2244
%2246 = getelementptr inbounds float, float* %2, i64 %2243
store float %2245, float* %2246
%2247 = add nuw nsw i64 %2235, 3
%2248 = getelementptr inbounds float, float* %1, i64 %2247
%2249 = load float, float* %2248
%2250 = getelementptr inbounds float, float* %2, i64 %2247
store float %2249, float* %2250
%2251 = add nuw nsw i64 %2235, 4
%2252 = icmp eq i64 %2251, %2003
br i1 %2252, label %2127, label %2234
2253: ; preds = %2231, %2360, %2214
br i1 %4, label %2254, label %3154
2254: ; preds = %2253
%2255 = zext i32 %0 to i64
%2256 = icmp ult i32 %0, 8
br i1 %2256, label %2342, label %2257
2257: ; preds = %2254
%2258 = getelementptr float, float* %2, i64 %6
%2259 = getelementptr float, float* %1, i64 %6
%2260 = icmp ugt float* %2259, %2
%2261 = icmp ugt float* %2258, %1
%2262 = and i1 %2260, %2261
br i1 %2262, label %2342, label %2263
2263: ; preds = %2257
%2264 = and i64 %6, 4294967288
%2265 = add nsw i64 %2264, -8
%2266 = lshr exact i64 %2265, 3
%2267 = add nuw nsw i64 %2266, 1
%2268 = and i64 %2267, 3
%2269 = icmp ult i64 %2265, 24
br i1 %2269, label %2321, label %2270
2270: ; preds = %2263
%2271 = and i64 %2267, 4611686018427387900
br label %2272
2272: ; preds = %2272, %2270
%2273 = phi i64 [ 0, %2270 ], [ %2318, %2272 ]
%2274 = phi i64 [ 0, %2270 ], [ %2319, %2272 ]
%2275 = getelementptr inbounds float, float* %1, i64 %2273
%2276 = bitcast float* %2275 to <4 x float>*
%2277 = load <4 x float>, <4 x float>* %2276
%2278 = getelementptr inbounds float, float* %2275, i64 4
%2279 = bitcast float* %2278 to <4 x float>*
%2280 = load <4 x float>, <4 x float>* %2279
%2281 = getelementptr inbounds float, float* %2, i64 %2273
%2282 = bitcast float* %2281 to <4 x float>*
store <4 x float> %2277, <4 x float>* %2282
%2283 = getelementptr inbounds float, float* %2281, i64 4
%2284 = bitcast float* %2283 to <4 x float>*
store <4 x float> %2280, <4 x float>* %2284
%2285 = or i64 %2273, 8
%2286 = getelementptr inbounds float, float* %1, i64 %2285
%2287 = bitcast float* %2286 to <4 x float>*
%2288 = load <4 x float>, <4 x float>* %2287
%2289 = getelementptr inbounds float, float* %2286, i64 4
%2290 = bitcast float* %2289 to <4 x float>*
%2291 = load <4 x float>, <4 x float>* %2290
%2292 = getelementptr inbounds float, float* %2, i64 %2285
%2293 = bitcast float* %2292 to <4 x float>*
store <4 x float> %2288, <4 x float>* %2293
%2294 = getelementptr inbounds float, float* %2292, i64 4
%2295 = bitcast float* %2294 to <4 x float>*
store <4 x float> %2291, <4 x float>* %2295
%2296 = or i64 %2273, 16
%2297 = getelementptr inbounds float, float* %1, i64 %2296
%2298 = bitcast float* %2297 to <4 x float>*
%2299 = load <4 x float>, <4 x float>* %2298
%2300 = getelementptr inbounds float, float* %2297, i64 4
%2301 = bitcast float* %2300 to <4 x float>*
%2302 = load <4 x float>, <4 x float>* %2301
%2303 = getelementptr inbounds float, float* %2, i64 %2296
%2304 = bitcast float* %2303 to <4 x float>*
store <4 x float> %2299, <4 x float>* %2304
%2305 = getelementptr inbounds float, float* %2303, i64 4
%2306 = bitcast float* %2305 to <4 x float>*
store <4 x float> %2302, <4 x float>* %2306
%2307 = or i64 %2273, 24
%2308 = getelementptr inbounds float, float* %1, i64 %2307
%2309 = bitcast float* %2308 to <4 x float>*
%2310 = load <4 x float>, <4 x float>* %2309
%2311 = getelementptr inbounds float, float* %2308, i64 4
%2312 = bitcast float* %2311 to <4 x float>*
%2313 = load <4 x float>, <4 x float>* %2312
%2314 = getelementptr inbounds float, float* %2, i64 %2307
%2315 = bitcast float* %2314 to <4 x float>*
store <4 x float> %2310, <4 x float>* %2315
%2316 = getelementptr inbounds float, float* %2314, i64 4
%2317 = bitcast float* %2316 to <4 x float>*
store <4 x float> %2313, <4 x float>* %2317
%2318 = add nuw i64 %2273, 32
%2319 = add i64 %2274, 4
%2320 = icmp eq i64 %2319, %2271
br i1 %2320, label %2321, label %2272
2321: ; preds = %2272, %2263
%2322 = phi i64 [ 0, %2263 ], [ %2318, %2272 ]
%2323 = icmp eq i64 %2268, 0
br i1 %2323, label %2340, label %2324
2324: ; preds = %2321, %2324
%2325 = phi i64 [ %2337, %2324 ], [ %2322, %2321 ]
%2326 = phi i64 [ %2338, %2324 ], [ 0, %2321 ]
%2327 = getelementptr inbounds float, float* %1, i64 %2325
%2328 = bitcast float* %2327 to <4 x float>*
%2329 = load <4 x float>, <4 x float>* %2328
%2330 = getelementptr inbounds float, float* %2327, i64 4
%2331 = bitcast float* %2330 to <4 x float>*
%2332 = load <4 x float>, <4 x float>* %2331
%2333 = getelementptr inbounds float, float* %2, i64 %2325
%2334 = bitcast float* %2333 to <4 x float>*
store <4 x float> %2329, <4 x float>* %2334
%2335 = getelementptr inbounds float, float* %2333, i64 4
%2336 = bitcast float* %2335 to <4 x float>*
store <4 x float> %2332, <4 x float>* %2336
%2337 = add nuw i64 %2325, 8
%2338 = add i64 %2326, 1
%2339 = icmp eq i64 %2338, %2268
br i1 %2339, label %2340, label %2324
2340: ; preds = %2324, %2321
%2341 = icmp eq i64 %2264, %6
br i1 %2341, label %2379, label %2342
2342: ; preds = %2257, %2254, %2340
%2343 = phi i64 [ 0, %2257 ], [ 0, %2254 ], [ %2264, %2340 ]
%2344 = xor i64 %2343, -1
%2345 = add nsw i64 %2344, %6
%2346 = and i64 %6, 3
%2347 = icmp eq i64 %2346, 0
br i1 %2347, label %2357, label %2348
2348: ; preds = %2342, %2348
%2349 = phi i64 [ %2354, %2348 ], [ %2343, %2342 ]
%2350 = phi i64 [ %2355, %2348 ], [ 0, %2342 ]
%2351 = getelementptr inbounds float, float* %1, i64 %2349
%2352 = load float, float* %2351
%2353 = getelementptr inbounds float, float* %2, i64 %2349
store float %2352, float* %2353
%2354 = add nuw nsw i64 %2349, 1
%2355 = add i64 %2350, 1
%2356 = icmp eq i64 %2355, %2346
br i1 %2356, label %2357, label %2348
2357: ; preds = %2348, %2342
%2358 = phi i64 [ %2343, %2342 ], [ %2354, %2348 ]
%2359 = icmp ult i64 %2345, 3
br i1 %2359, label %2379, label %2486
2360: ; preds = %2231, %2360
%2361 = phi i64 [ %2377, %2360 ], [ %2232, %2231 ]
%2362 = getelementptr inbounds float, float* %1, i64 %2361
%2363 = load float, float* %2362
%2364 = getelementptr inbounds float, float* %2, i64 %2361
store float %2363, float* %2364
%2365 = add nuw nsw i64 %2361, 1
%2366 = getelementptr inbounds float, float* %1, i64 %2365
%2367 = load float, float* %2366
%2368 = getelementptr inbounds float, float* %2, i64 %2365
store float %2367, float* %2368
%2369 = add nuw nsw i64 %2361, 2
%2370 = getelementptr inbounds float, float* %1, i64 %2369
%2371 = load float, float* %2370
%2372 = getelementptr inbounds float, float* %2, i64 %2369
store float %2371, float* %2372
%2373 = add nuw nsw i64 %2361, 3
%2374 = getelementptr inbounds float, float* %1, i64 %2373
%2375 = load float, float* %2374
%2376 = getelementptr inbounds float, float* %2, i64 %2373
store float %2375, float* %2376
%2377 = add nuw nsw i64 %2361, 4
%2378 = icmp eq i64 %2377, %2129
br i1 %2378, label %2253, label %2360
2379: ; preds = %2357, %2486, %2340
br i1 %4, label %2380, label %3154
2380: ; preds = %2379
%2381 = zext i32 %0 to i64
%2382 = icmp ult i32 %0, 8
br i1 %2382, label %2468, label %2383
2383: ; preds = %2380
%2384 = getelementptr float, float* %2, i64 %6
%2385 = getelementptr float, float* %1, i64 %6
%2386 = icmp ugt float* %2385, %2
%2387 = icmp ugt float* %2384, %1
%2388 = and i1 %2386, %2387
br i1 %2388, label %2468, label %2389
2389: ; preds = %2383
%2390 = and i64 %6, 4294967288
%2391 = add nsw i64 %2390, -8
%2392 = lshr exact i64 %2391, 3
%2393 = add nuw nsw i64 %2392, 1
%2394 = and i64 %2393, 3
%2395 = icmp ult i64 %2391, 24
br i1 %2395, label %2447, label %2396
2396: ; preds = %2389
%2397 = and i64 %2393, 4611686018427387900
br label %2398
2398: ; preds = %2398, %2396
%2399 = phi i64 [ 0, %2396 ], [ %2444, %2398 ]
%2400 = phi i64 [ 0, %2396 ], [ %2445, %2398 ]
%2401 = getelementptr inbounds float, float* %1, i64 %2399
%2402 = bitcast float* %2401 to <4 x float>*
%2403 = load <4 x float>, <4 x float>* %2402
%2404 = getelementptr inbounds float, float* %2401, i64 4
%2405 = bitcast float* %2404 to <4 x float>*
%2406 = load <4 x float>, <4 x float>* %2405
%2407 = getelementptr inbounds float, float* %2, i64 %2399
%2408 = bitcast float* %2407 to <4 x float>*
store <4 x float> %2403, <4 x float>* %2408
%2409 = getelementptr inbounds float, float* %2407, i64 4
%2410 = bitcast float* %2409 to <4 x float>*
store <4 x float> %2406, <4 x float>* %2410
%2411 = or i64 %2399, 8
%2412 = getelementptr inbounds float, float* %1, i64 %2411
%2413 = bitcast float* %2412 to <4 x float>*
%2414 = load <4 x float>, <4 x float>* %2413
%2415 = getelementptr inbounds float, float* %2412, i64 4
%2416 = bitcast float* %2415 to <4 x float>*
%2417 = load <4 x float>, <4 x float>* %2416
%2418 = getelementptr inbounds float, float* %2, i64 %2411
%2419 = bitcast float* %2418 to <4 x float>*
store <4 x float> %2414, <4 x float>* %2419
%2420 = getelementptr inbounds float, float* %2418, i64 4
%2421 = bitcast float* %2420 to <4 x float>*
store <4 x float> %2417, <4 x float>* %2421
%2422 = or i64 %2399, 16
%2423 = getelementptr inbounds float, float* %1, i64 %2422
%2424 = bitcast float* %2423 to <4 x float>*
%2425 = load <4 x float>, <4 x float>* %2424
%2426 = getelementptr inbounds float, float* %2423, i64 4
%2427 = bitcast float* %2426 to <4 x float>*
%2428 = load <4 x float>, <4 x float>* %2427
%2429 = getelementptr inbounds float, float* %2, i64 %2422
%2430 = bitcast float* %2429 to <4 x float>*
store <4 x float> %2425, <4 x float>* %2430
%2431 = getelementptr inbounds float, float* %2429, i64 4
%2432 = bitcast float* %2431 to <4 x float>*
store <4 x float> %2428, <4 x float>* %2432
%2433 = or i64 %2399, 24
%2434 = getelementptr inbounds float, float* %1, i64 %2433
%2435 = bitcast float* %2434 to <4 x float>*
%2436 = load <4 x float>, <4 x float>* %2435
%2437 = getelementptr inbounds float, float* %2434, i64 4
%2438 = bitcast float* %2437 to <4 x float>*
%2439 = load <4 x float>, <4 x float>* %2438
%2440 = getelementptr inbounds float, float* %2, i64 %2433
%2441 = bitcast float* %2440 to <4 x float>*
store <4 x float> %2436, <4 x float>* %2441
%2442 = getelementptr inbounds float, float* %2440, i64 4
%2443 = bitcast float* %2442 to <4 x float>*
store <4 x float> %2439, <4 x float>* %2443
%2444 = add nuw i64 %2399, 32
%2445 = add i64 %2400, 4
%2446 = icmp eq i64 %2445, %2397
br i1 %2446, label %2447, label %2398
2447: ; preds = %2398, %2389
%2448 = phi i64 [ 0, %2389 ], [ %2444, %2398 ]
%2449 = icmp eq i64 %2394, 0
br i1 %2449, label %2466, label %2450
2450: ; preds = %2447, %2450
%2451 = phi i64 [ %2463, %2450 ], [ %2448, %2447 ]
%2452 = phi i64 [ %2464, %2450 ], [ 0, %2447 ]
%2453 = getelementptr inbounds float, float* %1, i64 %2451
%2454 = bitcast float* %2453 to <4 x float>*
%2455 = load <4 x float>, <4 x float>* %2454
%2456 = getelementptr inbounds float, float* %2453, i64 4
%2457 = bitcast float* %2456 to <4 x float>*
%2458 = load <4 x float>, <4 x float>* %2457
%2459 = getelementptr inbounds float, float* %2, i64 %2451
%2460 = bitcast float* %2459 to <4 x float>*
store <4 x float> %2455, <4 x float>* %2460
%2461 = getelementptr inbounds float, float* %2459, i64 4
%2462 = bitcast float* %2461 to <4 x float>*
store <4 x float> %2458, <4 x float>* %2462
%2463 = add nuw i64 %2451, 8
%2464 = add i64 %2452, 1
%2465 = icmp eq i64 %2464, %2394
br i1 %2465, label %2466, label %2450
2466: ; preds = %2450, %2447
%2467 = icmp eq i64 %2390, %6
br i1 %2467, label %2505, label %2468
2468: ; preds = %2383, %2380, %2466
%2469 = phi i64 [ 0, %2383 ], [ 0, %2380 ], [ %2390, %2466 ]
%2470 = xor i64 %2469, -1
%2471 = add nsw i64 %2470, %6
%2472 = and i64 %6, 3
%2473 = icmp eq i64 %2472, 0
br i1 %2473, label %2483, label %2474
2474: ; preds = %2468, %2474
%2475 = phi i64 [ %2480, %2474 ], [ %2469, %2468 ]
%2476 = phi i64 [ %2481, %2474 ], [ 0, %2468 ]
%2477 = getelementptr inbounds float, float* %1, i64 %2475
%2478 = load float, float* %2477
%2479 = getelementptr inbounds float, float* %2, i64 %2475
store float %2478, float* %2479
%2480 = add nuw nsw i64 %2475, 1
%2481 = add i64 %2476, 1
%2482 = icmp eq i64 %2481, %2472
br i1 %2482, label %2483, label %2474
2483: ; preds = %2474, %2468
%2484 = phi i64 [ %2469, %2468 ], [ %2480, %2474 ]
%2485 = icmp ult i64 %2471, 3
br i1 %2485, label %2505, label %2612
2486: ; preds = %2357, %2486
%2487 = phi i64 [ %2503, %2486 ], [ %2358, %2357 ]
%2488 = getelementptr inbounds float, float* %1, i64 %2487
%2489 = load float, float* %2488
%2490 = getelementptr inbounds float, float* %2, i64 %2487
store float %2489, float* %2490
%2491 = add nuw nsw i64 %2487, 1
%2492 = getelementptr inbounds float, float* %1, i64 %2491
%2493 = load float, float* %2492
%2494 = getelementptr inbounds float, float* %2, i64 %2491
store float %2493, float* %2494
%2495 = add nuw nsw i64 %2487, 2
%2496 = getelementptr inbounds float, float* %1, i64 %2495
%2497 = load float, float* %2496
%2498 = getelementptr inbounds float, float* %2, i64 %2495
store float %2497, float* %2498
%2499 = add nuw nsw i64 %2487, 3
%2500 = getelementptr inbounds float, float* %1, i64 %2499
%2501 = load float, float* %2500
%2502 = getelementptr inbounds float, float* %2, i64 %2499
store float %2501, float* %2502
%2503 = add nuw nsw i64 %2487, 4
%2504 = icmp eq i64 %2503, %2255
br i1 %2504, label %2379, label %2486
2505: ; preds = %2483, %2612, %2466
br i1 %4, label %2506, label %3154
2506: ; preds = %2505
%2507 = zext i32 %0 to i64
%2508 = icmp ult i32 %0, 8
br i1 %2508, label %2594, label %2509
2509: ; preds = %2506
%2510 = getelementptr float, float* %2, i64 %6
%2511 = getelementptr float, float* %1, i64 %6
%2512 = icmp ugt float* %2511, %2
%2513 = icmp ugt float* %2510, %1
%2514 = and i1 %2512, %2513
br i1 %2514, label %2594, label %2515
2515: ; preds = %2509
%2516 = and i64 %6, 4294967288
%2517 = add nsw i64 %2516, -8
%2518 = lshr exact i64 %2517, 3
%2519 = add nuw nsw i64 %2518, 1
%2520 = and i64 %2519, 3
%2521 = icmp ult i64 %2517, 24
br i1 %2521, label %2573, label %2522
2522: ; preds = %2515
%2523 = and i64 %2519, 4611686018427387900
br label %2524
2524: ; preds = %2524, %2522
%2525 = phi i64 [ 0, %2522 ], [ %2570, %2524 ]
%2526 = phi i64 [ 0, %2522 ], [ %2571, %2524 ]
%2527 = getelementptr inbounds float, float* %1, i64 %2525
%2528 = bitcast float* %2527 to <4 x float>*
%2529 = load <4 x float>, <4 x float>* %2528
%2530 = getelementptr inbounds float, float* %2527, i64 4
%2531 = bitcast float* %2530 to <4 x float>*
%2532 = load <4 x float>, <4 x float>* %2531
%2533 = getelementptr inbounds float, float* %2, i64 %2525
%2534 = bitcast float* %2533 to <4 x float>*
store <4 x float> %2529, <4 x float>* %2534
%2535 = getelementptr inbounds float, float* %2533, i64 4
%2536 = bitcast float* %2535 to <4 x float>*
store <4 x float> %2532, <4 x float>* %2536
%2537 = or i64 %2525, 8
%2538 = getelementptr inbounds float, float* %1, i64 %2537
%2539 = bitcast float* %2538 to <4 x float>*
%2540 = load <4 x float>, <4 x float>* %2539
%2541 = getelementptr inbounds float, float* %2538, i64 4
%2542 = bitcast float* %2541 to <4 x float>*
%2543 = load <4 x float>, <4 x float>* %2542
%2544 = getelementptr inbounds float, float* %2, i64 %2537
%2545 = bitcast float* %2544 to <4 x float>*
store <4 x float> %2540, <4 x float>* %2545
%2546 = getelementptr inbounds float, float* %2544, i64 4
%2547 = bitcast float* %2546 to <4 x float>*
store <4 x float> %2543, <4 x float>* %2547
%2548 = or i64 %2525, 16
%2549 = getelementptr inbounds float, float* %1, i64 %2548
%2550 = bitcast float* %2549 to <4 x float>*
%2551 = load <4 x float>, <4 x float>* %2550
%2552 = getelementptr inbounds float, float* %2549, i64 4
%2553 = bitcast float* %2552 to <4 x float>*
%2554 = load <4 x float>, <4 x float>* %2553
%2555 = getelementptr inbounds float, float* %2, i64 %2548
%2556 = bitcast float* %2555 to <4 x float>*
store <4 x float> %2551, <4 x float>* %2556
%2557 = getelementptr inbounds float, float* %2555, i64 4
%2558 = bitcast float* %2557 to <4 x float>*
store <4 x float> %2554, <4 x float>* %2558
%2559 = or i64 %2525, 24
%2560 = getelementptr inbounds float, float* %1, i64 %2559
%2561 = bitcast float* %2560 to <4 x float>*
%2562 = load <4 x float>, <4 x float>* %2561
%2563 = getelementptr inbounds float, float* %2560, i64 4
%2564 = bitcast float* %2563 to <4 x float>*
%2565 = load <4 x float>, <4 x float>* %2564
%2566 = getelementptr inbounds float, float* %2, i64 %2559
%2567 = bitcast float* %2566 to <4 x float>*
store <4 x float> %2562, <4 x float>* %2567
%2568 = getelementptr inbounds float, float* %2566, i64 4
%2569 = bitcast float* %2568 to <4 x float>*
store <4 x float> %2565, <4 x float>* %2569
%2570 = add nuw i64 %2525, 32
%2571 = add i64 %2526, 4
%2572 = icmp eq i64 %2571, %2523
br i1 %2572, label %2573, label %2524
2573: ; preds = %2524, %2515
%2574 = phi i64 [ 0, %2515 ], [ %2570, %2524 ]
%2575 = icmp eq i64 %2520, 0
br i1 %2575, label %2592, label %2576
2576: ; preds = %2573, %2576
%2577 = phi i64 [ %2589, %2576 ], [ %2574, %2573 ]
%2578 = phi i64 [ %2590, %2576 ], [ 0, %2573 ]
%2579 = getelementptr inbounds float, float* %1, i64 %2577
%2580 = bitcast float* %2579 to <4 x float>*
%2581 = load <4 x float>, <4 x float>* %2580
%2582 = getelementptr inbounds float, float* %2579, i64 4
%2583 = bitcast float* %2582 to <4 x float>*
%2584 = load <4 x float>, <4 x float>* %2583
%2585 = getelementptr inbounds float, float* %2, i64 %2577
%2586 = bitcast float* %2585 to <4 x float>*
store <4 x float> %2581, <4 x float>* %2586
%2587 = getelementptr inbounds float, float* %2585, i64 4
%2588 = bitcast float* %2587 to <4 x float>*
store <4 x float> %2584, <4 x float>* %2588
%2589 = add nuw i64 %2577, 8
%2590 = add i64 %2578, 1
%2591 = icmp eq i64 %2590, %2520
br i1 %2591, label %2592, label %2576
2592: ; preds = %2576, %2573
%2593 = icmp eq i64 %2516, %6
br i1 %2593, label %2631, label %2594
2594: ; preds = %2509, %2506, %2592
%2595 = phi i64 [ 0, %2509 ], [ 0, %2506 ], [ %2516, %2592 ]
%2596 = xor i64 %2595, -1
%2597 = add nsw i64 %2596, %6
%2598 = and i64 %6, 3
%2599 = icmp eq i64 %2598, 0
br i1 %2599, label %2609, label %2600
2600: ; preds = %2594, %2600
%2601 = phi i64 [ %2606, %2600 ], [ %2595, %2594 ]
%2602 = phi i64 [ %2607, %2600 ], [ 0, %2594 ]
%2603 = getelementptr inbounds float, float* %1, i64 %2601
%2604 = load float, float* %2603
%2605 = getelementptr inbounds float, float* %2, i64 %2601
store float %2604, float* %2605
%2606 = add nuw nsw i64 %2601, 1
%2607 = add i64 %2602, 1
%2608 = icmp eq i64 %2607, %2598
br i1 %2608, label %2609, label %2600
2609: ; preds = %2600, %2594
%2610 = phi i64 [ %2595, %2594 ], [ %2606, %2600 ]
%2611 = icmp ult i64 %2597, 3
br i1 %2611, label %2631, label %2738
2612: ; preds = %2483, %2612
%2613 = phi i64 [ %2629, %2612 ], [ %2484, %2483 ]
%2614 = getelementptr inbounds float, float* %1, i64 %2613
%2615 = load float, float* %2614
%2616 = getelementptr inbounds float, float* %2, i64 %2613
store float %2615, float* %2616
%2617 = add nuw nsw i64 %2613, 1
%2618 = getelementptr inbounds float, float* %1, i64 %2617
%2619 = load float, float* %2618
%2620 = getelementptr inbounds float, float* %2, i64 %2617
store float %2619, float* %2620
%2621 = add nuw nsw i64 %2613, 2
%2622 = getelementptr inbounds float, float* %1, i64 %2621
%2623 = load float, float* %2622
%2624 = getelementptr inbounds float, float* %2, i64 %2621
store float %2623, float* %2624
%2625 = add nuw nsw i64 %2613, 3
%2626 = getelementptr inbounds float, float* %1, i64 %2625
%2627 = load float, float* %2626
%2628 = getelementptr inbounds float, float* %2, i64 %2625
store float %2627, float* %2628
%2629 = add nuw nsw i64 %2613, 4
%2630 = icmp eq i64 %2629, %2381
br i1 %2630, label %2505, label %2612
2631: ; preds = %2609, %2738, %2592
br i1 %4, label %2632, label %3154
2632: ; preds = %2631
%2633 = zext i32 %0 to i64
%2634 = icmp ult i32 %0, 8
br i1 %2634, label %2720, label %2635
2635: ; preds = %2632
%2636 = getelementptr float, float* %2, i64 %6
%2637 = getelementptr float, float* %1, i64 %6
%2638 = icmp ugt float* %2637, %2
%2639 = icmp ugt float* %2636, %1
%2640 = and i1 %2638, %2639
br i1 %2640, label %2720, label %2641
2641: ; preds = %2635
%2642 = and i64 %6, 4294967288
%2643 = add nsw i64 %2642, -8
%2644 = lshr exact i64 %2643, 3
%2645 = add nuw nsw i64 %2644, 1
%2646 = and i64 %2645, 3
%2647 = icmp ult i64 %2643, 24
br i1 %2647, label %2699, label %2648
2648: ; preds = %2641
%2649 = and i64 %2645, 4611686018427387900
br label %2650
2650: ; preds = %2650, %2648
%2651 = phi i64 [ 0, %2648 ], [ %2696, %2650 ]
%2652 = phi i64 [ 0, %2648 ], [ %2697, %2650 ]
%2653 = getelementptr inbounds float, float* %1, i64 %2651
%2654 = bitcast float* %2653 to <4 x float>*
%2655 = load <4 x float>, <4 x float>* %2654
%2656 = getelementptr inbounds float, float* %2653, i64 4
%2657 = bitcast float* %2656 to <4 x float>*
%2658 = load <4 x float>, <4 x float>* %2657
%2659 = getelementptr inbounds float, float* %2, i64 %2651
%2660 = bitcast float* %2659 to <4 x float>*
store <4 x float> %2655, <4 x float>* %2660
%2661 = getelementptr inbounds float, float* %2659, i64 4
%2662 = bitcast float* %2661 to <4 x float>*
store <4 x float> %2658, <4 x float>* %2662
%2663 = or i64 %2651, 8
%2664 = getelementptr inbounds float, float* %1, i64 %2663
%2665 = bitcast float* %2664 to <4 x float>*
%2666 = load <4 x float>, <4 x float>* %2665
%2667 = getelementptr inbounds float, float* %2664, i64 4
%2668 = bitcast float* %2667 to <4 x float>*
%2669 = load <4 x float>, <4 x float>* %2668
%2670 = getelementptr inbounds float, float* %2, i64 %2663
%2671 = bitcast float* %2670 to <4 x float>*
store <4 x float> %2666, <4 x float>* %2671
%2672 = getelementptr inbounds float, float* %2670, i64 4
%2673 = bitcast float* %2672 to <4 x float>*
store <4 x float> %2669, <4 x float>* %2673
%2674 = or i64 %2651, 16
%2675 = getelementptr inbounds float, float* %1, i64 %2674
%2676 = bitcast float* %2675 to <4 x float>*
%2677 = load <4 x float>, <4 x float>* %2676
%2678 = getelementptr inbounds float, float* %2675, i64 4
%2679 = bitcast float* %2678 to <4 x float>*
%2680 = load <4 x float>, <4 x float>* %2679
%2681 = getelementptr inbounds float, float* %2, i64 %2674
%2682 = bitcast float* %2681 to <4 x float>*
store <4 x float> %2677, <4 x float>* %2682
%2683 = getelementptr inbounds float, float* %2681, i64 4
%2684 = bitcast float* %2683 to <4 x float>*
store <4 x float> %2680, <4 x float>* %2684
%2685 = or i64 %2651, 24
%2686 = getelementptr inbounds float, float* %1, i64 %2685
%2687 = bitcast float* %2686 to <4 x float>*
%2688 = load <4 x float>, <4 x float>* %2687
%2689 = getelementptr inbounds float, float* %2686, i64 4
%2690 = bitcast float* %2689 to <4 x float>*
%2691 = load <4 x float>, <4 x float>* %2690
%2692 = getelementptr inbounds float, float* %2, i64 %2685
%2693 = bitcast float* %2692 to <4 x float>*
store <4 x float> %2688, <4 x float>* %2693
%2694 = getelementptr inbounds float, float* %2692, i64 4
%2695 = bitcast float* %2694 to <4 x float>*
store <4 x float> %2691, <4 x float>* %2695
%2696 = add nuw i64 %2651, 32
%2697 = add i64 %2652, 4
%2698 = icmp eq i64 %2697, %2649
br i1 %2698, label %2699, label %2650
2699: ; preds = %2650, %2641
%2700 = phi i64 [ 0, %2641 ], [ %2696, %2650 ]
%2701 = icmp eq i64 %2646, 0
br i1 %2701, label %2718, label %2702
2702: ; preds = %2699, %2702
%2703 = phi i64 [ %2715, %2702 ], [ %2700, %2699 ]
%2704 = phi i64 [ %2716, %2702 ], [ 0, %2699 ]
%2705 = getelementptr inbounds float, float* %1, i64 %2703
%2706 = bitcast float* %2705 to <4 x float>*
%2707 = load <4 x float>, <4 x float>* %2706
%2708 = getelementptr inbounds float, float* %2705, i64 4
%2709 = bitcast float* %2708 to <4 x float>*
%2710 = load <4 x float>, <4 x float>* %2709
%2711 = getelementptr inbounds float, float* %2, i64 %2703
%2712 = bitcast float* %2711 to <4 x float>*
store <4 x float> %2707, <4 x float>* %2712
%2713 = getelementptr inbounds float, float* %2711, i64 4
%2714 = bitcast float* %2713 to <4 x float>*
store <4 x float> %2710, <4 x float>* %2714
%2715 = add nuw i64 %2703, 8
%2716 = add i64 %2704, 1
%2717 = icmp eq i64 %2716, %2646
br i1 %2717, label %2718, label %2702
2718: ; preds = %2702, %2699
%2719 = icmp eq i64 %2642, %6
br i1 %2719, label %2757, label %2720
2720: ; preds = %2635, %2632, %2718
%2721 = phi i64 [ 0, %2635 ], [ 0, %2632 ], [ %2642, %2718 ]
%2722 = xor i64 %2721, -1
%2723 = add nsw i64 %2722, %6
%2724 = and i64 %6, 3
%2725 = icmp eq i64 %2724, 0
br i1 %2725, label %2735, label %2726
2726: ; preds = %2720, %2726
%2727 = phi i64 [ %2732, %2726 ], [ %2721, %2720 ]
%2728 = phi i64 [ %2733, %2726 ], [ 0, %2720 ]
%2729 = getelementptr inbounds float, float* %1, i64 %2727
%2730 = load float, float* %2729
%2731 = getelementptr inbounds float, float* %2, i64 %2727
store float %2730, float* %2731
%2732 = add nuw nsw i64 %2727, 1
%2733 = add i64 %2728, 1
%2734 = icmp eq i64 %2733, %2724
br i1 %2734, label %2735, label %2726
2735: ; preds = %2726, %2720
%2736 = phi i64 [ %2721, %2720 ], [ %2732, %2726 ]
%2737 = icmp ult i64 %2723, 3
br i1 %2737, label %2757, label %2864
2738: ; preds = %2609, %2738
%2739 = phi i64 [ %2755, %2738 ], [ %2610, %2609 ]
%2740 = getelementptr inbounds float, float* %1, i64 %2739
%2741 = load float, float* %2740
%2742 = getelementptr inbounds float, float* %2, i64 %2739
store float %2741, float* %2742
%2743 = add nuw nsw i64 %2739, 1
%2744 = getelementptr inbounds float, float* %1, i64 %2743
%2745 = load float, float* %2744
%2746 = getelementptr inbounds float, float* %2, i64 %2743
store float %2745, float* %2746
%2747 = add nuw nsw i64 %2739, 2
%2748 = getelementptr inbounds float, float* %1, i64 %2747
%2749 = load float, float* %2748
%2750 = getelementptr inbounds float, float* %2, i64 %2747
store float %2749, float* %2750
%2751 = add nuw nsw i64 %2739, 3
%2752 = getelementptr inbounds float, float* %1, i64 %2751
%2753 = load float, float* %2752
%2754 = getelementptr inbounds float, float* %2, i64 %2751
store float %2753, float* %2754
%2755 = add nuw nsw i64 %2739, 4
%2756 = icmp eq i64 %2755, %2507
br i1 %2756, label %2631, label %2738
2757: ; preds = %2735, %2864, %2718
br i1 %4, label %2758, label %3154
2758: ; preds = %2757
%2759 = zext i32 %0 to i64
%2760 = icmp ult i32 %0, 8
br i1 %2760, label %2846, label %2761
2761: ; preds = %2758
%2762 = getelementptr float, float* %2, i64 %6
%2763 = getelementptr float, float* %1, i64 %6
%2764 = icmp ugt float* %2763, %2
%2765 = icmp ugt float* %2762, %1
%2766 = and i1 %2764, %2765
br i1 %2766, label %2846, label %2767
2767: ; preds = %2761
%2768 = and i64 %6, 4294967288
%2769 = add nsw i64 %2768, -8
%2770 = lshr exact i64 %2769, 3
%2771 = add nuw nsw i64 %2770, 1
%2772 = and i64 %2771, 3
%2773 = icmp ult i64 %2769, 24
br i1 %2773, label %2825, label %2774
2774: ; preds = %2767
%2775 = and i64 %2771, 4611686018427387900
br label %2776
2776: ; preds = %2776, %2774
%2777 = phi i64 [ 0, %2774 ], [ %2822, %2776 ]
%2778 = phi i64 [ 0, %2774 ], [ %2823, %2776 ]
%2779 = getelementptr inbounds float, float* %1, i64 %2777
%2780 = bitcast float* %2779 to <4 x float>*
%2781 = load <4 x float>, <4 x float>* %2780
%2782 = getelementptr inbounds float, float* %2779, i64 4
%2783 = bitcast float* %2782 to <4 x float>*
%2784 = load <4 x float>, <4 x float>* %2783
%2785 = getelementptr inbounds float, float* %2, i64 %2777
%2786 = bitcast float* %2785 to <4 x float>*
store <4 x float> %2781, <4 x float>* %2786
%2787 = getelementptr inbounds float, float* %2785, i64 4
%2788 = bitcast float* %2787 to <4 x float>*
store <4 x float> %2784, <4 x float>* %2788
%2789 = or i64 %2777, 8
%2790 = getelementptr inbounds float, float* %1, i64 %2789
%2791 = bitcast float* %2790 to <4 x float>*
%2792 = load <4 x float>, <4 x float>* %2791
%2793 = getelementptr inbounds float, float* %2790, i64 4
%2794 = bitcast float* %2793 to <4 x float>*
%2795 = load <4 x float>, <4 x float>* %2794
%2796 = getelementptr inbounds float, float* %2, i64 %2789
%2797 = bitcast float* %2796 to <4 x float>*
store <4 x float> %2792, <4 x float>* %2797
%2798 = getelementptr inbounds float, float* %2796, i64 4
%2799 = bitcast float* %2798 to <4 x float>*
store <4 x float> %2795, <4 x float>* %2799
%2800 = or i64 %2777, 16
%2801 = getelementptr inbounds float, float* %1, i64 %2800
%2802 = bitcast float* %2801 to <4 x float>*
%2803 = load <4 x float>, <4 x float>* %2802
%2804 = getelementptr inbounds float, float* %2801, i64 4
%2805 = bitcast float* %2804 to <4 x float>*
%2806 = load <4 x float>, <4 x float>* %2805
%2807 = getelementptr inbounds float, float* %2, i64 %2800
%2808 = bitcast float* %2807 to <4 x float>*
store <4 x float> %2803, <4 x float>* %2808
%2809 = getelementptr inbounds float, float* %2807, i64 4
%2810 = bitcast float* %2809 to <4 x float>*
store <4 x float> %2806, <4 x float>* %2810
%2811 = or i64 %2777, 24
%2812 = getelementptr inbounds float, float* %1, i64 %2811
%2813 = bitcast float* %2812 to <4 x float>*
%2814 = load <4 x float>, <4 x float>* %2813
%2815 = getelementptr inbounds float, float* %2812, i64 4
%2816 = bitcast float* %2815 to <4 x float>*
%2817 = load <4 x float>, <4 x float>* %2816
%2818 = getelementptr inbounds float, float* %2, i64 %2811
%2819 = bitcast float* %2818 to <4 x float>*
store <4 x float> %2814, <4 x float>* %2819
%2820 = getelementptr inbounds float, float* %2818, i64 4
%2821 = bitcast float* %2820 to <4 x float>*
store <4 x float> %2817, <4 x float>* %2821
%2822 = add nuw i64 %2777, 32
%2823 = add i64 %2778, 4
%2824 = icmp eq i64 %2823, %2775
br i1 %2824, label %2825, label %2776
2825: ; preds = %2776, %2767
%2826 = phi i64 [ 0, %2767 ], [ %2822, %2776 ]
%2827 = icmp eq i64 %2772, 0
br i1 %2827, label %2844, label %2828
2828: ; preds = %2825, %2828
%2829 = phi i64 [ %2841, %2828 ], [ %2826, %2825 ]
%2830 = phi i64 [ %2842, %2828 ], [ 0, %2825 ]
%2831 = getelementptr inbounds float, float* %1, i64 %2829
%2832 = bitcast float* %2831 to <4 x float>*
%2833 = load <4 x float>, <4 x float>* %2832
%2834 = getelementptr inbounds float, float* %2831, i64 4
%2835 = bitcast float* %2834 to <4 x float>*
%2836 = load <4 x float>, <4 x float>* %2835
%2837 = getelementptr inbounds float, float* %2, i64 %2829
%2838 = bitcast float* %2837 to <4 x float>*
store <4 x float> %2833, <4 x float>* %2838
%2839 = getelementptr inbounds float, float* %2837, i64 4
%2840 = bitcast float* %2839 to <4 x float>*
store <4 x float> %2836, <4 x float>* %2840
%2841 = add nuw i64 %2829, 8
%2842 = add i64 %2830, 1
%2843 = icmp eq i64 %2842, %2772
br i1 %2843, label %2844, label %2828
2844: ; preds = %2828, %2825
%2845 = icmp eq i64 %2768, %6
br i1 %2845, label %2883, label %2846
2846: ; preds = %2761, %2758, %2844
%2847 = phi i64 [ 0, %2761 ], [ 0, %2758 ], [ %2768, %2844 ]
%2848 = xor i64 %2847, -1
%2849 = add nsw i64 %2848, %6
%2850 = and i64 %6, 3
%2851 = icmp eq i64 %2850, 0
br i1 %2851, label %2861, label %2852
2852: ; preds = %2846, %2852
%2853 = phi i64 [ %2858, %2852 ], [ %2847, %2846 ]
%2854 = phi i64 [ %2859, %2852 ], [ 0, %2846 ]
%2855 = getelementptr inbounds float, float* %1, i64 %2853
%2856 = load float, float* %2855
%2857 = getelementptr inbounds float, float* %2, i64 %2853
store float %2856, float* %2857
%2858 = add nuw nsw i64 %2853, 1
%2859 = add i64 %2854, 1
%2860 = icmp eq i64 %2859, %2850
br i1 %2860, label %2861, label %2852
2861: ; preds = %2852, %2846
%2862 = phi i64 [ %2847, %2846 ], [ %2858, %2852 ]
%2863 = icmp ult i64 %2849, 3
br i1 %2863, label %2883, label %2990
2864: ; preds = %2735, %2864
%2865 = phi i64 [ %2881, %2864 ], [ %2736, %2735 ]
%2866 = getelementptr inbounds float, float* %1, i64 %2865
%2867 = load float, float* %2866
%2868 = getelementptr inbounds float, float* %2, i64 %2865
store float %2867, float* %2868
%2869 = add nuw nsw i64 %2865, 1
%2870 = getelementptr inbounds float, float* %1, i64 %2869
%2871 = load float, float* %2870
%2872 = getelementptr inbounds float, float* %2, i64 %2869
store float %2871, float* %2872
%2873 = add nuw nsw i64 %2865, 2
%2874 = getelementptr inbounds float, float* %1, i64 %2873
%2875 = load float, float* %2874
%2876 = getelementptr inbounds float, float* %2, i64 %2873
store float %2875, float* %2876
%2877 = add nuw nsw i64 %2865, 3
%2878 = getelementptr inbounds float, float* %1, i64 %2877
%2879 = load float, float* %2878
%2880 = getelementptr inbounds float, float* %2, i64 %2877
store float %2879, float* %2880
%2881 = add nuw nsw i64 %2865, 4
%2882 = icmp eq i64 %2881, %2633
br i1 %2882, label %2757, label %2864
2883: ; preds = %2861, %2990, %2844
br i1 %4, label %2884, label %3154
2884: ; preds = %2883
%2885 = zext i32 %0 to i64
%2886 = icmp ult i32 %0, 8
br i1 %2886, label %2972, label %2887
2887: ; preds = %2884
%2888 = getelementptr float, float* %2, i64 %6
%2889 = getelementptr float, float* %1, i64 %6
%2890 = icmp ugt float* %2889, %2
%2891 = icmp ugt float* %2888, %1
%2892 = and i1 %2890, %2891
br i1 %2892, label %2972, label %2893
2893: ; preds = %2887
%2894 = and i64 %6, 4294967288
%2895 = add nsw i64 %2894, -8
%2896 = lshr exact i64 %2895, 3
%2897 = add nuw nsw i64 %2896, 1
%2898 = and i64 %2897, 3
%2899 = icmp ult i64 %2895, 24
br i1 %2899, label %2951, label %2900
2900: ; preds = %2893
%2901 = and i64 %2897, 4611686018427387900
br label %2902
2902: ; preds = %2902, %2900
%2903 = phi i64 [ 0, %2900 ], [ %2948, %2902 ]
%2904 = phi i64 [ 0, %2900 ], [ %2949, %2902 ]
%2905 = getelementptr inbounds float, float* %1, i64 %2903
%2906 = bitcast float* %2905 to <4 x float>*
%2907 = load <4 x float>, <4 x float>* %2906
%2908 = getelementptr inbounds float, float* %2905, i64 4
%2909 = bitcast float* %2908 to <4 x float>*
%2910 = load <4 x float>, <4 x float>* %2909
%2911 = getelementptr inbounds float, float* %2, i64 %2903
%2912 = bitcast float* %2911 to <4 x float>*
store <4 x float> %2907, <4 x float>* %2912
%2913 = getelementptr inbounds float, float* %2911, i64 4
%2914 = bitcast float* %2913 to <4 x float>*
store <4 x float> %2910, <4 x float>* %2914
%2915 = or i64 %2903, 8
%2916 = getelementptr inbounds float, float* %1, i64 %2915
%2917 = bitcast float* %2916 to <4 x float>*
%2918 = load <4 x float>, <4 x float>* %2917
%2919 = getelementptr inbounds float, float* %2916, i64 4
%2920 = bitcast float* %2919 to <4 x float>*
%2921 = load <4 x float>, <4 x float>* %2920
%2922 = getelementptr inbounds float, float* %2, i64 %2915
%2923 = bitcast float* %2922 to <4 x float>*
store <4 x float> %2918, <4 x float>* %2923
%2924 = getelementptr inbounds float, float* %2922, i64 4
%2925 = bitcast float* %2924 to <4 x float>*
store <4 x float> %2921, <4 x float>* %2925
%2926 = or i64 %2903, 16
%2927 = getelementptr inbounds float, float* %1, i64 %2926
%2928 = bitcast float* %2927 to <4 x float>*
%2929 = load <4 x float>, <4 x float>* %2928
%2930 = getelementptr inbounds float, float* %2927, i64 4
%2931 = bitcast float* %2930 to <4 x float>*
%2932 = load <4 x float>, <4 x float>* %2931
%2933 = getelementptr inbounds float, float* %2, i64 %2926
%2934 = bitcast float* %2933 to <4 x float>*
store <4 x float> %2929, <4 x float>* %2934
%2935 = getelementptr inbounds float, float* %2933, i64 4
%2936 = bitcast float* %2935 to <4 x float>*
store <4 x float> %2932, <4 x float>* %2936
%2937 = or i64 %2903, 24
%2938 = getelementptr inbounds float, float* %1, i64 %2937
%2939 = bitcast float* %2938 to <4 x float>*
%2940 = load <4 x float>, <4 x float>* %2939
%2941 = getelementptr inbounds float, float* %2938, i64 4
%2942 = bitcast float* %2941 to <4 x float>*
%2943 = load <4 x float>, <4 x float>* %2942
%2944 = getelementptr inbounds float, float* %2, i64 %2937
%2945 = bitcast float* %2944 to <4 x float>*
store <4 x float> %2940, <4 x float>* %2945
%2946 = getelementptr inbounds float, float* %2944, i64 4
%2947 = bitcast float* %2946 to <4 x float>*
store <4 x float> %2943, <4 x float>* %2947
%2948 = add nuw i64 %2903, 32
%2949 = add i64 %2904, 4
%2950 = icmp eq i64 %2949, %2901
br i1 %2950, label %2951, label %2902
2951: ; preds = %2902, %2893
%2952 = phi i64 [ 0, %2893 ], [ %2948, %2902 ]
%2953 = icmp eq i64 %2898, 0
br i1 %2953, label %2970, label %2954
2954: ; preds = %2951, %2954
%2955 = phi i64 [ %2967, %2954 ], [ %2952, %2951 ]
%2956 = phi i64 [ %2968, %2954 ], [ 0, %2951 ]
%2957 = getelementptr inbounds float, float* %1, i64 %2955
%2958 = bitcast float* %2957 to <4 x float>*
%2959 = load <4 x float>, <4 x float>* %2958
%2960 = getelementptr inbounds float, float* %2957, i64 4
%2961 = bitcast float* %2960 to <4 x float>*
%2962 = load <4 x float>, <4 x float>* %2961
%2963 = getelementptr inbounds float, float* %2, i64 %2955
%2964 = bitcast float* %2963 to <4 x float>*
store <4 x float> %2959, <4 x float>* %2964
%2965 = getelementptr inbounds float, float* %2963, i64 4
%2966 = bitcast float* %2965 to <4 x float>*
store <4 x float> %2962, <4 x float>* %2966
%2967 = add nuw i64 %2955, 8
%2968 = add i64 %2956, 1
%2969 = icmp eq i64 %2968, %2898
br i1 %2969, label %2970, label %2954
2970: ; preds = %2954, %2951
%2971 = icmp eq i64 %2894, %6
br i1 %2971, label %3009, label %2972
2972: ; preds = %2887, %2884, %2970
%2973 = phi i64 [ 0, %2887 ], [ 0, %2884 ], [ %2894, %2970 ]
%2974 = xor i64 %2973, -1
%2975 = add nsw i64 %2974, %6
%2976 = and i64 %6, 3
%2977 = icmp eq i64 %2976, 0
br i1 %2977, label %2987, label %2978
2978: ; preds = %2972, %2978
%2979 = phi i64 [ %2984, %2978 ], [ %2973, %2972 ]
%2980 = phi i64 [ %2985, %2978 ], [ 0, %2972 ]
%2981 = getelementptr inbounds float, float* %1, i64 %2979
%2982 = load float, float* %2981
%2983 = getelementptr inbounds float, float* %2, i64 %2979
store float %2982, float* %2983
%2984 = add nuw nsw i64 %2979, 1
%2985 = add i64 %2980, 1
%2986 = icmp eq i64 %2985, %2976
br i1 %2986, label %2987, label %2978
2987: ; preds = %2978, %2972
%2988 = phi i64 [ %2973, %2972 ], [ %2984, %2978 ]
%2989 = icmp ult i64 %2975, 3
br i1 %2989, label %3009, label %3116
2990: ; preds = %2861, %2990
%2991 = phi i64 [ %3007, %2990 ], [ %2862, %2861 ]
%2992 = getelementptr inbounds float, float* %1, i64 %2991
%2993 = load float, float* %2992
%2994 = getelementptr inbounds float, float* %2, i64 %2991
store float %2993, float* %2994
%2995 = add nuw nsw i64 %2991, 1
%2996 = getelementptr inbounds float, float* %1, i64 %2995
%2997 = load float, float* %2996
%2998 = getelementptr inbounds float, float* %2, i64 %2995
store float %2997, float* %2998
%2999 = add nuw nsw i64 %2991, 2
%3000 = getelementptr inbounds float, float* %1, i64 %2999
%3001 = load float, float* %3000
%3002 = getelementptr inbounds float, float* %2, i64 %2999
store float %3001, float* %3002
%3003 = add nuw nsw i64 %2991, 3
%3004 = getelementptr inbounds float, float* %1, i64 %3003
%3005 = load float, float* %3004
%3006 = getelementptr inbounds float, float* %2, i64 %3003
store float %3005, float* %3006
%3007 = add nuw nsw i64 %2991, 4
%3008 = icmp eq i64 %3007, %2759
br i1 %3008, label %2883, label %2990
3009: ; preds = %2987, %3116, %2970
br i1 %4, label %3010, label %3154
3010: ; preds = %3009
%3011 = zext i32 %0 to i64
%3012 = icmp ult i32 %0, 8
br i1 %3012, label %3098, label %3013
3013: ; preds = %3010
%3014 = getelementptr float, float* %2, i64 %6
%3015 = getelementptr float, float* %1, i64 %6
%3016 = icmp ugt float* %3015, %2
%3017 = icmp ugt float* %3014, %1
%3018 = and i1 %3016, %3017
br i1 %3018, label %3098, label %3019
3019: ; preds = %3013
%3020 = and i64 %6, 4294967288
%3021 = add nsw i64 %3020, -8
%3022 = lshr exact i64 %3021, 3
%3023 = add nuw nsw i64 %3022, 1
%3024 = and i64 %3023, 3
%3025 = icmp ult i64 %3021, 24
br i1 %3025, label %3077, label %3026
3026: ; preds = %3019
%3027 = and i64 %3023, 4611686018427387900
br label %3028
3028: ; preds = %3028, %3026
%3029 = phi i64 [ 0, %3026 ], [ %3074, %3028 ]
%3030 = phi i64 [ 0, %3026 ], [ %3075, %3028 ]
%3031 = getelementptr inbounds float, float* %1, i64 %3029
%3032 = bitcast float* %3031 to <4 x float>*
%3033 = load <4 x float>, <4 x float>* %3032
%3034 = getelementptr inbounds float, float* %3031, i64 4
%3035 = bitcast float* %3034 to <4 x float>*
%3036 = load <4 x float>, <4 x float>* %3035
%3037 = getelementptr inbounds float, float* %2, i64 %3029
%3038 = bitcast float* %3037 to <4 x float>*
store <4 x float> %3033, <4 x float>* %3038
%3039 = getelementptr inbounds float, float* %3037, i64 4
%3040 = bitcast float* %3039 to <4 x float>*
store <4 x float> %3036, <4 x float>* %3040
%3041 = or i64 %3029, 8
%3042 = getelementptr inbounds float, float* %1, i64 %3041
%3043 = bitcast float* %3042 to <4 x float>*
%3044 = load <4 x float>, <4 x float>* %3043
%3045 = getelementptr inbounds float, float* %3042, i64 4
%3046 = bitcast float* %3045 to <4 x float>*
%3047 = load <4 x float>, <4 x float>* %3046
%3048 = getelementptr inbounds float, float* %2, i64 %3041
%3049 = bitcast float* %3048 to <4 x float>*
store <4 x float> %3044, <4 x float>* %3049
%3050 = getelementptr inbounds float, float* %3048, i64 4
%3051 = bitcast float* %3050 to <4 x float>*
store <4 x float> %3047, <4 x float>* %3051
%3052 = or i64 %3029, 16
%3053 = getelementptr inbounds float, float* %1, i64 %3052
%3054 = bitcast float* %3053 to <4 x float>*
%3055 = load <4 x float>, <4 x float>* %3054
%3056 = getelementptr inbounds float, float* %3053, i64 4
%3057 = bitcast float* %3056 to <4 x float>*
%3058 = load <4 x float>, <4 x float>* %3057
%3059 = getelementptr inbounds float, float* %2, i64 %3052
%3060 = bitcast float* %3059 to <4 x float>*
store <4 x float> %3055, <4 x float>* %3060
%3061 = getelementptr inbounds float, float* %3059, i64 4
%3062 = bitcast float* %3061 to <4 x float>*
store <4 x float> %3058, <4 x float>* %3062
%3063 = or i64 %3029, 24
%3064 = getelementptr inbounds float, float* %1, i64 %3063
%3065 = bitcast float* %3064 to <4 x float>*
%3066 = load <4 x float>, <4 x float>* %3065
%3067 = getelementptr inbounds float, float* %3064, i64 4
%3068 = bitcast float* %3067 to <4 x float>*
%3069 = load <4 x float>, <4 x float>* %3068
%3070 = getelementptr inbounds float, float* %2, i64 %3063
%3071 = bitcast float* %3070 to <4 x float>*
store <4 x float> %3066, <4 x float>* %3071
%3072 = getelementptr inbounds float, float* %3070, i64 4
%3073 = bitcast float* %3072 to <4 x float>*
store <4 x float> %3069, <4 x float>* %3073
%3074 = add nuw i64 %3029, 32
%3075 = add i64 %3030, 4
%3076 = icmp eq i64 %3075, %3027
br i1 %3076, label %3077, label %3028
3077: ; preds = %3028, %3019
%3078 = phi i64 [ 0, %3019 ], [ %3074, %3028 ]
%3079 = icmp eq i64 %3024, 0
br i1 %3079, label %3096, label %3080
3080: ; preds = %3077, %3080
%3081 = phi i64 [ %3093, %3080 ], [ %3078, %3077 ]
%3082 = phi i64 [ %3094, %3080 ], [ 0, %3077 ]
%3083 = getelementptr inbounds float, float* %1, i64 %3081
%3084 = bitcast float* %3083 to <4 x float>*
%3085 = load <4 x float>, <4 x float>* %3084
%3086 = getelementptr inbounds float, float* %3083, i64 4
%3087 = bitcast float* %3086 to <4 x float>*
%3088 = load <4 x float>, <4 x float>* %3087
%3089 = getelementptr inbounds float, float* %2, i64 %3081
%3090 = bitcast float* %3089 to <4 x float>*
store <4 x float> %3085, <4 x float>* %3090
%3091 = getelementptr inbounds float, float* %3089, i64 4
%3092 = bitcast float* %3091 to <4 x float>*
store <4 x float> %3088, <4 x float>* %3092
%3093 = add nuw i64 %3081, 8
%3094 = add i64 %3082, 1
%3095 = icmp eq i64 %3094, %3024
br i1 %3095, label %3096, label %3080
3096: ; preds = %3080, %3077
%3097 = icmp eq i64 %3020, %6
br i1 %3097, label %3154, label %3098
3098: ; preds = %3013, %3010, %3096
%3099 = phi i64 [ 0, %3013 ], [ 0, %3010 ], [ %3020, %3096 ]
%3100 = xor i64 %3099, -1
%3101 = add nsw i64 %3100, %6
%3102 = and i64 %6, 3
%3103 = icmp eq i64 %3102, 0
br i1 %3103, label %3113, label %3104
3104: ; preds = %3098, %3104
%3105 = phi i64 [ %3110, %3104 ], [ %3099, %3098 ]
%3106 = phi i64 [ %3111, %3104 ], [ 0, %3098 ]
%3107 = getelementptr inbounds float, float* %1, i64 %3105
%3108 = load float, float* %3107
%3109 = getelementptr inbounds float, float* %2, i64 %3105
store float %3108, float* %3109
%3110 = add nuw nsw i64 %3105, 1
%3111 = add i64 %3106, 1
%3112 = icmp eq i64 %3111, %3102
br i1 %3112, label %3113, label %3104
3113: ; preds = %3104, %3098
%3114 = phi i64 [ %3099, %3098 ], [ %3110, %3104 ]
%3115 = icmp ult i64 %3101, 3
br i1 %3115, label %3154, label %3135
3116: ; preds = %2987, %3116
%3117 = phi i64 [ %3133, %3116 ], [ %2988, %2987 ]
%3118 = getelementptr inbounds float, float* %1, i64 %3117
%3119 = load float, float* %3118
%3120 = getelementptr inbounds float, float* %2, i64 %3117
store float %3119, float* %3120
%3121 = add nuw nsw i64 %3117, 1
%3122 = getelementptr inbounds float, float* %1, i64 %3121
%3123 = load float, float* %3122
%3124 = getelementptr inbounds float, float* %2, i64 %3121
store float %3123, float* %3124
%3125 = add nuw nsw i64 %3117, 2
%3126 = getelementptr inbounds float, float* %1, i64 %3125
%3127 = load float, float* %3126
%3128 = getelementptr inbounds float, float* %2, i64 %3125
store float %3127, float* %3128
%3129 = add nuw nsw i64 %3117, 3
%3130 = getelementptr inbounds float, float* %1, i64 %3129
%3131 = load float, float* %3130
%3132 = getelementptr inbounds float, float* %2, i64 %3129
store float %3131, float* %3132
%3133 = add nuw nsw i64 %3117, 4
%3134 = icmp eq i64 %3133, %2885
br i1 %3134, label %3009, label %3116
3135: ; preds = %3113, %3135
%3136 = phi i64 [ %3152, %3135 ], [ %3114, %3113 ]
%3137 = getelementptr inbounds float, float* %1, i64 %3136
%3138 = load float, float* %3137
%3139 = getelementptr inbounds float, float* %2, i64 %3136
store float %3138, float* %3139
%3140 = add nuw nsw i64 %3136, 1
%3141 = getelementptr inbounds float, float* %1, i64 %3140
%3142 = load float, float* %3141
%3143 = getelementptr inbounds float, float* %2, i64 %3140
store float %3142, float* %3143
%3144 = add nuw nsw i64 %3136, 2
%3145 = getelementptr inbounds float, float* %1, i64 %3144
%3146 = load float, float* %3145
%3147 = getelementptr inbounds float, float* %2, i64 %3144
store float %3146, float* %3147
%3148 = add nuw nsw i64 %3136, 3
%3149 = getelementptr inbounds float, float* %1, i64 %3148
%3150 = load float, float* %3149
%3151 = getelementptr inbounds float, float* %2, i64 %3148
store float %3150, float* %3151
%3152 = add nuw nsw i64 %3136, 4
%3153 = icmp eq i64 %3152, %3011
br i1 %3153, label %3154, label %3135
3154: ; preds = %3113, %3135, %3096, %3, %111, %237, %363, %489, %615, %741, %867, %993, %1119, %1245, %1371, %1497, %1623, %1749, %1875, %2001, %2127, %2253, %2379, %2505, %2631, %2757, %2883, %3009
ret void
}