#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ assert(float *);
int /*<<< orphan*/ free(float *);
scalar_t__ malloc(size_t);
void flt_move(float *array, size_t off, size_t n, size_t pos) {
  size_t i, end;
  float *src, *dst;
  float fxd[1024], *buf;
  assert(array);
  if ((pos >= off) && (pos < off + n))
    return;
  if (pos < off) {
    end = off + n;
    off = pos;
    pos = end - n;
  } else {
    end = pos + 1;
    pos = off + n;
  }
  buf = fxd;
  if (pos + pos > end + off) {
    while (pos > off) {
      n = pos - off;
      if (n > 1024) {
        buf = (float *)malloc(n * sizeof(float));
        if (!buf) {
          buf = fxd;
          n = 1024;
        }
      }
      src = array + pos - n;
      dst = buf;
      for (i = n; i > 0; i--)
        *dst++ = *src++;
      dst = array + pos - n;
      for (i = end - pos; i > 0; i--)
        *dst++ = *src++;
      src = buf;
      for (i = n; i > 0; i--)
        *dst++ = *src++;
      pos -= n;
      end -= n;
    }
  } else {
    while (end > pos) {
      n = end - pos;
      if (n > 1024) {
        buf = (float *)malloc(n * sizeof(float));
        if (!buf) {
          buf = fxd;
          n = 1024;
        }
      }
      src = array + pos + n;
      dst = buf + n;
      for (i = n; i > 0; i--)
        *--dst = *--src;
      dst = array + pos + n;
      for (i = pos - off; i > 0; i--)
        *--dst = *--src;
      src = buf + n;
      for (i = n; i > 0; i--)
        *--dst = *--src;
      pos += n;
      off += n;
    }
  }
  if (buf != fxd)
    free(buf);
}


x86 assembly (clang, -O0):
<flt_move>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1050,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x8(%rbp),%rdi
call   1040 <assert@plt>
mov    -0x20(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     117c <flt_move+0x4c>
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x18(%rbp),%rcx
cmp    %rcx,%rax
jae    117c <flt_move+0x4c>
jmp    15b7 <flt_move+0x487>
mov    -0x20(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    11af <flt_move+0x7f>
mov    -0x10(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x30(%rbp),%rax
sub    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    11c7 <flt_move+0x97>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
lea    -0x1040(%rbp),%rax
mov    %rax,-0x1048(%rbp)
mov    -0x20(%rbp),%rax
add    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    -0x10(%rbp),%rcx
cmp    %rcx,%rax
jbe    13b8 <flt_move+0x288>
jmp    11f3 <flt_move+0xc3>
mov    -0x20(%rbp),%rax
cmp    -0x10(%rbp),%rax
jbe    13b3 <flt_move+0x283>
mov    -0x20(%rbp),%rax
sub    -0x10(%rbp),%rax
mov    %rax,-0x18(%rbp)
cmpq   $0x400,-0x18(%rbp)
jbe    1258 <flt_move+0x128>
mov    -0x18(%rbp),%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x1048(%rbp)
cmpq   $0x0,-0x1048(%rbp)
jne    1253 <flt_move+0x123>
lea    -0x1040(%rbp),%rax
mov    %rax,-0x1048(%rbp)
movq   $0x400,-0x18(%rbp)
jmp    1258 <flt_move+0x128>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
xor    %ecx,%ecx
sub    -0x18(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x1048(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jbe    12cd <flt_move+0x19d>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
movss  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x40(%rbp)
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    128b <flt_move+0x15b>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
xor    %ecx,%ecx
sub    -0x18(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jbe    133b <flt_move+0x20b>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
movss  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x40(%rbp)
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    12f9 <flt_move+0x1c9>
mov    -0x1048(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jbe    1390 <flt_move+0x260>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
movss  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x40(%rbp)
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    134e <flt_move+0x21e>
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x30(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x30(%rbp)
jmp    11f3 <flt_move+0xc3>
jmp    1594 <flt_move+0x464>
jmp    13bd <flt_move+0x28d>
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jbe    158f <flt_move+0x45f>
mov    -0x30(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %rax,-0x18(%rbp)
cmpq   $0x400,-0x18(%rbp)
jbe    1422 <flt_move+0x2f2>
mov    -0x18(%rbp),%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x1048(%rbp)
cmpq   $0x0,-0x1048(%rbp)
jne    141d <flt_move+0x2ed>
lea    -0x1040(%rbp),%rax
mov    %rax,-0x1048(%rbp)
movq   $0x400,-0x18(%rbp)
jmp    1422 <flt_move+0x2f2>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x1048(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jbe    14a2 <flt_move+0x372>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
movss  -0x4(%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x40(%rbp)
movss  %xmm0,-0x4(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    145e <flt_move+0x32e>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
sub    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jbe    1510 <flt_move+0x3e0>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
movss  -0x4(%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x40(%rbp)
movss  %xmm0,-0x4(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    14cc <flt_move+0x39c>
mov    -0x1048(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jbe    1572 <flt_move+0x442>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
movss  -0x4(%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x40(%rbp)
movss  %xmm0,-0x4(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    152e <flt_move+0x3fe>
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
jmp    13bd <flt_move+0x28d>
jmp    1594 <flt_move+0x464>
mov    -0x1048(%rbp),%rax
lea    -0x1040(%rbp),%rcx
cmp    %rcx,%rax
je     15b7 <flt_move+0x487>
mov    -0x1048(%rbp),%rdi
call   1030 <free@plt>
add    $0x1050,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<flt_move>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1018,%rsp
mov    %rcx,%r14
mov    %rdx,%rbx
mov    %rsi,%r15
mov    %rdi,(%rsp)
call   1040 <assert@plt>
add    %r15,%rbx
cmp    %r15,%r14
jb     1164 <flt_move+0x34>
cmp    %r14,%rbx
ja     1d74 <flt_move+0xc44>
lea    0x1(%r14),%r10
cmp    %r15,%r14
cmovae %r15,%r14
cmovae %rbx,%r15
cmovb  %rbx,%r10
lea    (%r15,%r15,1),%rax
lea    (%r10,%r14,1),%rcx
cmp    %rcx,%rax
jbe    1787 <flt_move+0x657>
cmp    %r14,%r15
jbe    1d74 <flt_move+0xc44>
lea    0x10(%rsp),%r13
mov    %r13,%r11
jmp    11af <flt_move+0x7f>
nopl   0x0(%rax,%rax,1)
sub    %r12,%r15
sub    %r12,%r10
cmp    %r14,%r15
jbe    1d62 <flt_move+0xc32>
mov    %r15,%r12
sub    %r14,%r12
cmp    $0x401,%r12
jb     1200 <flt_move+0xd0>
lea    0x0(,%r12,4),%rdi
mov    %r10,%rbx
call   1050 <malloc@plt>
mov    %rbx,%r10
mov    %rax,%r11
test   %rax,%rax
mov    $0x400,%eax
cmove  %rax,%r12
cmove  %r13,%r11
mov    (%rsp),%rax
lea    (%rax,%r15,4),%rax
lea    0x0(,%r12,4),%rcx
sub    %rcx,%rax
jmp    1218 <flt_move+0xe8>
nopl   0x0(%rax)
mov    (%rsp),%rax
lea    (%rax,%r15,4),%rax
lea    0x0(,%r12,4),%rcx
sub    %rcx,%rax
test   %r12,%r12
je     1272 <flt_move+0x142>
mov    %r11,%rdx
mov    %rax,%rcx
mov    %r12,%rbx
cmp    $0x8,%r12
jb     1350 <flt_move+0x220>
lea    (%rax,%r12,4),%rcx
cmp    %rcx,%r11
jae    124a <flt_move+0x11a>
lea    (%r11,%r12,4),%rsi
mov    %r11,%rdx
mov    %rax,%rcx
mov    %r12,%rbx
cmp    %rsi,%rax
jb     1350 <flt_move+0x220>
mov    %r12,%rdx
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ecx
and    $0x3,%ecx
cmp    $0x18,%rdi
jae    1280 <flt_move+0x150>
xor    %ebp,%ebp
jmp    12f0 <flt_move+0x1c0>
mov    $0x1,%r8b
xor    %r12d,%r12d
mov    %rax,%rcx
jmp    13f6 <flt_move+0x2c6>
movabs $0x3ffffffffffffffc,%rdi
ff ff 3f
and    %rdi,%rsi
xor    %ebp,%ebp
nop
movups (%rax,%rbp,4),%xmm0
movups 0x10(%rax,%rbp,4),%xmm1
movups %xmm0,(%r11,%rbp,4)
movups %xmm1,0x10(%r11,%rbp,4)
movups 0x20(%rax,%rbp,4),%xmm0
movups 0x30(%rax,%rbp,4),%xmm1
movups %xmm0,0x20(%r11,%rbp,4)
movups %xmm1,0x30(%r11,%rbp,4)
movups 0x40(%rax,%rbp,4),%xmm0
movups 0x50(%rax,%rbp,4),%xmm1
movups %xmm0,0x40(%r11,%rbp,4)
movups %xmm1,0x50(%r11,%rbp,4)
movups 0x60(%rax,%rbp,4),%xmm0
movups 0x70(%rax,%rbp,4),%xmm1
movups %xmm0,0x60(%r11,%rbp,4)
movups %xmm1,0x70(%r11,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rsi
jne    1290 <flt_move+0x160>
test   %rcx,%rcx
je     132b <flt_move+0x1fb>
lea    (%rax,%rbp,4),%rsi
add    $0x10,%rsi
lea    (%r11,%rbp,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rcx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movups -0x10(%rsi,%rbp,1),%xmm0
movups (%rsi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbp,1)
movups %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rcx
jne    1310 <flt_move+0x1e0>
lea    (%rax,%rdx,4),%rcx
cmp    %rdx,%r12
je     13f3 <flt_move+0x2c3>
mov    %r12d,%ebx
and    $0x7,%ebx
lea    (%r11,%rdx,4),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    -0x1(%rbx),%rbp
mov    %rbx,%rsi
and    $0x7,%rsi
je     137c <flt_move+0x24c>
xor    %edi,%edi
nop
movss  (%rcx),%xmm0
add    $0x4,%rcx
movss  %xmm0,(%rdx)
add    $0x4,%rdx
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    1360 <flt_move+0x230>
sub    %rdi,%rbx
cmp    $0x7,%rbp
jb     13f3 <flt_move+0x2c3>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rcx),%xmm0
movss  %xmm0,(%rdx,%rbp,4)
movss  0x4(%rcx),%xmm0
movss  %xmm0,0x4(%rdx,%rbp,4)
movss  0x8(%rcx),%xmm0
movss  %xmm0,0x8(%rdx,%rbp,4)
movss  0xc(%rcx),%xmm0
movss  %xmm0,0xc(%rdx,%rbp,4)
movss  0x10(%rcx),%xmm0
movss  %xmm0,0x10(%rdx,%rbp,4)
movss  0x14(%rcx),%xmm0
movss  %xmm0,0x14(%rdx,%rbp,4)
movss  0x18(%rcx),%xmm0
movss  %xmm0,0x18(%rdx,%rbp,4)
movss  0x1c(%rcx),%xmm0
add    $0x20,%rcx
movss  %xmm0,0x1c(%rdx,%rbp,4)
add    $0x8,%rbp
cmp    %rbp,%rbx
jne    1390 <flt_move+0x260>
xor    %r8d,%r8d
mov    %r10,%rsi
sub    %r15,%rsi
je     15b3 <flt_move+0x483>
cmp    $0x8,%rsi
jb     1510 <flt_move+0x3e0>
lea    (%rcx,%rsi,4),%rdx
cmp    %rdx,%rax
jae    1422 <flt_move+0x2f2>
lea    (%rax,%rsi,4),%rdx
cmp    %rdx,%rcx
jb     1510 <flt_move+0x3e0>
mov    %rsi,%r9
and    $0xfffffffffffffff8,%r9
lea    -0x8(%r9),%rdi
mov    %rdi,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
mov    %ebx,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    1447 <flt_move+0x317>
xor    %ebp,%ebp
jmp    14b8 <flt_move+0x388>
movabs $0x3ffffffffffffffc,%rdi
ff ff 3f
and    %rdi,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movups (%rcx,%rbp,4),%xmm0
movups 0x10(%rcx,%rbp,4),%xmm1
movups %xmm0,(%rax,%rbp,4)
movups %xmm1,0x10(%rax,%rbp,4)
movups 0x20(%rcx,%rbp,4),%xmm0
movups 0x30(%rcx,%rbp,4),%xmm1
movups %xmm0,0x20(%rax,%rbp,4)
movups %xmm1,0x30(%rax,%rbp,4)
movups 0x40(%rcx,%rbp,4),%xmm0
movups 0x50(%rcx,%rbp,4),%xmm1
movups %xmm0,0x40(%rax,%rbp,4)
movups %xmm1,0x50(%rax,%rbp,4)
movups 0x60(%rcx,%rbp,4),%xmm0
movups 0x70(%rcx,%rbp,4),%xmm1
movups %xmm0,0x60(%rax,%rbp,4)
movups %xmm1,0x70(%rax,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rbx
jne    1460 <flt_move+0x330>
test   %rdx,%rdx
je     14fc <flt_move+0x3cc>
lea    (%rcx,%rbp,4),%rdi
add    $0x10,%rdi
lea    (%rax,%rbp,4),%rbp
add    $0x10,%rbp
shl    $0x5,%rdx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rdi,%rbx,1),%xmm0
movups (%rdi,%rbx,1),%xmm1
movups %xmm0,-0x10(%rbp,%rbx,1)
movups %xmm1,0x0(%rbp,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rdx
jne    14e0 <flt_move+0x3b0>
lea    (%rax,%r9,4),%rax
cmp    %r9,%rsi
je     15b3 <flt_move+0x483>
and    $0x7,%esi
lea    (%rcx,%r9,4),%rcx
lea    -0x1(%rsi),%rbp
mov    %rsi,%rdx
and    $0x7,%rdx
je     153c <flt_move+0x40c>
xor    %edi,%edi
nop
movss  (%rcx),%xmm0
add    $0x4,%rcx
movss  %xmm0,(%rax)
add    $0x4,%rax
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    1520 <flt_move+0x3f0>
sub    %rdi,%rsi
cmp    $0x7,%rbp
jb     15b3 <flt_move+0x483>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,(%rax)
movss  0x4(%rcx,%rdx,4),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x8(%rcx,%rdx,4),%xmm0
movss  %xmm0,0x8(%rax)
movss  0xc(%rcx,%rdx,4),%xmm0
movss  %xmm0,0xc(%rax)
movss  0x10(%rcx,%rdx,4),%xmm0
movss  %xmm0,0x10(%rax)
movss  0x14(%rcx,%rdx,4),%xmm0
movss  %xmm0,0x14(%rax)
movss  0x18(%rcx,%rdx,4),%xmm0
movss  %xmm0,0x18(%rax)
movss  0x1c(%rcx,%rdx,4),%xmm0
movss  %xmm0,0x1c(%rax)
add    $0x20,%rax
add    $0x8,%rdx
cmp    %rdx,%rsi
jne    1550 <flt_move+0x420>
test   %r8b,%r8b
jne    11a0 <flt_move+0x70>
cmp    $0x8,%r12
jb     15dc <flt_move+0x4ac>
lea    (%r11,%r12,4),%rcx
cmp    %rcx,%rax
jae    169c <flt_move+0x56c>
lea    (%rax,%r12,4),%rcx
cmp    %rcx,%r11
jae    169c <flt_move+0x56c>
mov    %r11,%rdx
mov    %r12,%rbp
lea    -0x1(%rbp),%rsi
mov    %rbp,%rcx
and    $0x7,%rcx
je     161c <flt_move+0x4ec>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rdx),%xmm0
add    $0x4,%rdx
movss  %xmm0,(%rax)
add    $0x4,%rax
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    1600 <flt_move+0x4d0>
sub    %rdi,%rbp
cmp    $0x7,%rsi
jb     11a0 <flt_move+0x70>
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x4(%rax,%rcx,4)
movss  0x8(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x8(%rax,%rcx,4)
movss  0xc(%rdx,%rcx,4),%xmm0
movss  %xmm0,0xc(%rax,%rcx,4)
movss  0x10(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x10(%rax,%rcx,4)
movss  0x14(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x14(%rax,%rcx,4)
movss  0x18(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x18(%rax,%rcx,4)
movss  0x1c(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x1c(%rax,%rcx,4)
add    $0x8,%rcx
cmp    %rcx,%rbp
jne    1630 <flt_move+0x500>
jmp    11a0 <flt_move+0x70>
mov    %r12,%rdx
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ecx
and    $0x3,%ecx
cmp    $0x18,%rdi
jae    16c1 <flt_move+0x591>
xor    %ebp,%ebp
jmp    1730 <flt_move+0x600>
movabs $0x3ffffffffffffffc,%rdi
ff ff 3f
and    %rdi,%rsi
xor    %ebp,%ebp
movups (%r11,%rbp,4),%xmm0
movups 0x10(%r11,%rbp,4),%xmm1
movups %xmm0,(%rax,%rbp,4)
movups %xmm1,0x10(%rax,%rbp,4)
movups 0x20(%r11,%rbp,4),%xmm0
movups 0x30(%r11,%rbp,4),%xmm1
movups %xmm0,0x20(%rax,%rbp,4)
movups %xmm1,0x30(%rax,%rbp,4)
movups 0x40(%r11,%rbp,4),%xmm0
movups 0x50(%r11,%rbp,4),%xmm1
movups %xmm0,0x40(%rax,%rbp,4)
movups %xmm1,0x50(%rax,%rbp,4)
movups 0x60(%r11,%rbp,4),%xmm0
movups 0x70(%r11,%rbp,4),%xmm1
movups %xmm0,0x60(%rax,%rbp,4)
movups %xmm1,0x70(%rax,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rsi
jne    16d0 <flt_move+0x5a0>
test   %rcx,%rcx
je     176b <flt_move+0x63b>
lea    (%r11,%rbp,4),%rsi
add    $0x10,%rsi
lea    (%rax,%rbp,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rcx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movups -0x10(%rsi,%rbp,1),%xmm0
movups (%rsi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbp,1)
movups %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rcx
jne    1750 <flt_move+0x620>
cmp    %rdx,%r12
je     11a0 <flt_move+0x70>
mov    %r12d,%ebp
and    $0x7,%ebp
lea    (%rax,%rdx,4),%rax
lea    (%r11,%rdx,4),%rdx
jmp    15e2 <flt_move+0x4b2>
cmp    %r15,%r10
jbe    1d74 <flt_move+0xc44>
lea    0x10(%rsp),%r11
mov    (%rsp),%rax
lea    (%rax,%r10,4),%rax
mov    %rax,0x8(%rsp)
mov    %r10,%r12
jmp    17bf <flt_move+0x68f>
nopw   0x0(%rax,%rax,1)
add    %r13,%r15
add    %r13,%r14
cmp    %r15,%r10
jbe    1d62 <flt_move+0xc32>
mov    %r10,%r13
sub    %r15,%r13
cmp    $0x401,%r13
jb     1810 <flt_move+0x6e0>
lea    0x0(,%r13,4),%rdi
call   1050 <malloc@plt>
mov    %r12,%r10
mov    %rax,%r11
test   %rax,%rax
mov    $0x400,%eax
cmove  %rax,%r13
lea    0x10(%rsp),%rax
cmove  %rax,%r11
mov    (%rsp),%rax
lea    (%rax,%r15,4),%rax
lea    (%rax,%r13,4),%rbx
lea    (%r11,%r13,4),%rcx
jmp    1822 <flt_move+0x6f2>
nopl   0x0(%rax,%rax,1)
lea    (%r11,%r13,4),%rcx
test   %r13,%r13
je     18c7 <flt_move+0x797>
mov    0x8(%rsp),%rbx
mov    %rcx,%rax
mov    %rbx,%rsi
mov    %r13,%rdi
cmp    $0x8,%r13
jb     1930 <flt_move+0x800>
lea    0x0(,%r13,4),%rax
mov    %rcx,%rdx
sub    %rax,%rdx
cmp    %rbx,%rdx
jae    1860 <flt_move+0x730>
mov    %rbx,%rdx
sub    %rax,%rdx
mov    %rcx,%rax
mov    %rbx,%rsi
mov    %r13,%rdi
cmp    %rcx,%rdx
jb     1930 <flt_move+0x800>
mov    %r13,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     18da <flt_move+0x7aa>
movabs $0x3ffffffffffffffc,%rsi
ff ff 3f
lea    0x2(%rsi),%rdi
and    %rdx,%rdi
xor    %esi,%esi
xchg   %ax,%ax
movups -0x20(%rbx,%rsi,4),%xmm0
movups -0x10(%rbx,%rsi,4),%xmm1
movups %xmm1,-0x10(%rcx,%rsi,4)
movups %xmm0,-0x20(%rcx,%rsi,4)
movups -0x40(%rbx,%rsi,4),%xmm0
movups -0x30(%rbx,%rsi,4),%xmm1
movups %xmm1,-0x30(%rcx,%rsi,4)
movups %xmm0,-0x40(%rcx,%rsi,4)
add    $0xfffffffffffffff0,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1890 <flt_move+0x760>
neg    %rsi
jmp    18dc <flt_move+0x7ac>
mov    $0x1,%r8b
mov    0x8(%rsp),%rsi
mov    %rsi,%rbx
xor    %r13d,%r13d
jmp    19d8 <flt_move+0x8a8>
xor    %esi,%esi
lea    0x0(,%rax,4),%rbp
test   $0x1,%dl
je     1909 <flt_move+0x7d9>
shl    $0x2,%rsi
mov    %rcx,%rdx
sub    %rsi,%rdx
mov    %rbx,%rdi
sub    %rsi,%rdi
movups -0x20(%rdi),%xmm0
movups -0x10(%rdi),%xmm1
movups %xmm1,-0x10(%rdx)
movups %xmm0,-0x20(%rdx)
mov    %rbx,%rsi
sub    %rbp,%rsi
cmp    %rax,%r13
je     19d5 <flt_move+0x8a5>
mov    %r13d,%edi
and    $0x7,%edi
mov    %rcx,%rax
sub    %rbp,%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    -0x1(%rdi),%r8
mov    %rdi,%rdx
and    $0x7,%rdx
je     195e <flt_move+0x82e>
xor    %ebp,%ebp
nop
movss  -0x4(%rsi),%xmm0
add    $0xfffffffffffffffc,%rsi
movss  %xmm0,-0x4(%rax)
add    $0xfffffffffffffffc,%rax
add    $0x1,%rbp
cmp    %rbp,%rdx
jne    1940 <flt_move+0x810>
sub    %rbp,%rdi
cmp    $0x7,%r8
jb     19d5 <flt_move+0x8a5>
neg    %rdi
xor    %ebp,%ebp
nopl   0x0(%rax)
movss  -0x4(%rsi),%xmm0
movss  %xmm0,-0x4(%rax,%rbp,4)
movss  -0x8(%rsi),%xmm0
movss  %xmm0,-0x8(%rax,%rbp,4)
movss  -0xc(%rsi),%xmm0
movss  %xmm0,-0xc(%rax,%rbp,4)
movss  -0x10(%rsi),%xmm0
movss  %xmm0,-0x10(%rax,%rbp,4)
movss  -0x14(%rsi),%xmm0
movss  %xmm0,-0x14(%rax,%rbp,4)
movss  -0x18(%rsi),%xmm0
movss  %xmm0,-0x18(%rax,%rbp,4)
movss  -0x1c(%rsi),%xmm0
movss  %xmm0,-0x1c(%rax,%rbp,4)
movss  -0x20(%rsi),%xmm0
add    $0xffffffffffffffe0,%rsi
movss  %xmm0,-0x20(%rax,%rbp,4)
add    $0xfffffffffffffff8,%rbp
cmp    %rbp,%rdi
jne    1970 <flt_move+0x840>
xor    %r8d,%r8d
mov    %r15,%rbp
sub    %r14,%rbp
je     1a95 <flt_move+0x965>
cmp    $0x8,%rbp
jae    1b80 <flt_move+0xa50>
lea    -0x1(%rbp),%rax
mov    %rbp,%rdx
and    $0x7,%rdx
je     1a1e <flt_move+0x8ee>
xor    %edi,%edi
nopl   (%rax)
movss  -0x4(%rsi),%xmm0
add    $0xfffffffffffffffc,%rsi
movss  %xmm0,-0x4(%rbx)
add    $0xfffffffffffffffc,%rbx
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    1a00 <flt_move+0x8d0>
sub    %rdi,%rbp
mov    %r12,%r10
cmp    $0x7,%rax
jb     1a95 <flt_move+0x965>
neg    %rbp
xor    %eax,%eax
nopl   0x0(%rax)
movss  -0x4(%rsi,%rax,4),%xmm0
movss  %xmm0,-0x4(%rbx)
movss  -0x8(%rsi,%rax,4),%xmm0
movss  %xmm0,-0x8(%rbx)
movss  -0xc(%rsi,%rax,4),%xmm0
movss  %xmm0,-0xc(%rbx)
movss  -0x10(%rsi,%rax,4),%xmm0
movss  %xmm0,-0x10(%rbx)
movss  -0x14(%rsi,%rax,4),%xmm0
movss  %xmm0,-0x14(%rbx)
movss  -0x18(%rsi,%rax,4),%xmm0
movss  %xmm0,-0x18(%rbx)
movss  -0x1c(%rsi,%rax,4),%xmm0
movss  %xmm0,-0x1c(%rbx)
movss  -0x20(%rsi,%rax,4),%xmm0
movss  %xmm0,-0x20(%rbx)
add    $0xffffffffffffffe0,%rbx
add    $0xfffffffffffffff8,%rax
cmp    %rax,%rbp
jne    1a30 <flt_move+0x900>
test   %r8b,%r8b
jne    17b0 <flt_move+0x680>
cmp    $0x8,%r13
jb     1aca <flt_move+0x99a>
lea    0x0(,%r13,4),%rax
mov    %rbx,%rdx
sub    %rax,%rdx
cmp    %rcx,%rdx
jae    1c5a <flt_move+0xb2a>
mov    %rcx,%rdx
sub    %rax,%rdx
cmp    %rbx,%rdx
jae    1c5a <flt_move+0xb2a>
mov    %r13,%rax
lea    -0x1(%rax),%rdx
mov    %rax,%rsi
and    $0x7,%rsi
je     1afe <flt_move+0x9ce>
xor    %edi,%edi
nopl   0x0(%rax)
movss  -0x4(%rcx),%xmm0
add    $0xfffffffffffffffc,%rcx
movss  %xmm0,-0x4(%rbx)
add    $0xfffffffffffffffc,%rbx
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    1ae0 <flt_move+0x9b0>
sub    %rdi,%rax
cmp    $0x7,%rdx
jb     17b0 <flt_move+0x680>
neg    %rax
xor    %edx,%edx
nopl   (%rax)
movss  -0x4(%rcx,%rdx,4),%xmm0
movss  %xmm0,-0x4(%rbx,%rdx,4)
movss  -0x8(%rcx,%rdx,4),%xmm0
movss  %xmm0,-0x8(%rbx,%rdx,4)
movss  -0xc(%rcx,%rdx,4),%xmm0
movss  %xmm0,-0xc(%rbx,%rdx,4)
movss  -0x10(%rcx,%rdx,4),%xmm0
movss  %xmm0,-0x10(%rbx,%rdx,4)
movss  -0x14(%rcx,%rdx,4),%xmm0
movss  %xmm0,-0x14(%rbx,%rdx,4)
movss  -0x18(%rcx,%rdx,4),%xmm0
movss  %xmm0,-0x18(%rbx,%rdx,4)
movss  -0x1c(%rcx,%rdx,4),%xmm0
movss  %xmm0,-0x1c(%rbx,%rdx,4)
movss  -0x20(%rcx,%rdx,4),%xmm0
movss  %xmm0,-0x20(%rbx,%rdx,4)
add    $0xfffffffffffffff8,%rdx
cmp    %rdx,%rax
jne    1b10 <flt_move+0x9e0>
jmp    17b0 <flt_move+0x680>
xchg   %ax,%ax
mov    %r14,%rax
not    %rax
add    %r15,%rax
mov    $0x4,%edx
mul    %rdx
lea    -0x4(%rbx),%rdx
seto   %r9b
mov    %rdx,%rdi
sub    %rax,%rdi
cmp    %rdx,%rdi
ja     19ee <flt_move+0x8be>
test   %r9b,%r9b
jne    19ee <flt_move+0x8be>
lea    -0x4(%rsi),%rdx
mov    %rdx,%rdi
sub    %rax,%rdi
cmp    %rdx,%rdi
ja     19ee <flt_move+0x8be>
test   %r9b,%r9b
jne    19ee <flt_move+0x8be>
mov    %r14,%rax
sub    %r15,%rax
lea    (%rbx,%rax,4),%rdx
cmp    %rsi,%rdx
jae    1be9 <flt_move+0xab9>
lea    (%rsi,%rax,4),%rax
cmp    %rbx,%rax
jb     19ee <flt_move+0x8be>
mov    %rbp,%r9
and    $0xfffffffffffffff8,%r9
lea    -0x8(%r9),%rax
mov    %rax,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rax,%rax
je     1d0f <flt_move+0xbdf>
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
lea    0x2(%rax),%rdi
and    %rdx,%rdi
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups -0x20(%rsi,%rax,4),%xmm0
movups -0x10(%rsi,%rax,4),%xmm1
movups %xmm1,-0x10(%rbx,%rax,4)
movups %xmm0,-0x20(%rbx,%rax,4)
movups -0x40(%rsi,%rax,4),%xmm0
movups -0x30(%rsi,%rax,4),%xmm1
movups %xmm1,-0x30(%rbx,%rax,4)
movups %xmm0,-0x40(%rbx,%rax,4)
add    $0xfffffffffffffff0,%rax
add    $0xfffffffffffffffe,%rdi
jne    1c20 <flt_move+0xaf0>
neg    %rax
jmp    1d11 <flt_move+0xbe1>
mov    %r13,%rdx
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%rsi
mov    %rsi,%rax
shr    $0x3,%rax
add    $0x1,%rax
test   %rsi,%rsi
je     1d07 <flt_move+0xbd7>
movabs $0x3ffffffffffffffc,%rsi
ff ff 3f
lea    0x2(%rsi),%rdi
and    %rax,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
movups -0x20(%rcx,%rsi,4),%xmm0
movups -0x10(%rcx,%rsi,4),%xmm1
movups %xmm1,-0x10(%rbx,%rsi,4)
movups %xmm0,-0x20(%rbx,%rsi,4)
movups -0x40(%rcx,%rsi,4),%xmm0
movups -0x30(%rcx,%rsi,4),%xmm1
movups %xmm1,-0x30(%rbx,%rsi,4)
movups %xmm0,-0x40(%rbx,%rsi,4)
add    $0xfffffffffffffff0,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1c90 <flt_move+0xb60>
neg    %rsi
test   $0x1,%al
je     1ce9 <flt_move+0xbb9>
shl    $0x2,%rsi
mov    %rbx,%rax
sub    %rsi,%rax
mov    %rcx,%rdi
sub    %rsi,%rdi
movups -0x20(%rdi),%xmm0
movups -0x10(%rdi),%xmm1
movups %xmm1,-0x10(%rax)
movups %xmm0,-0x20(%rax)
cmp    %rdx,%r13
je     17b0 <flt_move+0x680>
shl    $0x2,%rdx
mov    %r13d,%eax
and    $0x7,%eax
sub    %rdx,%rbx
sub    %rdx,%rcx
jmp    1acd <flt_move+0x99d>
xor    %esi,%esi
test   $0x1,%al
jne    1cc9 <flt_move+0xb99>
jmp    1ce9 <flt_move+0xbb9>
xor    %eax,%eax
lea    0x0(,%r9,4),%r10
test   $0x1,%dl
je     1d3e <flt_move+0xc0e>
shl    $0x2,%rax
mov    %rbx,%rdx
sub    %rax,%rdx
mov    %rsi,%rdi
sub    %rax,%rdi
movups -0x20(%rdi),%xmm0
movups -0x10(%rdi),%xmm1
movups %xmm1,-0x10(%rdx)
movups %xmm0,-0x20(%rdx)
sub    %r10,%rbx
cmp    %r9,%rbp
jne    1d57 <flt_move+0xc27>
mov    %r12,%r10
test   %r8b,%r8b
jne    17b0 <flt_move+0x680>
jmp    1a9e <flt_move+0x96e>
and    $0x7,%ebp
sub    %r10,%rsi
jmp    19ee <flt_move+0x8be>
lea    0x10(%rsp),%rax
cmp    %rax,%r11
je     1d74 <flt_move+0xc44>
mov    %r11,%rdi
call   1030 <free@plt>
add    $0x1018,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @flt_move(float* %0, i64 %1, i64 %2, i64 %3) {
%5 = alloca float*
%6 = alloca i64
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64
%11 = alloca float*
%12 = alloca float*
%13 = alloca [1024 x float]
%14 = alloca float*
store float* %0, float** %5
store i64 %1, i64* %6
store i64 %2, i64* %7
store i64 %3, i64* %8
%15 = load float*, float** %5
%16 = call i32 @assert(float* %15)
%17 = load i64, i64* %8
%18 = load i64, i64* %6
%19 = icmp uge i64 %17, %18
br i1 %19, label %20, label %27
20: ; preds = %4
%21 = load i64, i64* %8
%22 = load i64, i64* %6
%23 = load i64, i64* %7
%24 = add i64 %22, %23
%25 = icmp ult i64 %21, %24
br i1 %25, label %26, label %27
26: ; preds = %20
br label %237
27: ; preds = %20, %4
%28 = load i64, i64* %8
%29 = load i64, i64* %6
%30 = icmp ult i64 %28, %29
br i1 %30, label %31, label %39
31: ; preds = %27
%32 = load i64, i64* %6
%33 = load i64, i64* %7
%34 = add i64 %32, %33
store i64 %34, i64* %10
%35 = load i64, i64* %8
store i64 %35, i64* %6
%36 = load i64, i64* %10
%37 = load i64, i64* %7
%38 = sub i64 %36, %37
store i64 %38, i64* %8
br label %45
39: ; preds = %27
%40 = load i64, i64* %8
%41 = add i64 %40, 1
store i64 %41, i64* %10
%42 = load i64, i64* %6
%43 = load i64, i64* %7
%44 = add i64 %42, %43
store i64 %44, i64* %8
br label %45
45: ; preds = %39, %31
%46 = getelementptr inbounds [1024 x float], [1024 x float]* %13, i64 0, i64 0
store float* %46, float** %14
%47 = load i64, i64* %8
%48 = load i64, i64* %8
%49 = add i64 %47, %48
%50 = load i64, i64* %10
%51 = load i64, i64* %6
%52 = add i64 %50, %51
%53 = icmp ugt i64 %49, %52
br i1 %53, label %54, label %141
54: ; preds = %45
br label %55
55: ; preds = %133, %54
%56 = load i64, i64* %8
%57 = load i64, i64* %6
%58 = icmp ugt i64 %56, %57
br i1 %58, label %59, label %140
59: ; preds = %55
%60 = load i64, i64* %8
%61 = load i64, i64* %6
%62 = sub i64 %60, %61
store i64 %62, i64* %7
%63 = load i64, i64* %7
%64 = icmp ugt i64 %63, 1024
br i1 %64, label %65, label %75
65: ; preds = %59
%66 = load i64, i64* %7
%67 = mul i64 %66, 4
%68 = call i64 @malloc(i64 %67)
%69 = inttoptr i64 %68 to float*
store float* %69, float** %14
%70 = load float*, float** %14
%71 = icmp ne float* %70, null
br i1 %71, label %74, label %72
72: ; preds = %65
%73 = getelementptr inbounds [1024 x float], [1024 x float]* %13, i64 0, i64 0
store float* %73, float** %14
store i64 1024, i64* %7
br label %74
74: ; preds = %72, %65
br label %75
75: ; preds = %74, %59
%76 = load float*, float** %5
%77 = load i64, i64* %8
%78 = getelementptr inbounds float, float* %76, i64 %77
%79 = load i64, i64* %7
%80 = sub i64 0, %79
%81 = getelementptr inbounds float, float* %78, i64 %80
store float* %81, float** %11
%82 = load float*, float** %14
store float* %82, float** %12
%83 = load i64, i64* %7
store i64 %83, i64* %9
br label %84
84: ; preds = %93, %75
%85 = load i64, i64* %9
%86 = icmp ugt i64 %85, 0
br i1 %86, label %87, label %96
87: ; preds = %84
%88 = load float*, float** %11
%89 = getelementptr inbounds float, float* %88, i32 1
store float* %89, float** %11
%90 = load float, float* %88
%91 = load float*, float** %12
%92 = getelementptr inbounds float, float* %91, i32 1
store float* %92, float** %12
store float %90, float* %91
br label %93
93: ; preds = %87
%94 = load i64, i64* %9
%95 = add i64 %94, -1
store i64 %95, i64* %9
br label %84
96: ; preds = %84
%97 = load float*, float** %5
%98 = load i64, i64* %8
%99 = getelementptr inbounds float, float* %97, i64 %98
%100 = load i64, i64* %7
%101 = sub i64 0, %100
%102 = getelementptr inbounds float, float* %99, i64 %101
store float* %102, float** %12
%103 = load i64, i64* %10
%104 = load i64, i64* %8
%105 = sub i64 %103, %104
store i64 %105, i64* %9
br label %106
106: ; preds = %115, %96
%107 = load i64, i64* %9
%108 = icmp ugt i64 %107, 0
br i1 %108, label %109, label %118
109: ; preds = %106
%110 = load float*, float** %11
%111 = getelementptr inbounds float, float* %110, i32 1
store float* %111, float** %11
%112 = load float, float* %110
%113 = load float*, float** %12
%114 = getelementptr inbounds float, float* %113, i32 1
store float* %114, float** %12
store float %112, float* %113
br label %115
115: ; preds = %109
%116 = load i64, i64* %9
%117 = add i64 %116, -1
store i64 %117, i64* %9
br label %106
118: ; preds = %106
%119 = load float*, float** %14
store float* %119, float** %11
%120 = load i64, i64* %7
store i64 %120, i64* %9
br label %121
121: ; preds = %130, %118
%122 = load i64, i64* %9
%123 = icmp ugt i64 %122, 0
br i1 %123, label %124, label %133
124: ; preds = %121
%125 = load float*, float** %11
%126 = getelementptr inbounds float, float* %125, i32 1
store float* %126, float** %11
%127 = load float, float* %125
%128 = load float*, float** %12
%129 = getelementptr inbounds float, float* %128, i32 1
store float* %129, float** %12
store float %127, float* %128
br label %130
130: ; preds = %124
%131 = load i64, i64* %9
%132 = add i64 %131, -1
store i64 %132, i64* %9
br label %121
133: ; preds = %121
%134 = load i64, i64* %7
%135 = load i64, i64* %8
%136 = sub i64 %135, %134
store i64 %136, i64* %8
%137 = load i64, i64* %7
%138 = load i64, i64* %10
%139 = sub i64 %138, %137
store i64 %139, i64* %10
br label %55
140: ; preds = %55
br label %230
141: ; preds = %45
br label %142
142: ; preds = %222, %141
%143 = load i64, i64* %10
%144 = load i64, i64* %8
%145 = icmp ugt i64 %143, %144
br i1 %145, label %146, label %229
146: ; preds = %142
%147 = load i64, i64* %10
%148 = load i64, i64* %8
%149 = sub i64 %147, %148
store i64 %149, i64* %7
%150 = load i64, i64* %7
%151 = icmp ugt i64 %150, 1024
br i1 %151, label %152, label %162
152: ; preds = %146
%153 = load i64, i64* %7
%154 = mul i64 %153, 4
%155 = call i64 @malloc(i64 %154)
%156 = inttoptr i64 %155 to float*
store float* %156, float** %14
%157 = load float*, float** %14
%158 = icmp ne float* %157, null
br i1 %158, label %161, label %159
159: ; preds = %152
%160 = getelementptr inbounds [1024 x float], [1024 x float]* %13, i64 0, i64 0
store float* %160, float** %14
store i64 1024, i64* %7
br label %161
161: ; preds = %159, %152
br label %162
162: ; preds = %161, %146
%163 = load float*, float** %5
%164 = load i64, i64* %8
%165 = getelementptr inbounds float, float* %163, i64 %164
%166 = load i64, i64* %7
%167 = getelementptr inbounds float, float* %165, i64 %166
store float* %167, float** %11
%168 = load float*, float** %14
%169 = load i64, i64* %7
%170 = getelementptr inbounds float, float* %168, i64 %169
store float* %170, float** %12
%171 = load i64, i64* %7
store i64 %171, i64* %9
br label %172
172: ; preds = %181, %162
%173 = load i64, i64* %9
%174 = icmp ugt i64 %173, 0
br i1 %174, label %175, label %184
175: ; preds = %172
%176 = load float*, float** %11
%177 = getelementptr inbounds float, float* %176, i32 -1
store float* %177, float** %11
%178 = load float, float* %177
%179 = load float*, float** %12
%180 = getelementptr inbounds float, float* %179, i32 -1
store float* %180, float** %12
store float %178, float* %180
br label %181
181: ; preds = %175
%182 = load i64, i64* %9
%183 = add i64 %182, -1
store i64 %183, i64* %9
br label %172
184: ; preds = %172
%185 = load float*, float** %5
%186 = load i64, i64* %8
%187 = getelementptr inbounds float, float* %185, i64 %186
%188 = load i64, i64* %7
%189 = getelementptr inbounds float, float* %187, i64 %188
store float* %189, float** %12
%190 = load i64, i64* %8
%191 = load i64, i64* %6
%192 = sub i64 %190, %191
store i64 %192, i64* %9
br label %193
193: ; preds = %202, %184
%194 = load i64, i64* %9
%195 = icmp ugt i64 %194, 0
br i1 %195, label %196, label %205
196: ; preds = %193
%197 = load float*, float** %11
%198 = getelementptr inbounds float, float* %197, i32 -1
store float* %198, float** %11
%199 = load float, float* %198
%200 = load float*, float** %12
%201 = getelementptr inbounds float, float* %200, i32 -1
store float* %201, float** %12
store float %199, float* %201
br label %202
202: ; preds = %196
%203 = load i64, i64* %9
%204 = add i64 %203, -1
store i64 %204, i64* %9
br label %193
205: ; preds = %193
%206 = load float*, float** %14
%207 = load i64, i64* %7
%208 = getelementptr inbounds float, float* %206, i64 %207
store float* %208, float** %11
%209 = load i64, i64* %7
store i64 %209, i64* %9
br label %210
210: ; preds = %219, %205
%211 = load i64, i64* %9
%212 = icmp ugt i64 %211, 0
br i1 %212, label %213, label %222
213: ; preds = %210
%214 = load float*, float** %11
%215 = getelementptr inbounds float, float* %214, i32 -1
store float* %215, float** %11
%216 = load float, float* %215
%217 = load float*, float** %12
%218 = getelementptr inbounds float, float* %217, i32 -1
store float* %218, float** %12
store float %216, float* %218
br label %219
219: ; preds = %213
%220 = load i64, i64* %9
%221 = add i64 %220, -1
store i64 %221, i64* %9
br label %210
222: ; preds = %210
%223 = load i64, i64* %7
%224 = load i64, i64* %8
%225 = add i64 %224, %223
store i64 %225, i64* %8
%226 = load i64, i64* %7
%227 = load i64, i64* %6
%228 = add i64 %227, %226
store i64 %228, i64* %6
br label %142
229: ; preds = %142
br label %230
230: ; preds = %229, %140
%231 = load float*, float** %14
%232 = getelementptr inbounds [1024 x float], [1024 x float]* %13, i64 0, i64 0
%233 = icmp ne float* %231, %232
br i1 %233, label %234, label %237
234: ; preds = %230
%235 = load float*, float** %14
%236 = call i32 @free(float* %235)
br label %237
237: ; preds = %26, %234, %230
ret void
}

LLVM IR (-O2):
define void @flt_move(float* %0, i64 %1, i64 %2, i64 %3) {
%5 = alloca [1024 x float]
%6 = bitcast [1024 x float]* %5 to i8*
%7 = tail call i32 @assert(float* %0)
%8 = icmp uge i64 %3, %1
%9 = add i64 %2, %1
%10 = icmp ugt i64 %9, %3
%11 = and i1 %8, %10
br i1 %11, label %990, label %12
12: ; preds = %4
%13 = icmp ult i64 %3, %1
%14 = add i64 %3, 1
%15 = select i1 %13, i64 %3, i64 %1
%16 = select i1 %13, i64 %1, i64 %9
%17 = select i1 %13, i64 %9, i64 %14
%18 = getelementptr inbounds [1024 x float], [1024 x float]* %5, i64 0, i64 0
%19 = shl i64 %16, 1
%20 = add i64 %17, %15
%21 = icmp ugt i64 %19, %20
br i1 %21, label %26, label %22
22: ; preds = %12
%23 = icmp ugt i64 %17, %16
br i1 %23, label %24, label %990
24: ; preds = %22
%25 = getelementptr float, float* %0, i64 %17
br label %497
26: ; preds = %12
%27 = icmp ugt i64 %16, %15
br i1 %27, label %28, label %990
28: ; preds = %26, %493
%29 = phi float* [ %199, %493 ], [ %18, %26 ]
%30 = phi i64 [ %495, %493 ], [ %17, %26 ]
%31 = phi i64 [ %494, %493 ], [ %16, %26 ]
%32 = sub i64 %31, %15
%33 = icmp ugt i64 %32, 1024
br i1 %33, label %34, label %44
34: ; preds = %28
%35 = shl i64 %32, 2
%36 = tail call i64 @malloc(i64 %35)
%37 = inttoptr i64 %36 to float*
%38 = icmp eq i64 %36, 0
%39 = select i1 %38, i64 1024, i64 %32
%40 = select i1 %38, float* %18, float* %37
%41 = getelementptr inbounds float, float* %0, i64 %31
%42 = sub i64 0, %39
%43 = getelementptr float, float* %41, i64 %42
br label %49
44: ; preds = %28
%45 = getelementptr inbounds float, float* %0, i64 %31
%46 = sub nsw i64 0, %32
%47 = getelementptr float, float* %45, i64 %46
%48 = icmp eq i64 %32, 0
br i1 %48, label %196, label %49
49: ; preds = %34, %44
%50 = phi float* [ %43, %34 ], [ %47, %44 ]
%51 = phi float* [ %40, %34 ], [ %29, %44 ]
%52 = phi i64 [ %39, %34 ], [ %32, %44 ]
%53 = icmp ult i64 %52, 8
br i1 %53, label %142, label %54
54: ; preds = %49
%55 = getelementptr float, float* %51, i64 %52
%56 = getelementptr float, float* %50, i64 %52
%57 = icmp ult float* %51, %56
%58 = icmp ult float* %50, %55
%59 = and i1 %57, %58
br i1 %59, label %142, label %60
60: ; preds = %54
%61 = and i64 %52, -8
%62 = getelementptr float, float* %51, i64 %61
%63 = getelementptr float, float* %50, i64 %61
%64 = and i64 %52, 7
%65 = add i64 %61, -8
%66 = lshr exact i64 %65, 3
%67 = add nuw nsw i64 %66, 1
%68 = and i64 %67, 3
%69 = icmp ult i64 %65, 24
br i1 %69, label %121, label %70
70: ; preds = %60
%71 = and i64 %67, 4611686018427387900
br label %72
72: ; preds = %72, %70
%73 = phi i64 [ 0, %70 ], [ %118, %72 ]
%74 = phi i64 [ 0, %70 ], [ %119, %72 ]
%75 = getelementptr float, float* %51, i64 %73
%76 = getelementptr float, float* %50, i64 %73
%77 = bitcast float* %76 to <4 x float>*
%78 = load <4 x float>, <4 x float>* %77
%79 = getelementptr float, float* %76, i64 4
%80 = bitcast float* %79 to <4 x float>*
%81 = load <4 x float>, <4 x float>* %80
%82 = bitcast float* %75 to <4 x float>*
store <4 x float> %78, <4 x float>* %82
%83 = getelementptr float, float* %75, i64 4
%84 = bitcast float* %83 to <4 x float>*
store <4 x float> %81, <4 x float>* %84
%85 = or i64 %73, 8
%86 = getelementptr float, float* %51, i64 %85
%87 = getelementptr float, float* %50, i64 %85
%88 = bitcast float* %87 to <4 x float>*
%89 = load <4 x float>, <4 x float>* %88
%90 = getelementptr float, float* %87, i64 4
%91 = bitcast float* %90 to <4 x float>*
%92 = load <4 x float>, <4 x float>* %91
%93 = bitcast float* %86 to <4 x float>*
store <4 x float> %89, <4 x float>* %93
%94 = getelementptr float, float* %86, i64 4
%95 = bitcast float* %94 to <4 x float>*
store <4 x float> %92, <4 x float>* %95
%96 = or i64 %73, 16
%97 = getelementptr float, float* %51, i64 %96
%98 = getelementptr float, float* %50, i64 %96
%99 = bitcast float* %98 to <4 x float>*
%100 = load <4 x float>, <4 x float>* %99
%101 = getelementptr float, float* %98, i64 4
%102 = bitcast float* %101 to <4 x float>*
%103 = load <4 x float>, <4 x float>* %102
%104 = bitcast float* %97 to <4 x float>*
store <4 x float> %100, <4 x float>* %104
%105 = getelementptr float, float* %97, i64 4
%106 = bitcast float* %105 to <4 x float>*
store <4 x float> %103, <4 x float>* %106
%107 = or i64 %73, 24
%108 = getelementptr float, float* %51, i64 %107
%109 = getelementptr float, float* %50, i64 %107
%110 = bitcast float* %109 to <4 x float>*
%111 = load <4 x float>, <4 x float>* %110
%112 = getelementptr float, float* %109, i64 4
%113 = bitcast float* %112 to <4 x float>*
%114 = load <4 x float>, <4 x float>* %113
%115 = bitcast float* %108 to <4 x float>*
store <4 x float> %111, <4 x float>* %115
%116 = getelementptr float, float* %108, i64 4
%117 = bitcast float* %116 to <4 x float>*
store <4 x float> %114, <4 x float>* %117
%118 = add nuw i64 %73, 32
%119 = add i64 %74, 4
%120 = icmp eq i64 %119, %71
br i1 %120, label %121, label %72
121: ; preds = %72, %60
%122 = phi i64 [ 0, %60 ], [ %118, %72 ]
%123 = icmp eq i64 %68, 0
br i1 %123, label %140, label %124
124: ; preds = %121, %124
%125 = phi i64 [ %137, %124 ], [ %122, %121 ]
%126 = phi i64 [ %138, %124 ], [ 0, %121 ]
%127 = getelementptr float, float* %51, i64 %125
%128 = getelementptr float, float* %50, i64 %125
%129 = bitcast float* %128 to <4 x float>*
%130 = load <4 x float>, <4 x float>* %129
%131 = getelementptr float, float* %128, i64 4
%132 = bitcast float* %131 to <4 x float>*
%133 = load <4 x float>, <4 x float>* %132
%134 = bitcast float* %127 to <4 x float>*
store <4 x float> %130, <4 x float>* %134
%135 = getelementptr float, float* %127, i64 4
%136 = bitcast float* %135 to <4 x float>*
store <4 x float> %133, <4 x float>* %136
%137 = add nuw i64 %125, 8
%138 = add i64 %126, 1
%139 = icmp eq i64 %138, %68
br i1 %139, label %140, label %124
140: ; preds = %124, %121
%141 = icmp eq i64 %52, %61
br i1 %141, label %196, label %142
142: ; preds = %54, %49, %140
%143 = phi float* [ %51, %54 ], [ %51, %49 ], [ %62, %140 ]
%144 = phi float* [ %50, %54 ], [ %50, %49 ], [ %63, %140 ]
%145 = phi i64 [ %52, %54 ], [ %52, %49 ], [ %64, %140 ]
%146 = add i64 %145, -1
%147 = and i64 %145, 7
%148 = icmp eq i64 %147, 0
br i1 %148, label %160, label %149
149: ; preds = %142, %149
%150 = phi float* [ %156, %149 ], [ %143, %142 ]
%151 = phi float* [ %154, %149 ], [ %144, %142 ]
%152 = phi i64 [ %157, %149 ], [ %145, %142 ]
%153 = phi i64 [ %158, %149 ], [ 0, %142 ]
%154 = getelementptr inbounds float, float* %151, i64 1
%155 = load float, float* %151
%156 = getelementptr inbounds float, float* %150, i64 1
store float %155, float* %150
%157 = add i64 %152, -1
%158 = add i64 %153, 1
%159 = icmp eq i64 %158, %147
br i1 %159, label %160, label %149
160: ; preds = %149, %142
%161 = phi float* [ undef, %142 ], [ %154, %149 ]
%162 = phi float* [ %143, %142 ], [ %156, %149 ]
%163 = phi float* [ %144, %142 ], [ %154, %149 ]
%164 = phi i64 [ %145, %142 ], [ %157, %149 ]
%165 = icmp ult i64 %146, 7
br i1 %165, label %196, label %166
166: ; preds = %160, %166
%167 = phi float* [ %193, %166 ], [ %162, %160 ]
%168 = phi float* [ %191, %166 ], [ %163, %160 ]
%169 = phi i64 [ %194, %166 ], [ %164, %160 ]
%170 = getelementptr inbounds float, float* %168, i64 1
%171 = load float, float* %168
%172 = getelementptr inbounds float, float* %167, i64 1
store float %171, float* %167
%173 = getelementptr inbounds float, float* %168, i64 2
%174 = load float, float* %170
%175 = getelementptr inbounds float, float* %167, i64 2
store float %174, float* %172
%176 = getelementptr inbounds float, float* %168, i64 3
%177 = load float, float* %173
%178 = getelementptr inbounds float, float* %167, i64 3
store float %177, float* %175
%179 = getelementptr inbounds float, float* %168, i64 4
%180 = load float, float* %176
%181 = getelementptr inbounds float, float* %167, i64 4
store float %180, float* %178
%182 = getelementptr inbounds float, float* %168, i64 5
%183 = load float, float* %179
%184 = getelementptr inbounds float, float* %167, i64 5
store float %183, float* %181
%185 = getelementptr inbounds float, float* %168, i64 6
%186 = load float, float* %182
%187 = getelementptr inbounds float, float* %167, i64 6
store float %186, float* %184
%188 = getelementptr inbounds float, float* %168, i64 7
%189 = load float, float* %185
%190 = getelementptr inbounds float, float* %167, i64 7
store float %189, float* %187
%191 = getelementptr inbounds float, float* %168, i64 8
%192 = load float, float* %188
%193 = getelementptr inbounds float, float* %167, i64 8
store float %192, float* %190
%194 = add i64 %169, -8
%195 = icmp eq i64 %194, 0
br i1 %195, label %196, label %166
196: ; preds = %160, %166, %140, %44
%197 = phi i1 [ true, %44 ], [ false, %140 ], [ false, %166 ], [ false, %160 ]
%198 = phi float* [ %47, %44 ], [ %50, %140 ], [ %50, %166 ], [ %50, %160 ]
%199 = phi float* [ %29, %44 ], [ %51, %140 ], [ %51, %166 ], [ %51, %160 ]
%200 = phi i64 [ 0, %44 ], [ %52, %140 ], [ %52, %166 ], [ %52, %160 ]
%201 = phi float* [ %47, %44 ], [ %63, %140 ], [ %161, %160 ], [ %191, %166 ]
%202 = sub i64 %30, %31
%203 = icmp eq i64 %202, 0
br i1 %203, label %318, label %204
204: ; preds = %196
%205 = icmp ult i64 %202, 8
br i1 %205, label %294, label %206
206: ; preds = %204
%207 = getelementptr float, float* %198, i64 %202
%208 = getelementptr float, float* %201, i64 %202
%209 = icmp ult float* %198, %208
%210 = icmp ult float* %201, %207
%211 = and i1 %209, %210
br i1 %211, label %294, label %212
212: ; preds = %206
%213 = and i64 %202, -8
%214 = getelementptr float, float* %198, i64 %213
%215 = getelementptr float, float* %201, i64 %213
%216 = and i64 %202, 7
%217 = add i64 %213, -8
%218 = lshr exact i64 %217, 3
%219 = add nuw nsw i64 %218, 1
%220 = and i64 %219, 3
%221 = icmp ult i64 %217, 24
br i1 %221, label %273, label %222
222: ; preds = %212
%223 = and i64 %219, 4611686018427387900
br label %224
224: ; preds = %224, %222
%225 = phi i64 [ 0, %222 ], [ %270, %224 ]
%226 = phi i64 [ 0, %222 ], [ %271, %224 ]
%227 = getelementptr float, float* %198, i64 %225
%228 = getelementptr float, float* %201, i64 %225
%229 = bitcast float* %228 to <4 x float>*
%230 = load <4 x float>, <4 x float>* %229
%231 = getelementptr float, float* %228, i64 4
%232 = bitcast float* %231 to <4 x float>*
%233 = load <4 x float>, <4 x float>* %232
%234 = bitcast float* %227 to <4 x float>*
store <4 x float> %230, <4 x float>* %234
%235 = getelementptr float, float* %227, i64 4
%236 = bitcast float* %235 to <4 x float>*
store <4 x float> %233, <4 x float>* %236
%237 = or i64 %225, 8
%238 = getelementptr float, float* %198, i64 %237
%239 = getelementptr float, float* %201, i64 %237
%240 = bitcast float* %239 to <4 x float>*
%241 = load <4 x float>, <4 x float>* %240
%242 = getelementptr float, float* %239, i64 4
%243 = bitcast float* %242 to <4 x float>*
%244 = load <4 x float>, <4 x float>* %243
%245 = bitcast float* %238 to <4 x float>*
store <4 x float> %241, <4 x float>* %245
%246 = getelementptr float, float* %238, i64 4
%247 = bitcast float* %246 to <4 x float>*
store <4 x float> %244, <4 x float>* %247
%248 = or i64 %225, 16
%249 = getelementptr float, float* %198, i64 %248
%250 = getelementptr float, float* %201, i64 %248
%251 = bitcast float* %250 to <4 x float>*
%252 = load <4 x float>, <4 x float>* %251
%253 = getelementptr float, float* %250, i64 4
%254 = bitcast float* %253 to <4 x float>*
%255 = load <4 x float>, <4 x float>* %254
%256 = bitcast float* %249 to <4 x float>*
store <4 x float> %252, <4 x float>* %256
%257 = getelementptr float, float* %249, i64 4
%258 = bitcast float* %257 to <4 x float>*
store <4 x float> %255, <4 x float>* %258
%259 = or i64 %225, 24
%260 = getelementptr float, float* %198, i64 %259
%261 = getelementptr float, float* %201, i64 %259
%262 = bitcast float* %261 to <4 x float>*
%263 = load <4 x float>, <4 x float>* %262
%264 = getelementptr float, float* %261, i64 4
%265 = bitcast float* %264 to <4 x float>*
%266 = load <4 x float>, <4 x float>* %265
%267 = bitcast float* %260 to <4 x float>*
store <4 x float> %263, <4 x float>* %267
%268 = getelementptr float, float* %260, i64 4
%269 = bitcast float* %268 to <4 x float>*
store <4 x float> %266, <4 x float>* %269
%270 = add nuw i64 %225, 32
%271 = add i64 %226, 4
%272 = icmp eq i64 %271, %223
br i1 %272, label %273, label %224
273: ; preds = %224, %212
%274 = phi i64 [ 0, %212 ], [ %270, %224 ]
%275 = icmp eq i64 %220, 0
br i1 %275, label %292, label %276
276: ; preds = %273, %276
%277 = phi i64 [ %289, %276 ], [ %274, %273 ]
%278 = phi i64 [ %290, %276 ], [ 0, %273 ]
%279 = getelementptr float, float* %198, i64 %277
%280 = getelementptr float, float* %201, i64 %277
%281 = bitcast float* %280 to <4 x float>*
%282 = load <4 x float>, <4 x float>* %281
%283 = getelementptr float, float* %280, i64 4
%284 = bitcast float* %283 to <4 x float>*
%285 = load <4 x float>, <4 x float>* %284
%286 = bitcast float* %279 to <4 x float>*
store <4 x float> %282, <4 x float>* %286
%287 = getelementptr float, float* %279, i64 4
%288 = bitcast float* %287 to <4 x float>*
store <4 x float> %285, <4 x float>* %288
%289 = add nuw i64 %277, 8
%290 = add i64 %278, 1
%291 = icmp eq i64 %290, %220
br i1 %291, label %292, label %276
292: ; preds = %276, %273
%293 = icmp eq i64 %202, %213
br i1 %293, label %318, label %294
294: ; preds = %206, %204, %292
%295 = phi float* [ %198, %206 ], [ %198, %204 ], [ %214, %292 ]
%296 = phi float* [ %201, %206 ], [ %201, %204 ], [ %215, %292 ]
%297 = phi i64 [ %202, %206 ], [ %202, %204 ], [ %216, %292 ]
%298 = add i64 %297, -1
%299 = and i64 %297, 7
%300 = icmp eq i64 %299, 0
br i1 %300, label %312, label %301
301: ; preds = %294, %301
%302 = phi float* [ %308, %301 ], [ %295, %294 ]
%303 = phi float* [ %306, %301 ], [ %296, %294 ]
%304 = phi i64 [ %309, %301 ], [ %297, %294 ]
%305 = phi i64 [ %310, %301 ], [ 0, %294 ]
%306 = getelementptr inbounds float, float* %303, i64 1
%307 = load float, float* %303
%308 = getelementptr inbounds float, float* %302, i64 1
store float %307, float* %302
%309 = add i64 %304, -1
%310 = add i64 %305, 1
%311 = icmp eq i64 %310, %299
br i1 %311, label %312, label %301
312: ; preds = %301, %294
%313 = phi float* [ undef, %294 ], [ %308, %301 ]
%314 = phi float* [ %295, %294 ], [ %308, %301 ]
%315 = phi float* [ %296, %294 ], [ %306, %301 ]
%316 = phi i64 [ %297, %294 ], [ %309, %301 ]
%317 = icmp ult i64 %298, 7
br i1 %317, label %318, label %433
318: ; preds = %312, %433, %292, %196
%319 = phi float* [ %198, %196 ], [ %214, %292 ], [ %313, %312 ], [ %460, %433 ]
br i1 %197, label %493, label %320
320: ; preds = %318
%321 = icmp ult i64 %200, 8
br i1 %321, label %410, label %322
322: ; preds = %320
%323 = getelementptr float, float* %319, i64 %200
%324 = getelementptr float, float* %199, i64 %200
%325 = icmp ult float* %319, %324
%326 = icmp ult float* %199, %323
%327 = and i1 %325, %326
br i1 %327, label %410, label %328
328: ; preds = %322
%329 = and i64 %200, -8
%330 = getelementptr float, float* %319, i64 %329
%331 = getelementptr float, float* %199, i64 %329
%332 = and i64 %200, 7
%333 = add i64 %329, -8
%334 = lshr exact i64 %333, 3
%335 = add nuw nsw i64 %334, 1
%336 = and i64 %335, 3
%337 = icmp ult i64 %333, 24
br i1 %337, label %389, label %338
338: ; preds = %328
%339 = and i64 %335, 4611686018427387900
br label %340
340: ; preds = %340, %338
%341 = phi i64 [ 0, %338 ], [ %386, %340 ]
%342 = phi i64 [ 0, %338 ], [ %387, %340 ]
%343 = getelementptr float, float* %319, i64 %341
%344 = getelementptr float, float* %199, i64 %341
%345 = bitcast float* %344 to <4 x float>*
%346 = load <4 x float>, <4 x float>* %345
%347 = getelementptr float, float* %344, i64 4
%348 = bitcast float* %347 to <4 x float>*
%349 = load <4 x float>, <4 x float>* %348
%350 = bitcast float* %343 to <4 x float>*
store <4 x float> %346, <4 x float>* %350
%351 = getelementptr float, float* %343, i64 4
%352 = bitcast float* %351 to <4 x float>*
store <4 x float> %349, <4 x float>* %352
%353 = or i64 %341, 8
%354 = getelementptr float, float* %319, i64 %353
%355 = getelementptr float, float* %199, i64 %353
%356 = bitcast float* %355 to <4 x float>*
%357 = load <4 x float>, <4 x float>* %356
%358 = getelementptr float, float* %355, i64 4
%359 = bitcast float* %358 to <4 x float>*
%360 = load <4 x float>, <4 x float>* %359
%361 = bitcast float* %354 to <4 x float>*
store <4 x float> %357, <4 x float>* %361
%362 = getelementptr float, float* %354, i64 4
%363 = bitcast float* %362 to <4 x float>*
store <4 x float> %360, <4 x float>* %363
%364 = or i64 %341, 16
%365 = getelementptr float, float* %319, i64 %364
%366 = getelementptr float, float* %199, i64 %364
%367 = bitcast float* %366 to <4 x float>*
%368 = load <4 x float>, <4 x float>* %367
%369 = getelementptr float, float* %366, i64 4
%370 = bitcast float* %369 to <4 x float>*
%371 = load <4 x float>, <4 x float>* %370
%372 = bitcast float* %365 to <4 x float>*
store <4 x float> %368, <4 x float>* %372
%373 = getelementptr float, float* %365, i64 4
%374 = bitcast float* %373 to <4 x float>*
store <4 x float> %371, <4 x float>* %374
%375 = or i64 %341, 24
%376 = getelementptr float, float* %319, i64 %375
%377 = getelementptr float, float* %199, i64 %375
%378 = bitcast float* %377 to <4 x float>*
%379 = load <4 x float>, <4 x float>* %378
%380 = getelementptr float, float* %377, i64 4
%381 = bitcast float* %380 to <4 x float>*
%382 = load <4 x float>, <4 x float>* %381
%383 = bitcast float* %376 to <4 x float>*
store <4 x float> %379, <4 x float>* %383
%384 = getelementptr float, float* %376, i64 4
%385 = bitcast float* %384 to <4 x float>*
store <4 x float> %382, <4 x float>* %385
%386 = add nuw i64 %341, 32
%387 = add i64 %342, 4
%388 = icmp eq i64 %387, %339
br i1 %388, label %389, label %340
389: ; preds = %340, %328
%390 = phi i64 [ 0, %328 ], [ %386, %340 ]
%391 = icmp eq i64 %336, 0
br i1 %391, label %408, label %392
392: ; preds = %389, %392
%393 = phi i64 [ %405, %392 ], [ %390, %389 ]
%394 = phi i64 [ %406, %392 ], [ 0, %389 ]
%395 = getelementptr float, float* %319, i64 %393
%396 = getelementptr float, float* %199, i64 %393
%397 = bitcast float* %396 to <4 x float>*
%398 = load <4 x float>, <4 x float>* %397
%399 = getelementptr float, float* %396, i64 4
%400 = bitcast float* %399 to <4 x float>*
%401 = load <4 x float>, <4 x float>* %400
%402 = bitcast float* %395 to <4 x float>*
store <4 x float> %398, <4 x float>* %402
%403 = getelementptr float, float* %395, i64 4
%404 = bitcast float* %403 to <4 x float>*
store <4 x float> %401, <4 x float>* %404
%405 = add nuw i64 %393, 8
%406 = add i64 %394, 1
%407 = icmp eq i64 %406, %336
br i1 %407, label %408, label %392
408: ; preds = %392, %389
%409 = icmp eq i64 %200, %329
br i1 %409, label %493, label %410
410: ; preds = %322, %320, %408
%411 = phi float* [ %319, %322 ], [ %319, %320 ], [ %330, %408 ]
%412 = phi float* [ %199, %322 ], [ %199, %320 ], [ %331, %408 ]
%413 = phi i64 [ %200, %322 ], [ %200, %320 ], [ %332, %408 ]
%414 = add i64 %413, -1
%415 = and i64 %413, 7
%416 = icmp eq i64 %415, 0
br i1 %416, label %428, label %417
417: ; preds = %410, %417
%418 = phi float* [ %424, %417 ], [ %411, %410 ]
%419 = phi float* [ %422, %417 ], [ %412, %410 ]
%420 = phi i64 [ %425, %417 ], [ %413, %410 ]
%421 = phi i64 [ %426, %417 ], [ 0, %410 ]
%422 = getelementptr inbounds float, float* %419, i64 1
%423 = load float, float* %419
%424 = getelementptr inbounds float, float* %418, i64 1
store float %423, float* %418
%425 = add i64 %420, -1
%426 = add i64 %421, 1
%427 = icmp eq i64 %426, %415
br i1 %427, label %428, label %417
428: ; preds = %417, %410
%429 = phi float* [ %411, %410 ], [ %424, %417 ]
%430 = phi float* [ %412, %410 ], [ %422, %417 ]
%431 = phi i64 [ %413, %410 ], [ %425, %417 ]
%432 = icmp ult i64 %414, 7
br i1 %432, label %493, label %463
433: ; preds = %312, %433
%434 = phi float* [ %460, %433 ], [ %314, %312 ]
%435 = phi float* [ %458, %433 ], [ %315, %312 ]
%436 = phi i64 [ %461, %433 ], [ %316, %312 ]
%437 = getelementptr inbounds float, float* %435, i64 1
%438 = load float, float* %435
%439 = getelementptr inbounds float, float* %434, i64 1
store float %438, float* %434
%440 = getelementptr inbounds float, float* %435, i64 2
%441 = load float, float* %437
%442 = getelementptr inbounds float, float* %434, i64 2
store float %441, float* %439
%443 = getelementptr inbounds float, float* %435, i64 3
%444 = load float, float* %440
%445 = getelementptr inbounds float, float* %434, i64 3
store float %444, float* %442
%446 = getelementptr inbounds float, float* %435, i64 4
%447 = load float, float* %443
%448 = getelementptr inbounds float, float* %434, i64 4
store float %447, float* %445
%449 = getelementptr inbounds float, float* %435, i64 5
%450 = load float, float* %446
%451 = getelementptr inbounds float, float* %434, i64 5
store float %450, float* %448
%452 = getelementptr inbounds float, float* %435, i64 6
%453 = load float, float* %449
%454 = getelementptr inbounds float, float* %434, i64 6
store float %453, float* %451
%455 = getelementptr inbounds float, float* %435, i64 7
%456 = load float, float* %452
%457 = getelementptr inbounds float, float* %434, i64 7
store float %456, float* %454
%458 = getelementptr inbounds float, float* %435, i64 8
%459 = load float, float* %455
%460 = getelementptr inbounds float, float* %434, i64 8
store float %459, float* %457
%461 = add i64 %436, -8
%462 = icmp eq i64 %461, 0
br i1 %462, label %318, label %433
463: ; preds = %428, %463
%464 = phi float* [ %490, %463 ], [ %429, %428 ]
%465 = phi float* [ %488, %463 ], [ %430, %428 ]
%466 = phi i64 [ %491, %463 ], [ %431, %428 ]
%467 = getelementptr inbounds float, float* %465, i64 1
%468 = load float, float* %465
%469 = getelementptr inbounds float, float* %464, i64 1
store float %468, float* %464
%470 = getelementptr inbounds float, float* %465, i64 2
%471 = load float, float* %467
%472 = getelementptr inbounds float, float* %464, i64 2
store float %471, float* %469
%473 = getelementptr inbounds float, float* %465, i64 3
%474 = load float, float* %470
%475 = getelementptr inbounds float, float* %464, i64 3
store float %474, float* %472
%476 = getelementptr inbounds float, float* %465, i64 4
%477 = load float, float* %473
%478 = getelementptr inbounds float, float* %464, i64 4
store float %477, float* %475
%479 = getelementptr inbounds float, float* %465, i64 5
%480 = load float, float* %476
%481 = getelementptr inbounds float, float* %464, i64 5
store float %480, float* %478
%482 = getelementptr inbounds float, float* %465, i64 6
%483 = load float, float* %479
%484 = getelementptr inbounds float, float* %464, i64 6
store float %483, float* %481
%485 = getelementptr inbounds float, float* %465, i64 7
%486 = load float, float* %482
%487 = getelementptr inbounds float, float* %464, i64 7
store float %486, float* %484
%488 = getelementptr inbounds float, float* %465, i64 8
%489 = load float, float* %485
%490 = getelementptr inbounds float, float* %464, i64 8
store float %489, float* %487
%491 = add i64 %466, -8
%492 = icmp eq i64 %491, 0
br i1 %492, label %493, label %463
493: ; preds = %428, %463, %408, %318
%494 = sub i64 %31, %200
%495 = sub i64 %30, %200
%496 = icmp ugt i64 %494, %15
br i1 %496, label %28, label %985
497: ; preds = %24, %981
%498 = phi float* [ %667, %981 ], [ %18, %24 ]
%499 = phi i64 [ %982, %981 ], [ %16, %24 ]
%500 = phi i64 [ %983, %981 ], [ %15, %24 ]
%501 = sub i64 %17, %499
%502 = icmp ugt i64 %501, 1024
br i1 %502, label %503, label %513
503: ; preds = %497
%504 = shl i64 %501, 2
%505 = tail call i64 @malloc(i64 %504)
%506 = inttoptr i64 %505 to float*
%507 = icmp eq i64 %505, 0
%508 = select i1 %507, i64 1024, i64 %501
%509 = select i1 %507, float* %18, float* %506
%510 = getelementptr float, float* %0, i64 %499
%511 = getelementptr inbounds float, float* %510, i64 %508
%512 = getelementptr inbounds float, float* %509, i64 %508
br label %516
513: ; preds = %497
%514 = getelementptr inbounds float, float* %498, i64 %501
%515 = icmp eq i64 %501, 0
br i1 %515, label %663, label %516
516: ; preds = %503, %513
%517 = phi float* [ %512, %503 ], [ %514, %513 ]
%518 = phi float* [ %511, %503 ], [ %25, %513 ]
%519 = phi float* [ %509, %503 ], [ %498, %513 ]
%520 = phi i64 [ %508, %503 ], [ %501, %513 ]
%521 = icmp ult i64 %520, 8
br i1 %521, label %609, label %522
522: ; preds = %516
%523 = sub i64 0, %520
%524 = getelementptr float, float* %517, i64 %523
%525 = getelementptr float, float* %518, i64 %523
%526 = icmp ult float* %524, %518
%527 = icmp ult float* %525, %517
%528 = and i1 %526, %527
br i1 %528, label %609, label %529
529: ; preds = %522
%530 = and i64 %520, -8
%531 = sub i64 0, %530
%532 = getelementptr float, float* %517, i64 %531
%533 = sub i64 0, %530
%534 = getelementptr float, float* %518, i64 %533
%535 = and i64 %520, 7
%536 = add i64 %530, -8
%537 = lshr exact i64 %536, 3
%538 = add nuw nsw i64 %537, 1
%539 = and i64 %538, 1
%540 = icmp eq i64 %536, 0
br i1 %540, label %585, label %541
541: ; preds = %529
%542 = and i64 %538, 4611686018427387902
%543 = getelementptr float, float* %517, i64 -1
%544 = getelementptr float, float* %518, i64 -1
%545 = getelementptr float, float* %517, i64 -1
%546 = getelementptr float, float* %518, i64 -1
br label %547
547: ; preds = %547, %541
%548 = phi i64 [ 0, %541 ], [ %582, %547 ]
%549 = phi i64 [ 0, %541 ], [ %583, %547 ]
%550 = sub i64 0, %548
%551 = sub i64 0, %548
%552 = getelementptr inbounds float, float* %544, i64 %551
%553 = getelementptr inbounds float, float* %552, i64 -3
%554 = bitcast float* %553 to <4 x float>*
%555 = load <4 x float>, <4 x float>* %554
%556 = getelementptr inbounds float, float* %552, i64 -4
%557 = getelementptr inbounds float, float* %556, i64 -3
%558 = bitcast float* %557 to <4 x float>*
%559 = load <4 x float>, <4 x float>* %558
%560 = getelementptr inbounds float, float* %543, i64 %550
%561 = getelementptr inbounds float, float* %560, i64 -3
%562 = bitcast float* %561 to <4 x float>*
store <4 x float> %555, <4 x float>* %562
%563 = getelementptr inbounds float, float* %560, i64 -4
%564 = getelementptr inbounds float, float* %563, i64 -3
%565 = bitcast float* %564 to <4 x float>*
store <4 x float> %559, <4 x float>* %565
%566 = sub nuw nsw i64 -8, %548
%567 = sub nuw nsw i64 -8, %548
%568 = getelementptr inbounds float, float* %546, i64 %567
%569 = getelementptr inbounds float, float* %568, i64 -3
%570 = bitcast float* %569 to <4 x float>*
%571 = load <4 x float>, <4 x float>* %570
%572 = getelementptr inbounds float, float* %568, i64 -4
%573 = getelementptr inbounds float, float* %572, i64 -3
%574 = bitcast float* %573 to <4 x float>*
%575 = load <4 x float>, <4 x float>* %574
%576 = getelementptr inbounds float, float* %545, i64 %566
%577 = getelementptr inbounds float, float* %576, i64 -3
%578 = bitcast float* %577 to <4 x float>*
store <4 x float> %571, <4 x float>* %578
%579 = getelementptr inbounds float, float* %576, i64 -4
%580 = getelementptr inbounds float, float* %579, i64 -3
%581 = bitcast float* %580 to <4 x float>*
store <4 x float> %575, <4 x float>* %581
%582 = add nuw i64 %548, 16
%583 = add i64 %549, 2
%584 = icmp eq i64 %583, %542
br i1 %584, label %585, label %547
585: ; preds = %547, %529
%586 = phi i64 [ 0, %529 ], [ %582, %547 ]
%587 = icmp eq i64 %539, 0
br i1 %587, label %607, label %588
588: ; preds = %585
%589 = sub i64 0, %586
%590 = getelementptr float, float* %517, i64 -1
%591 = sub i64 0, %586
%592 = getelementptr float, float* %518, i64 -1
%593 = getelementptr inbounds float, float* %592, i64 %591
%594 = getelementptr inbounds float, float* %593, i64 -3
%595 = bitcast float* %594 to <4 x float>*
%596 = load <4 x float>, <4 x float>* %595
%597 = getelementptr inbounds float, float* %593, i64 -4
%598 = getelementptr inbounds float, float* %597, i64 -3
%599 = bitcast float* %598 to <4 x float>*
%600 = load <4 x float>, <4 x float>* %599
%601 = getelementptr inbounds float, float* %590, i64 %589
%602 = getelementptr inbounds float, float* %601, i64 -3
%603 = bitcast float* %602 to <4 x float>*
store <4 x float> %596, <4 x float>* %603
%604 = getelementptr inbounds float, float* %601, i64 -4
%605 = getelementptr inbounds float, float* %604, i64 -3
%606 = bitcast float* %605 to <4 x float>*
store <4 x float> %600, <4 x float>* %606
br label %607
607: ; preds = %585, %588
%608 = icmp eq i64 %520, %530
br i1 %608, label %663, label %609
609: ; preds = %522, %516, %607
%610 = phi float* [ %517, %522 ], [ %517, %516 ], [ %532, %607 ]
%611 = phi float* [ %518, %522 ], [ %518, %516 ], [ %534, %607 ]
%612 = phi i64 [ %520, %522 ], [ %520, %516 ], [ %535, %607 ]
%613 = add i64 %612, -1
%614 = and i64 %612, 7
%615 = icmp eq i64 %614, 0
br i1 %615, label %627, label %616
616: ; preds = %609, %616
%617 = phi float* [ %623, %616 ], [ %610, %609 ]
%618 = phi float* [ %621, %616 ], [ %611, %609 ]
%619 = phi i64 [ %624, %616 ], [ %612, %609 ]
%620 = phi i64 [ %625, %616 ], [ 0, %609 ]
%621 = getelementptr inbounds float, float* %618, i64 -1
%622 = load float, float* %621
%623 = getelementptr inbounds float, float* %617, i64 -1
store float %622, float* %623
%624 = add i64 %619, -1
%625 = add i64 %620, 1
%626 = icmp eq i64 %625, %614
br i1 %626, label %627, label %616
627: ; preds = %616, %609
%628 = phi float* [ undef, %609 ], [ %621, %616 ]
%629 = phi float* [ %610, %609 ], [ %623, %616 ]
%630 = phi float* [ %611, %609 ], [ %621, %616 ]
%631 = phi i64 [ %612, %609 ], [ %624, %616 ]
%632 = icmp ult i64 %613, 7
br i1 %632, label %663, label %633
633: ; preds = %627, %633
%634 = phi float* [ %660, %633 ], [ %629, %627 ]
%635 = phi float* [ %658, %633 ], [ %630, %627 ]
%636 = phi i64 [ %661, %633 ], [ %631, %627 ]
%637 = getelementptr inbounds float, float* %635, i64 -1
%638 = load float, float* %637
%639 = getelementptr inbounds float, float* %634, i64 -1
store float %638, float* %639
%640 = getelementptr inbounds float, float* %635, i64 -2
%641 = load float, float* %640
%642 = getelementptr inbounds float, float* %634, i64 -2
store float %641, float* %642
%643 = getelementptr inbounds float, float* %635, i64 -3
%644 = load float, float* %643
%645 = getelementptr inbounds float, float* %634, i64 -3
store float %644, float* %645
%646 = getelementptr inbounds float, float* %635, i64 -4
%647 = load float, float* %646
%648 = getelementptr inbounds float, float* %634, i64 -4
store float %647, float* %648
%649 = getelementptr inbounds float, float* %635, i64 -5
%650 = load float, float* %649
%651 = getelementptr inbounds float, float* %634, i64 -5
store float %650, float* %651
%652 = getelementptr inbounds float, float* %635, i64 -6
%653 = load float, float* %652
%654 = getelementptr inbounds float, float* %634, i64 -6
store float %653, float* %654
%655 = getelementptr inbounds float, float* %635, i64 -7
%656 = load float, float* %655
%657 = getelementptr inbounds float, float* %634, i64 -7
store float %656, float* %657
%658 = getelementptr inbounds float, float* %635, i64 -8
%659 = load float, float* %658
%660 = getelementptr inbounds float, float* %634, i64 -8
store float %659, float* %660
%661 = add i64 %636, -8
%662 = icmp eq i64 %661, 0
br i1 %662, label %663, label %633
663: ; preds = %627, %633, %607, %513
%664 = phi i1 [ true, %513 ], [ false, %607 ], [ false, %633 ], [ false, %627 ]
%665 = phi float* [ %514, %513 ], [ %517, %607 ], [ %517, %633 ], [ %517, %627 ]
%666 = phi float* [ %25, %513 ], [ %518, %607 ], [ %518, %633 ], [ %518, %627 ]
%667 = phi float* [ %498, %513 ], [ %519, %607 ], [ %519, %633 ], [ %519, %627 ]
%668 = phi i64 [ 0, %513 ], [ %520, %607 ], [ %520, %633 ], [ %520, %627 ]
%669 = phi float* [ %25, %513 ], [ %534, %607 ], [ %628, %627 ], [ %658, %633 ]
%670 = sub i64 %499, %500
%671 = icmp eq i64 %670, 0
br i1 %671, label %807, label %672
672: ; preds = %663
%673 = icmp ult i64 %670, 8
br i1 %673, label %783, label %674
674: ; preds = %672
%675 = xor i64 %500, -1
%676 = add i64 %499, %675
%677 = getelementptr float, float* %666, i64 -1
%678 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %676, i64 4)
%679 = extractvalue { i64, i1 } %678, 0
%680 = extractvalue { i64, i1 } %678, 1
%681 = bitcast float* %677 to i8*
%682 = sub i64 0, %679
%683 = getelementptr i8, i8* %681, i64 %682
%684 = icmp ugt i8* %683, %681
%685 = or i1 %684, %680
%686 = getelementptr float, float* %669, i64 -1
%687 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %676, i64 4)
%688 = extractvalue { i64, i1 } %687, 0
%689 = extractvalue { i64, i1 } %687, 1
%690 = bitcast float* %686 to i8*
%691 = sub i64 0, %688
%692 = getelementptr i8, i8* %690, i64 %691
%693 = icmp ugt i8* %692, %690
%694 = or i1 %693, %689
%695 = or i1 %685, %694
br i1 %695, label %783, label %696
696: ; preds = %674
%697 = sub i64 %500, %499
%698 = getelementptr float, float* %666, i64 %697
%699 = getelementptr float, float* %669, i64 %697
%700 = icmp ult float* %698, %669
%701 = icmp ult float* %699, %666
%702 = and i1 %700, %701
br i1 %702, label %783, label %703
703: ; preds = %696
%704 = and i64 %670, -8
%705 = sub i64 0, %704
%706 = getelementptr float, float* %666, i64 %705
%707 = sub i64 0, %704
%708 = getelementptr float, float* %669, i64 %707
%709 = and i64 %670, 7
%710 = add i64 %704, -8
%711 = lshr exact i64 %710, 3
%712 = add nuw nsw i64 %711, 1
%713 = and i64 %712, 1
%714 = icmp eq i64 %710, 0
br i1 %714, label %759, label %715
715: ; preds = %703
%716 = and i64 %712, 4611686018427387902
%717 = getelementptr float, float* %666, i64 -1
%718 = getelementptr float, float* %669, i64 -1
%719 = getelementptr float, float* %666, i64 -1
%720 = getelementptr float, float* %669, i64 -1
br label %721
721: ; preds = %721, %715
%722 = phi i64 [ 0, %715 ], [ %756, %721 ]
%723 = phi i64 [ 0, %715 ], [ %757, %721 ]
%724 = sub i64 0, %722
%725 = sub i64 0, %722
%726 = getelementptr inbounds float, float* %718, i64 %725
%727 = getelementptr inbounds float, float* %726, i64 -3
%728 = bitcast float* %727 to <4 x float>*
%729 = load <4 x float>, <4 x float>* %728
%730 = getelementptr inbounds float, float* %726, i64 -4
%731 = getelementptr inbounds float, float* %730, i64 -3
%732 = bitcast float* %731 to <4 x float>*
%733 = load <4 x float>, <4 x float>* %732
%734 = getelementptr inbounds float, float* %717, i64 %724
%735 = getelementptr inbounds float, float* %734, i64 -3
%736 = bitcast float* %735 to <4 x float>*
store <4 x float> %729, <4 x float>* %736
%737 = getelementptr inbounds float, float* %734, i64 -4
%738 = getelementptr inbounds float, float* %737, i64 -3
%739 = bitcast float* %738 to <4 x float>*
store <4 x float> %733, <4 x float>* %739
%740 = sub nuw nsw i64 -8, %722
%741 = sub nuw nsw i64 -8, %722
%742 = getelementptr inbounds float, float* %720, i64 %741
%743 = getelementptr inbounds float, float* %742, i64 -3
%744 = bitcast float* %743 to <4 x float>*
%745 = load <4 x float>, <4 x float>* %744
%746 = getelementptr inbounds float, float* %742, i64 -4
%747 = getelementptr inbounds float, float* %746, i64 -3
%748 = bitcast float* %747 to <4 x float>*
%749 = load <4 x float>, <4 x float>* %748
%750 = getelementptr inbounds float, float* %719, i64 %740
%751 = getelementptr inbounds float, float* %750, i64 -3
%752 = bitcast float* %751 to <4 x float>*
store <4 x float> %745, <4 x float>* %752
%753 = getelementptr inbounds float, float* %750, i64 -4
%754 = getelementptr inbounds float, float* %753, i64 -3
%755 = bitcast float* %754 to <4 x float>*
store <4 x float> %749, <4 x float>* %755
%756 = add nuw i64 %722, 16
%757 = add i64 %723, 2
%758 = icmp eq i64 %757, %716
br i1 %758, label %759, label %721
759: ; preds = %721, %703
%760 = phi i64 [ 0, %703 ], [ %756, %721 ]
%761 = icmp eq i64 %713, 0
br i1 %761, label %781, label %762
762: ; preds = %759
%763 = sub i64 0, %760
%764 = getelementptr float, float* %666, i64 -1
%765 = sub i64 0, %760
%766 = getelementptr float, float* %669, i64 -1
%767 = getelementptr inbounds float, float* %766, i64 %765
%768 = getelementptr inbounds float, float* %767, i64 -3
%769 = bitcast float* %768 to <4 x float>*
%770 = load <4 x float>, <4 x float>* %769
%771 = getelementptr inbounds float, float* %767, i64 -4
%772 = getelementptr inbounds float, float* %771, i64 -3
%773 = bitcast float* %772 to <4 x float>*
%774 = load <4 x float>, <4 x float>* %773
%775 = getelementptr inbounds float, float* %764, i64 %763
%776 = getelementptr inbounds float, float* %775, i64 -3
%777 = bitcast float* %776 to <4 x float>*
store <4 x float> %770, <4 x float>* %777
%778 = getelementptr inbounds float, float* %775, i64 -4
%779 = getelementptr inbounds float, float* %778, i64 -3
%780 = bitcast float* %779 to <4 x float>*
store <4 x float> %774, <4 x float>* %780
br label %781
781: ; preds = %759, %762
%782 = icmp eq i64 %670, %704
br i1 %782, label %807, label %783
783: ; preds = %696, %674, %672, %781
%784 = phi float* [ %666, %696 ], [ %666, %674 ], [ %666, %672 ], [ %706, %781 ]
%785 = phi float* [ %669, %696 ], [ %669, %674 ], [ %669, %672 ], [ %708, %781 ]
%786 = phi i64 [ %670, %696 ], [ %670, %674 ], [ %670, %672 ], [ %709, %781 ]
%787 = add i64 %786, -1
%788 = and i64 %786, 7
%789 = icmp eq i64 %788, 0
br i1 %789, label %801, label %790
790: ; preds = %783, %790
%791 = phi float* [ %797, %790 ], [ %784, %783 ]
%792 = phi float* [ %795, %790 ], [ %785, %783 ]
%793 = phi i64 [ %798, %790 ], [ %786, %783 ]
%794 = phi i64 [ %799, %790 ], [ 0, %783 ]
%795 = getelementptr inbounds float, float* %792, i64 -1
%796 = load float, float* %795
%797 = getelementptr inbounds float, float* %791, i64 -1
store float %796, float* %797
%798 = add i64 %793, -1
%799 = add i64 %794, 1
%800 = icmp eq i64 %799, %788
br i1 %800, label %801, label %790
801: ; preds = %790, %783
%802 = phi float* [ undef, %783 ], [ %797, %790 ]
%803 = phi float* [ %784, %783 ], [ %797, %790 ]
%804 = phi float* [ %785, %783 ], [ %795, %790 ]
%805 = phi i64 [ %786, %783 ], [ %798, %790 ]
%806 = icmp ult i64 %787, 7
br i1 %806, label %807, label %921
807: ; preds = %801, %921, %781, %663
%808 = phi float* [ %666, %663 ], [ %706, %781 ], [ %802, %801 ], [ %948, %921 ]
br i1 %664, label %981, label %809
809: ; preds = %807
%810 = icmp ult i64 %668, 8
br i1 %810, label %898, label %811
811: ; preds = %809
%812 = sub i64 0, %668
%813 = getelementptr float, float* %808, i64 %812
%814 = getelementptr float, float* %665, i64 %812
%815 = icmp ult float* %813, %665
%816 = icmp ult float* %814, %808
%817 = and i1 %815, %816
br i1 %817, label %898, label %818
818: ; preds = %811
%819 = and i64 %668, -8
%820 = sub i64 0, %819
%821 = getelementptr float, float* %808, i64 %820
%822 = sub i64 0, %819
%823 = getelementptr float, float* %665, i64 %822
%824 = and i64 %668, 7
%825 = add i64 %819, -8
%826 = lshr exact i64 %825, 3
%827 = add nuw nsw i64 %826, 1
%828 = and i64 %827, 1
%829 = icmp eq i64 %825, 0
br i1 %829, label %874, label %830
830: ; preds = %818
%831 = and i64 %827, 4611686018427387902
%832 = getelementptr float, float* %808, i64 -1
%833 = getelementptr float, float* %665, i64 -1
%834 = getelementptr float, float* %808, i64 -1
%835 = getelementptr float, float* %665, i64 -1
br label %836
836: ; preds = %836, %830
%837 = phi i64 [ 0, %830 ], [ %871, %836 ]
%838 = phi i64 [ 0, %830 ], [ %872, %836 ]
%839 = sub i64 0, %837
%840 = sub i64 0, %837
%841 = getelementptr inbounds float, float* %833, i64 %840
%842 = getelementptr inbounds float, float* %841, i64 -3
%843 = bitcast float* %842 to <4 x float>*
%844 = load <4 x float>, <4 x float>* %843
%845 = getelementptr inbounds float, float* %841, i64 -4
%846 = getelementptr inbounds float, float* %845, i64 -3
%847 = bitcast float* %846 to <4 x float>*
%848 = load <4 x float>, <4 x float>* %847
%849 = getelementptr inbounds float, float* %832, i64 %839
%850 = getelementptr inbounds float, float* %849, i64 -3
%851 = bitcast float* %850 to <4 x float>*
store <4 x float> %844, <4 x float>* %851
%852 = getelementptr inbounds float, float* %849, i64 -4
%853 = getelementptr inbounds float, float* %852, i64 -3
%854 = bitcast float* %853 to <4 x float>*
store <4 x float> %848, <4 x float>* %854
%855 = sub nuw nsw i64 -8, %837
%856 = sub nuw nsw i64 -8, %837
%857 = getelementptr inbounds float, float* %835, i64 %856
%858 = getelementptr inbounds float, float* %857, i64 -3
%859 = bitcast float* %858 to <4 x float>*
%860 = load <4 x float>, <4 x float>* %859
%861 = getelementptr inbounds float, float* %857, i64 -4
%862 = getelementptr inbounds float, float* %861, i64 -3
%863 = bitcast float* %862 to <4 x float>*
%864 = load <4 x float>, <4 x float>* %863
%865 = getelementptr inbounds float, float* %834, i64 %855
%866 = getelementptr inbounds float, float* %865, i64 -3
%867 = bitcast float* %866 to <4 x float>*
store <4 x float> %860, <4 x float>* %867
%868 = getelementptr inbounds float, float* %865, i64 -4
%869 = getelementptr inbounds float, float* %868, i64 -3
%870 = bitcast float* %869 to <4 x float>*
store <4 x float> %864, <4 x float>* %870
%871 = add nuw i64 %837, 16
%872 = add i64 %838, 2
%873 = icmp eq i64 %872, %831
br i1 %873, label %874, label %836
874: ; preds = %836, %818
%875 = phi i64 [ 0, %818 ], [ %871, %836 ]
%876 = icmp eq i64 %828, 0
br i1 %876, label %896, label %877
877: ; preds = %874
%878 = sub i64 0, %875
%879 = getelementptr float, float* %808, i64 -1
%880 = sub i64 0, %875
%881 = getelementptr float, float* %665, i64 -1
%882 = getelementptr inbounds float, float* %881, i64 %880
%883 = getelementptr inbounds float, float* %882, i64 -3
%884 = bitcast float* %883 to <4 x float>*
%885 = load <4 x float>, <4 x float>* %884
%886 = getelementptr inbounds float, float* %882, i64 -4
%887 = getelementptr inbounds float, float* %886, i64 -3
%888 = bitcast float* %887 to <4 x float>*
%889 = load <4 x float>, <4 x float>* %888
%890 = getelementptr inbounds float, float* %879, i64 %878
%891 = getelementptr inbounds float, float* %890, i64 -3
%892 = bitcast float* %891 to <4 x float>*
store <4 x float> %885, <4 x float>* %892
%893 = getelementptr inbounds float, float* %890, i64 -4
%894 = getelementptr inbounds float, float* %893, i64 -3
%895 = bitcast float* %894 to <4 x float>*
store <4 x float> %889, <4 x float>* %895
br label %896
896: ; preds = %874, %877
%897 = icmp eq i64 %668, %819
br i1 %897, label %981, label %898
898: ; preds = %811, %809, %896
%899 = phi float* [ %808, %811 ], [ %808, %809 ], [ %821, %896 ]
%900 = phi float* [ %665, %811 ], [ %665, %809 ], [ %823, %896 ]
%901 = phi i64 [ %668, %811 ], [ %668, %809 ], [ %824, %896 ]
%902 = add i64 %901, -1
%903 = and i64 %901, 7
%904 = icmp eq i64 %903, 0
br i1 %904, label %916, label %905
905: ; preds = %898, %905
%906 = phi float* [ %912, %905 ], [ %899, %898 ]
%907 = phi float* [ %910, %905 ], [ %900, %898 ]
%908 = phi i64 [ %913, %905 ], [ %901, %898 ]
%909 = phi i64 [ %914, %905 ], [ 0, %898 ]
%910 = getelementptr inbounds float, float* %907, i64 -1
%911 = load float, float* %910
%912 = getelementptr inbounds float, float* %906, i64 -1
store float %911, float* %912
%913 = add i64 %908, -1
%914 = add i64 %909, 1
%915 = icmp eq i64 %914, %903
br i1 %915, label %916, label %905
916: ; preds = %905, %898
%917 = phi float* [ %899, %898 ], [ %912, %905 ]
%918 = phi float* [ %900, %898 ], [ %910, %905 ]
%919 = phi i64 [ %901, %898 ], [ %913, %905 ]
%920 = icmp ult i64 %902, 7
br i1 %920, label %981, label %951
921: ; preds = %801, %921
%922 = phi float* [ %948, %921 ], [ %803, %801 ]
%923 = phi float* [ %946, %921 ], [ %804, %801 ]
%924 = phi i64 [ %949, %921 ], [ %805, %801 ]
%925 = getelementptr inbounds float, float* %923, i64 -1
%926 = load float, float* %925
%927 = getelementptr inbounds float, float* %922, i64 -1
store float %926, float* %927
%928 = getelementptr inbounds float, float* %923, i64 -2
%929 = load float, float* %928
%930 = getelementptr inbounds float, float* %922, i64 -2
store float %929, float* %930
%931 = getelementptr inbounds float, float* %923, i64 -3
%932 = load float, float* %931
%933 = getelementptr inbounds float, float* %922, i64 -3
store float %932, float* %933
%934 = getelementptr inbounds float, float* %923, i64 -4
%935 = load float, float* %934
%936 = getelementptr inbounds float, float* %922, i64 -4
store float %935, float* %936
%937 = getelementptr inbounds float, float* %923, i64 -5
%938 = load float, float* %937
%939 = getelementptr inbounds float, float* %922, i64 -5
store float %938, float* %939
%940 = getelementptr inbounds float, float* %923, i64 -6
%941 = load float, float* %940
%942 = getelementptr inbounds float, float* %922, i64 -6
store float %941, float* %942
%943 = getelementptr inbounds float, float* %923, i64 -7
%944 = load float, float* %943
%945 = getelementptr inbounds float, float* %922, i64 -7
store float %944, float* %945
%946 = getelementptr inbounds float, float* %923, i64 -8
%947 = load float, float* %946
%948 = getelementptr inbounds float, float* %922, i64 -8
store float %947, float* %948
%949 = add i64 %924, -8
%950 = icmp eq i64 %949, 0
br i1 %950, label %807, label %921
951: ; preds = %916, %951
%952 = phi float* [ %978, %951 ], [ %917, %916 ]
%953 = phi float* [ %976, %951 ], [ %918, %916 ]
%954 = phi i64 [ %979, %951 ], [ %919, %916 ]
%955 = getelementptr inbounds float, float* %953, i64 -1
%956 = load float, float* %955
%957 = getelementptr inbounds float, float* %952, i64 -1
store float %956, float* %957
%958 = getelementptr inbounds float, float* %953, i64 -2
%959 = load float, float* %958
%960 = getelementptr inbounds float, float* %952, i64 -2
store float %959, float* %960
%961 = getelementptr inbounds float, float* %953, i64 -3
%962 = load float, float* %961
%963 = getelementptr inbounds float, float* %952, i64 -3
store float %962, float* %963
%964 = getelementptr inbounds float, float* %953, i64 -4
%965 = load float, float* %964
%966 = getelementptr inbounds float, float* %952, i64 -4
store float %965, float* %966
%967 = getelementptr inbounds float, float* %953, i64 -5
%968 = load float, float* %967
%969 = getelementptr inbounds float, float* %952, i64 -5
store float %968, float* %969
%970 = getelementptr inbounds float, float* %953, i64 -6
%971 = load float, float* %970
%972 = getelementptr inbounds float, float* %952, i64 -6
store float %971, float* %972
%973 = getelementptr inbounds float, float* %953, i64 -7
%974 = load float, float* %973
%975 = getelementptr inbounds float, float* %952, i64 -7
store float %974, float* %975
%976 = getelementptr inbounds float, float* %953, i64 -8
%977 = load float, float* %976
%978 = getelementptr inbounds float, float* %952, i64 -8
store float %977, float* %978
%979 = add i64 %954, -8
%980 = icmp eq i64 %979, 0
br i1 %980, label %981, label %951
981: ; preds = %916, %951, %896, %807
%982 = add i64 %668, %499
%983 = add i64 %668, %500
%984 = icmp ugt i64 %17, %982
br i1 %984, label %497, label %985
985: ; preds = %981, %493
%986 = phi float* [ %199, %493 ], [ %667, %981 ]
%987 = icmp eq float* %986, %18
br i1 %987, label %990, label %988
988: ; preds = %985
%989 = call i32 @free(float* %986)
br label %990
990: ; preds = %22, %26, %985, %988, %4
ret void
}