void foo(int n, float *a, float *b) {
  int i;
#pragma omp simd
  for (i = 0; i < n; i++)
    a[i] = b[i];
#pragma omp for simd
  for (i = 0; i < n; i++)
    a[i] = b[i];
#pragma omp distribute simd
  for (i = 0; i < n; i++)
    a[i] = b[i];
#pragma omp distribute parallel for simd
  for (i = 0; i < n; i++)
    a[i] = b[i];
#pragma omp parallel for simd
  for (i = 0; i < n; i++)
    a[i] = b[i];
#pragma omp teams distribute simd
  for (i = 0; i < n; i++)
    a[i] = b[i];
#pragma omp target teams distribute simd
  for (i = 0; i < n; i++)
    a[i] = b[i];
#pragma omp teams distribute parallel for simd
  for (i = 0; i < n; i++)
    a[i] = b[i];
#pragma omp target teams distribute parallel for simd
  for (i = 0; i < n; i++)
    a[i] = b[i];
}


x86 assembly (clang, -O0):
<foo>:
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 <foo+0x4a>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1116 <foo+0x16>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1185 <foo+0x85>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1151 <foo+0x51>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11c0 <foo+0xc0>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    118c <foo+0x8c>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11fb <foo+0xfb>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11c7 <foo+0xc7>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1236 <foo+0x136>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1202 <foo+0x102>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1271 <foo+0x171>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    123d <foo+0x13d>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12ac <foo+0x1ac>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1278 <foo+0x178>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12e7 <foo+0x1e7>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12b3 <foo+0x1b3>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1322 <foo+0x222>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12ee <foo+0x1ee>
pop    %rbp
ret

x86 assembly (clang, -O2):
<foo>:
test   %edi,%edi
jle    1dc1 <foo+0xcc1>
mov    %edi,%r8d
cmp    $0x8,%edi
jb     1126 <foo+0x26>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    119c <foo+0x9c>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    119c <foo+0x9c>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     1154 <foo+0x54>
nopw   0x0(%rax,%rax,1)
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1140 <foo+0x40>
cmp    $0x3,%r9
jb     1278 <foo+0x178>
xchg   %ax,%ax
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsi,%rcx,4)
movss  0x8(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x8(%rsi,%rcx,4)
movss  0xc(%rdx,%rcx,4),%xmm0
movss  %xmm0,0xc(%rsi,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1160 <foo+0x60>
jmp    1278 <foo+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 <foo+0xc2>
xor    %eax,%eax
jmp    1228 <foo+0x128>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups (%rdx,%rax,4),%xmm0
movups 0x10(%rdx,%rax,4),%xmm1
movups %xmm0,(%rsi,%rax,4)
movups %xmm1,0x10(%rsi,%rax,4)
movups 0x20(%rdx,%rax,4),%xmm0
movups 0x30(%rdx,%rax,4),%xmm1
movups %xmm0,0x20(%rsi,%rax,4)
movups %xmm1,0x30(%rsi,%rax,4)
movups 0x40(%rdx,%rax,4),%xmm0
movups 0x50(%rdx,%rax,4),%xmm1
movups %xmm0,0x40(%rsi,%rax,4)
movups %xmm1,0x50(%rsi,%rax,4)
movups 0x60(%rdx,%rax,4),%xmm0
movups 0x70(%rdx,%rax,4),%xmm1
movups %xmm0,0x60(%rsi,%rax,4)
movups %xmm1,0x70(%rsi,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    11d0 <foo+0xd0>
test   %r9,%r9
je     126f <foo+0x16f>
lea    (%rsi,%rax,4),%r10
add    $0x10,%r10
lea    (%rdx,%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 <foo+0x150>
cmp    %r8,%rcx
jne    1128 <foo+0x28>
test   %edi,%edi
jle    1dc1 <foo+0xcc1>
cmp    $0x8,%edi
jb     129b <foo+0x19b>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    130c <foo+0x20c>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    130c <foo+0x20c>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     12c4 <foo+0x1c4>
nop
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    12b0 <foo+0x1b0>
cmp    $0x3,%r9
jb     13e8 <foo+0x2e8>
xchg   %ax,%ax
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsi,%rcx,4)
movss  0x8(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x8(%rsi,%rcx,4)
movss  0xc(%rdx,%rcx,4),%xmm0
movss  %xmm0,0xc(%rsi,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    12d0 <foo+0x1d0>
jmp    13e8 <foo+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 <foo+0x232>
xor    %eax,%eax
jmp    1398 <foo+0x298>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups (%rdx,%rax,4),%xmm0
movups 0x10(%rdx,%rax,4),%xmm1
movups %xmm0,(%rsi,%rax,4)
movups %xmm1,0x10(%rsi,%rax,4)
movups 0x20(%rdx,%rax,4),%xmm0
movups 0x30(%rdx,%rax,4),%xmm1
movups %xmm0,0x20(%rsi,%rax,4)
movups %xmm1,0x30(%rsi,%rax,4)
movups 0x40(%rdx,%rax,4),%xmm0
movups 0x50(%rdx,%rax,4),%xmm1
movups %xmm0,0x40(%rsi,%rax,4)
movups %xmm1,0x50(%rsi,%rax,4)
movups 0x60(%rdx,%rax,4),%xmm0
movups 0x70(%rdx,%rax,4),%xmm1
movups %xmm0,0x60(%rsi,%rax,4)
movups %xmm1,0x70(%rsi,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    1340 <foo+0x240>
test   %r9,%r9
je     13df <foo+0x2df>
lea    (%rsi,%rax,4),%r10
add    $0x10,%r10
lea    (%rdx,%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 <foo+0x2c0>
cmp    %r8,%rcx
jne    129d <foo+0x19d>
test   %edi,%edi
jle    1dc1 <foo+0xcc1>
cmp    $0x8,%edi
jb     140b <foo+0x30b>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    147c <foo+0x37c>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    147c <foo+0x37c>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     1434 <foo+0x334>
nop
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1420 <foo+0x320>
cmp    $0x3,%r9
jb     1558 <foo+0x458>
xchg   %ax,%ax
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsi,%rcx,4)
movss  0x8(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x8(%rsi,%rcx,4)
movss  0xc(%rdx,%rcx,4),%xmm0
movss  %xmm0,0xc(%rsi,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1440 <foo+0x340>
jmp    1558 <foo+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 <foo+0x3a2>
xor    %eax,%eax
jmp    1508 <foo+0x408>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups (%rdx,%rax,4),%xmm0
movups 0x10(%rdx,%rax,4),%xmm1
movups %xmm0,(%rsi,%rax,4)
movups %xmm1,0x10(%rsi,%rax,4)
movups 0x20(%rdx,%rax,4),%xmm0
movups 0x30(%rdx,%rax,4),%xmm1
movups %xmm0,0x20(%rsi,%rax,4)
movups %xmm1,0x30(%rsi,%rax,4)
movups 0x40(%rdx,%rax,4),%xmm0
movups 0x50(%rdx,%rax,4),%xmm1
movups %xmm0,0x40(%rsi,%rax,4)
movups %xmm1,0x50(%rsi,%rax,4)
movups 0x60(%rdx,%rax,4),%xmm0
movups 0x70(%rdx,%rax,4),%xmm1
movups %xmm0,0x60(%rsi,%rax,4)
movups %xmm1,0x70(%rsi,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    14b0 <foo+0x3b0>
test   %r9,%r9
je     154f <foo+0x44f>
lea    (%rsi,%rax,4),%r10
add    $0x10,%r10
lea    (%rdx,%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 <foo+0x430>
cmp    %r8,%rcx
jne    140d <foo+0x30d>
test   %edi,%edi
jle    1dc1 <foo+0xcc1>
cmp    $0x8,%edi
jb     157b <foo+0x47b>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    15ec <foo+0x4ec>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    15ec <foo+0x4ec>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     15a4 <foo+0x4a4>
nop
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1590 <foo+0x490>
cmp    $0x3,%r9
jb     16c8 <foo+0x5c8>
xchg   %ax,%ax
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsi,%rcx,4)
movss  0x8(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x8(%rsi,%rcx,4)
movss  0xc(%rdx,%rcx,4),%xmm0
movss  %xmm0,0xc(%rsi,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    15b0 <foo+0x4b0>
jmp    16c8 <foo+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 <foo+0x512>
xor    %eax,%eax
jmp    1678 <foo+0x578>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups (%rdx,%rax,4),%xmm0
movups 0x10(%rdx,%rax,4),%xmm1
movups %xmm0,(%rsi,%rax,4)
movups %xmm1,0x10(%rsi,%rax,4)
movups 0x20(%rdx,%rax,4),%xmm0
movups 0x30(%rdx,%rax,4),%xmm1
movups %xmm0,0x20(%rsi,%rax,4)
movups %xmm1,0x30(%rsi,%rax,4)
movups 0x40(%rdx,%rax,4),%xmm0
movups 0x50(%rdx,%rax,4),%xmm1
movups %xmm0,0x40(%rsi,%rax,4)
movups %xmm1,0x50(%rsi,%rax,4)
movups 0x60(%rdx,%rax,4),%xmm0
movups 0x70(%rdx,%rax,4),%xmm1
movups %xmm0,0x60(%rsi,%rax,4)
movups %xmm1,0x70(%rsi,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    1620 <foo+0x520>
test   %r9,%r9
je     16bf <foo+0x5bf>
lea    (%rsi,%rax,4),%r10
add    $0x10,%r10
lea    (%rdx,%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 <foo+0x5a0>
cmp    %r8,%rcx
jne    157d <foo+0x47d>
test   %edi,%edi
jle    1dc1 <foo+0xcc1>
cmp    $0x8,%edi
jb     16eb <foo+0x5eb>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    175c <foo+0x65c>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    175c <foo+0x65c>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     1714 <foo+0x614>
nop
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1700 <foo+0x600>
cmp    $0x3,%r9
jb     1838 <foo+0x738>
xchg   %ax,%ax
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsi,%rcx,4)
movss  0x8(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x8(%rsi,%rcx,4)
movss  0xc(%rdx,%rcx,4),%xmm0
movss  %xmm0,0xc(%rsi,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1720 <foo+0x620>
jmp    1838 <foo+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 <foo+0x682>
xor    %eax,%eax
jmp    17e8 <foo+0x6e8>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups (%rdx,%rax,4),%xmm0
movups 0x10(%rdx,%rax,4),%xmm1
movups %xmm0,(%rsi,%rax,4)
movups %xmm1,0x10(%rsi,%rax,4)
movups 0x20(%rdx,%rax,4),%xmm0
movups 0x30(%rdx,%rax,4),%xmm1
movups %xmm0,0x20(%rsi,%rax,4)
movups %xmm1,0x30(%rsi,%rax,4)
movups 0x40(%rdx,%rax,4),%xmm0
movups 0x50(%rdx,%rax,4),%xmm1
movups %xmm0,0x40(%rsi,%rax,4)
movups %xmm1,0x50(%rsi,%rax,4)
movups 0x60(%rdx,%rax,4),%xmm0
movups 0x70(%rdx,%rax,4),%xmm1
movups %xmm0,0x60(%rsi,%rax,4)
movups %xmm1,0x70(%rsi,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    1790 <foo+0x690>
test   %r9,%r9
je     182f <foo+0x72f>
lea    (%rsi,%rax,4),%r10
add    $0x10,%r10
lea    (%rdx,%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 <foo+0x710>
cmp    %r8,%rcx
jne    16ed <foo+0x5ed>
test   %edi,%edi
jle    1dc1 <foo+0xcc1>
cmp    $0x8,%edi
jb     185b <foo+0x75b>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    18cc <foo+0x7cc>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    18cc <foo+0x7cc>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     1884 <foo+0x784>
nop
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1870 <foo+0x770>
cmp    $0x3,%r9
jb     19a8 <foo+0x8a8>
xchg   %ax,%ax
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsi,%rcx,4)
movss  0x8(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x8(%rsi,%rcx,4)
movss  0xc(%rdx,%rcx,4),%xmm0
movss  %xmm0,0xc(%rsi,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1890 <foo+0x790>
jmp    19a8 <foo+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 <foo+0x7f2>
xor    %eax,%eax
jmp    1958 <foo+0x858>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups (%rdx,%rax,4),%xmm0
movups 0x10(%rdx,%rax,4),%xmm1
movups %xmm0,(%rsi,%rax,4)
movups %xmm1,0x10(%rsi,%rax,4)
movups 0x20(%rdx,%rax,4),%xmm0
movups 0x30(%rdx,%rax,4),%xmm1
movups %xmm0,0x20(%rsi,%rax,4)
movups %xmm1,0x30(%rsi,%rax,4)
movups 0x40(%rdx,%rax,4),%xmm0
movups 0x50(%rdx,%rax,4),%xmm1
movups %xmm0,0x40(%rsi,%rax,4)
movups %xmm1,0x50(%rsi,%rax,4)
movups 0x60(%rdx,%rax,4),%xmm0
movups 0x70(%rdx,%rax,4),%xmm1
movups %xmm0,0x60(%rsi,%rax,4)
movups %xmm1,0x70(%rsi,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    1900 <foo+0x800>
test   %r9,%r9
je     199f <foo+0x89f>
lea    (%rsi,%rax,4),%r10
add    $0x10,%r10
lea    (%rdx,%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 <foo+0x880>
cmp    %r8,%rcx
jne    185d <foo+0x75d>
test   %edi,%edi
jle    1dc1 <foo+0xcc1>
cmp    $0x8,%edi
jb     19cb <foo+0x8cb>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    1a3c <foo+0x93c>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    1a3c <foo+0x93c>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     19f4 <foo+0x8f4>
nop
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    19e0 <foo+0x8e0>
cmp    $0x3,%r9
jb     1b03 <foo+0xa03>
xchg   %ax,%ax
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsi,%rcx,4)
movss  0x8(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x8(%rsi,%rcx,4)
movss  0xc(%rdx,%rcx,4),%xmm0
movss  %xmm0,0xc(%rsi,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1a00 <foo+0x900>
jmp    1b03 <foo+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 <foo+0x962>
xor    %eax,%eax
jmp    1ac0 <foo+0x9c0>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
movups (%rdx,%rax,4),%xmm0
movups 0x10(%rdx,%rax,4),%xmm1
movups %xmm0,(%rsi,%rax,4)
movups %xmm1,0x10(%rsi,%rax,4)
movups 0x20(%rdx,%rax,4),%xmm0
movups 0x30(%rdx,%rax,4),%xmm1
movups %xmm0,0x20(%rsi,%rax,4)
movups %xmm1,0x30(%rsi,%rax,4)
movups 0x40(%rdx,%rax,4),%xmm0
movups 0x50(%rdx,%rax,4),%xmm1
movups %xmm0,0x40(%rsi,%rax,4)
movups %xmm1,0x50(%rsi,%rax,4)
movups 0x60(%rdx,%rax,4),%xmm0
movups 0x70(%rdx,%rax,4),%xmm1
movups %xmm0,0x60(%rsi,%rax,4)
movups %xmm1,0x70(%rsi,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    1a68 <foo+0x968>
test   %r9,%r9
je     1afa <foo+0x9fa>
lea    (%rsi,%rax,4),%r10
add    $0x10,%r10
lea    (%rdx,%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 <foo+0x9db>
cmp    %r8,%rcx
jne    19cd <foo+0x8cd>
test   %edi,%edi
jle    1dc1 <foo+0xcc1>
cmp    $0x8,%edi
jb     1b26 <foo+0xa26>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    1b9c <foo+0xa9c>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    1b9c <foo+0xa9c>
xor    %ecx,%ecx
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     1b54 <foo+0xa54>
nopw   0x0(%rax,%rax,1)
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1b40 <foo+0xa40>
cmp    $0x3,%r9
jb     1c63 <foo+0xb63>
xchg   %ax,%ax
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsi,%rcx,4)
movss  0x8(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x8(%rsi,%rcx,4)
movss  0xc(%rdx,%rcx,4),%xmm0
movss  %xmm0,0xc(%rsi,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1b60 <foo+0xa60>
jmp    1c63 <foo+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 <foo+0xac2>
xor    %eax,%eax
jmp    1c20 <foo+0xb20>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
movups (%rdx,%rax,4),%xmm0
movups 0x10(%rdx,%rax,4),%xmm1
movups %xmm0,(%rsi,%rax,4)
movups %xmm1,0x10(%rsi,%rax,4)
movups 0x20(%rdx,%rax,4),%xmm0
movups 0x30(%rdx,%rax,4),%xmm1
movups %xmm0,0x20(%rsi,%rax,4)
movups %xmm1,0x30(%rsi,%rax,4)
movups 0x40(%rdx,%rax,4),%xmm0
movups 0x50(%rdx,%rax,4),%xmm1
movups %xmm0,0x40(%rsi,%rax,4)
movups %xmm1,0x50(%rsi,%rax,4)
movups 0x60(%rdx,%rax,4),%xmm0
movups 0x70(%rdx,%rax,4),%xmm1
movups %xmm0,0x60(%rsi,%rax,4)
movups %xmm1,0x70(%rsi,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    1bc8 <foo+0xac8>
test   %r9,%r9
je     1c5a <foo+0xb5a>
lea    (%rsi,%rax,4),%r10
add    $0x10,%r10
lea    (%rdx,%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 <foo+0xb3b>
cmp    %r8,%rcx
jne    1b28 <foo+0xa28>
test   %edi,%edi
jle    1dc1 <foo+0xcc1>
cmp    $0x8,%edi
jb     1c86 <foo+0xb86>
lea    (%rdx,%r8,4),%rax
cmp    %rsi,%rax
jbe    1cfc <foo+0xbfc>
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
jbe    1cfc <foo+0xbfc>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
add    %r8,%rax
mov    %r8,%rdi
and    $0x3,%rdi
je     1cb4 <foo+0xbb4>
nopw   0x0(%rax,%rax,1)
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    1ca0 <foo+0xba0>
cmp    $0x3,%rax
jb     1dc1 <foo+0xcc1>
xchg   %ax,%ax
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsi,%rcx,4)
movss  0x8(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x8(%rsi,%rcx,4)
movss  0xc(%rdx,%rcx,4),%xmm0
movss  %xmm0,0xc(%rsi,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1cc0 <foo+0xbc0>
jmp    1dc1 <foo+0xcc1>
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    1d22 <foo+0xc22>
xor    %eax,%eax
jmp    1d80 <foo+0xc80>
and    $0xfffffffffffffffc,%rdi
xor    %eax,%eax
movups (%rdx,%rax,4),%xmm0
movups 0x10(%rdx,%rax,4),%xmm1
movups %xmm0,(%rsi,%rax,4)
movups %xmm1,0x10(%rsi,%rax,4)
movups 0x20(%rdx,%rax,4),%xmm0
movups 0x30(%rdx,%rax,4),%xmm1
movups %xmm0,0x20(%rsi,%rax,4)
movups %xmm1,0x30(%rsi,%rax,4)
movups 0x40(%rdx,%rax,4),%xmm0
movups 0x50(%rdx,%rax,4),%xmm1
movups %xmm0,0x40(%rsi,%rax,4)
movups %xmm1,0x50(%rsi,%rax,4)
movups 0x60(%rdx,%rax,4),%xmm0
movups 0x70(%rdx,%rax,4),%xmm1
movups %xmm0,0x60(%rsi,%rax,4)
movups %xmm1,0x70(%rsi,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rdi
jne    1d28 <foo+0xc28>
test   %r9,%r9
je     1db8 <foo+0xcb8>
lea    (%rsi,%rax,4),%r10
add    $0x10,%r10
lea    (%rdx,%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    1d9b <foo+0xc9b>
cmp    %r8,%rcx
jne    1c88 <foo+0xb88>
ret

LLVM IR (-O0):
define void @foo(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** %6
%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** %5
%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** %6
%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** %5
%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** %6
%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** %5
%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** %6
%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** %5
%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** %6
%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** %5
%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** %6
%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** %5
%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** %6
%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** %5
%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** %6
%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** %5
%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** %6
%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** %5
%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
ret void
}

LLVM IR (-O2):
define void @foo(i32 %0, float* nocapture writeonly %1, float* nocapture %2) {
%4 = icmp sgt i32 %0, 0
br i1 %4, label %5, label %1138
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* %1, i64 %6
%10 = getelementptr float, float* %2, i64 %6
%11 = icmp ugt float* %10, %1
%12 = icmp ugt float* %9, %2
%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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, i64 %100
%103 = load float, float* %102
%104 = getelementptr inbounds float, float* %1, 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 %1138
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* %1, i64 %6
%117 = getelementptr float, float* %2, i64 %6
%118 = icmp ugt float* %117, %1
%119 = icmp ugt float* %116, %2
%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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, i64 %207
%210 = load float, float* %209
%211 = getelementptr inbounds float, float* %1, 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* %2, i64 %219
%221 = load float, float* %220
%222 = getelementptr inbounds float, float* %1, i64 %219
store float %221, float* %222
%223 = add nuw nsw i64 %219, 1
%224 = getelementptr inbounds float, float* %2, i64 %223
%225 = load float, float* %224
%226 = getelementptr inbounds float, float* %1, i64 %223
store float %225, float* %226
%227 = add nuw nsw i64 %219, 2
%228 = getelementptr inbounds float, float* %2, i64 %227
%229 = load float, float* %228
%230 = getelementptr inbounds float, float* %1, i64 %227
store float %229, float* %230
%231 = add nuw nsw i64 %219, 3
%232 = getelementptr inbounds float, float* %2, i64 %231
%233 = load float, float* %232
%234 = getelementptr inbounds float, float* %1, 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 %1138
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* %1, i64 %6
%243 = getelementptr float, float* %2, i64 %6
%244 = icmp ugt float* %243, %1
%245 = icmp ugt float* %242, %2
%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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, i64 %333
%336 = load float, float* %335
%337 = getelementptr inbounds float, float* %1, 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* %2, i64 %345
%347 = load float, float* %346
%348 = getelementptr inbounds float, float* %1, i64 %345
store float %347, float* %348
%349 = add nuw nsw i64 %345, 1
%350 = getelementptr inbounds float, float* %2, i64 %349
%351 = load float, float* %350
%352 = getelementptr inbounds float, float* %1, i64 %349
store float %351, float* %352
%353 = add nuw nsw i64 %345, 2
%354 = getelementptr inbounds float, float* %2, i64 %353
%355 = load float, float* %354
%356 = getelementptr inbounds float, float* %1, i64 %353
store float %355, float* %356
%357 = add nuw nsw i64 %345, 3
%358 = getelementptr inbounds float, float* %2, i64 %357
%359 = load float, float* %358
%360 = getelementptr inbounds float, float* %1, 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 %1138
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* %1, i64 %6
%369 = getelementptr float, float* %2, i64 %6
%370 = icmp ugt float* %369, %1
%371 = icmp ugt float* %368, %2
%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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, i64 %459
%462 = load float, float* %461
%463 = getelementptr inbounds float, float* %1, 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* %2, i64 %471
%473 = load float, float* %472
%474 = getelementptr inbounds float, float* %1, i64 %471
store float %473, float* %474
%475 = add nuw nsw i64 %471, 1
%476 = getelementptr inbounds float, float* %2, i64 %475
%477 = load float, float* %476
%478 = getelementptr inbounds float, float* %1, i64 %475
store float %477, float* %478
%479 = add nuw nsw i64 %471, 2
%480 = getelementptr inbounds float, float* %2, i64 %479
%481 = load float, float* %480
%482 = getelementptr inbounds float, float* %1, i64 %479
store float %481, float* %482
%483 = add nuw nsw i64 %471, 3
%484 = getelementptr inbounds float, float* %2, i64 %483
%485 = load float, float* %484
%486 = getelementptr inbounds float, float* %1, 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 %1138
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* %1, i64 %6
%495 = getelementptr float, float* %2, i64 %6
%496 = icmp ugt float* %495, %1
%497 = icmp ugt float* %494, %2
%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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, i64 %585
%588 = load float, float* %587
%589 = getelementptr inbounds float, float* %1, 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* %2, i64 %597
%599 = load float, float* %598
%600 = getelementptr inbounds float, float* %1, i64 %597
store float %599, float* %600
%601 = add nuw nsw i64 %597, 1
%602 = getelementptr inbounds float, float* %2, i64 %601
%603 = load float, float* %602
%604 = getelementptr inbounds float, float* %1, i64 %601
store float %603, float* %604
%605 = add nuw nsw i64 %597, 2
%606 = getelementptr inbounds float, float* %2, i64 %605
%607 = load float, float* %606
%608 = getelementptr inbounds float, float* %1, i64 %605
store float %607, float* %608
%609 = add nuw nsw i64 %597, 3
%610 = getelementptr inbounds float, float* %2, i64 %609
%611 = load float, float* %610
%612 = getelementptr inbounds float, float* %1, 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 %1138
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* %1, i64 %6
%621 = getelementptr float, float* %2, i64 %6
%622 = icmp ugt float* %621, %1
%623 = icmp ugt float* %620, %2
%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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, i64 %711
%714 = load float, float* %713
%715 = getelementptr inbounds float, float* %1, 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* %2, i64 %723
%725 = load float, float* %724
%726 = getelementptr inbounds float, float* %1, i64 %723
store float %725, float* %726
%727 = add nuw nsw i64 %723, 1
%728 = getelementptr inbounds float, float* %2, i64 %727
%729 = load float, float* %728
%730 = getelementptr inbounds float, float* %1, i64 %727
store float %729, float* %730
%731 = add nuw nsw i64 %723, 2
%732 = getelementptr inbounds float, float* %2, i64 %731
%733 = load float, float* %732
%734 = getelementptr inbounds float, float* %1, i64 %731
store float %733, float* %734
%735 = add nuw nsw i64 %723, 3
%736 = getelementptr inbounds float, float* %2, i64 %735
%737 = load float, float* %736
%738 = getelementptr inbounds float, float* %1, 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 %1138
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* %1, i64 %6
%747 = getelementptr float, float* %2, i64 %6
%748 = icmp ugt float* %747, %1
%749 = icmp ugt float* %746, %2
%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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, i64 %837
%840 = load float, float* %839
%841 = getelementptr inbounds float, float* %1, 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* %2, i64 %849
%851 = load float, float* %850
%852 = getelementptr inbounds float, float* %1, i64 %849
store float %851, float* %852
%853 = add nuw nsw i64 %849, 1
%854 = getelementptr inbounds float, float* %2, i64 %853
%855 = load float, float* %854
%856 = getelementptr inbounds float, float* %1, i64 %853
store float %855, float* %856
%857 = add nuw nsw i64 %849, 2
%858 = getelementptr inbounds float, float* %2, i64 %857
%859 = load float, float* %858
%860 = getelementptr inbounds float, float* %1, i64 %857
store float %859, float* %860
%861 = add nuw nsw i64 %849, 3
%862 = getelementptr inbounds float, float* %2, i64 %861
%863 = load float, float* %862
%864 = getelementptr inbounds float, float* %1, 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 %1138
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* %1, i64 %6
%873 = getelementptr float, float* %2, i64 %6
%874 = icmp ugt float* %873, %1
%875 = icmp ugt float* %872, %2
%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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, i64 %963
%966 = load float, float* %965
%967 = getelementptr inbounds float, float* %1, 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* %2, i64 %975
%977 = load float, float* %976
%978 = getelementptr inbounds float, float* %1, i64 %975
store float %977, float* %978
%979 = add nuw nsw i64 %975, 1
%980 = getelementptr inbounds float, float* %2, i64 %979
%981 = load float, float* %980
%982 = getelementptr inbounds float, float* %1, i64 %979
store float %981, float* %982
%983 = add nuw nsw i64 %975, 2
%984 = getelementptr inbounds float, float* %2, i64 %983
%985 = load float, float* %984
%986 = getelementptr inbounds float, float* %1, i64 %983
store float %985, float* %986
%987 = add nuw nsw i64 %975, 3
%988 = getelementptr inbounds float, float* %2, i64 %987
%989 = load float, float* %988
%990 = getelementptr inbounds float, float* %1, 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 %1138
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* %1, i64 %6
%999 = getelementptr float, float* %2, i64 %6
%1000 = icmp ugt float* %999, %1
%1001 = icmp ugt float* %998, %2
%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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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* %2, 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* %1, 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 %1138, 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* %2, i64 %1089
%1092 = load float, float* %1091
%1093 = getelementptr inbounds float, float* %1, 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 %1138, label %1119
1100: ; preds = %971, %1100
%1101 = phi i64 [ %1117, %1100 ], [ %972, %971 ]
%1102 = getelementptr inbounds float, float* %2, i64 %1101
%1103 = load float, float* %1102
%1104 = getelementptr inbounds float, float* %1, i64 %1101
store float %1103, float* %1104
%1105 = add nuw nsw i64 %1101, 1
%1106 = getelementptr inbounds float, float* %2, i64 %1105
%1107 = load float, float* %1106
%1108 = getelementptr inbounds float, float* %1, i64 %1105
store float %1107, float* %1108
%1109 = add nuw nsw i64 %1101, 2
%1110 = getelementptr inbounds float, float* %2, i64 %1109
%1111 = load float, float* %1110
%1112 = getelementptr inbounds float, float* %1, i64 %1109
store float %1111, float* %1112
%1113 = add nuw nsw i64 %1101, 3
%1114 = getelementptr inbounds float, float* %2, i64 %1113
%1115 = load float, float* %1114
%1116 = getelementptr inbounds float, float* %1, 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, %1119
%1120 = phi i64 [ %1136, %1119 ], [ %1098, %1097 ]
%1121 = getelementptr inbounds float, float* %2, i64 %1120
%1122 = load float, float* %1121
%1123 = getelementptr inbounds float, float* %1, i64 %1120
store float %1122, float* %1123
%1124 = add nuw nsw i64 %1120, 1
%1125 = getelementptr inbounds float, float* %2, i64 %1124
%1126 = load float, float* %1125
%1127 = getelementptr inbounds float, float* %1, i64 %1124
store float %1126, float* %1127
%1128 = add nuw nsw i64 %1120, 2
%1129 = getelementptr inbounds float, float* %2, i64 %1128
%1130 = load float, float* %1129
%1131 = getelementptr inbounds float, float* %1, i64 %1128
store float %1130, float* %1131
%1132 = add nuw nsw i64 %1120, 3
%1133 = getelementptr inbounds float, float* %2, i64 %1132
%1134 = load float, float* %1133
%1135 = getelementptr inbounds float, float* %1, i64 %1132
store float %1134, float* %1135
%1136 = add nuw nsw i64 %1120, 4
%1137 = icmp eq i64 %1136, %995
br i1 %1137, label %1138, label %1119
1138: ; preds = %1097, %1119, %1080, %3, %111, %237, %363, %489, %615, %741, %867, %993
ret void
}