#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(size_t *);
int /*<<< orphan*/ free(size_t *);
scalar_t__ malloc(size_t);
void siz_move(size_t *array, size_t off, size_t n, size_t pos) {
  size_t i, end;
  size_t *src, *dst;
  size_t 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 = (size_t *)malloc(n * sizeof(size_t));
        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 = (size_t *)malloc(n * sizeof(size_t));
        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):
<siz_move>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2050,%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 <siz_move+0x4c>
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x18(%rbp),%rcx
cmp    %rcx,%rax
jae    117c <siz_move+0x4c>
jmp    15ab <siz_move+0x47b>
mov    -0x20(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    11af <siz_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 <siz_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    -0x2040(%rbp),%rax
mov    %rax,-0x2048(%rbp)
mov    -0x20(%rbp),%rax
add    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    -0x10(%rbp),%rcx
cmp    %rcx,%rax
jbe    13b2 <siz_move+0x282>
jmp    11f3 <siz_move+0xc3>
mov    -0x20(%rbp),%rax
cmp    -0x10(%rbp),%rax
jbe    13ad <siz_move+0x27d>
mov    -0x20(%rbp),%rax
sub    -0x10(%rbp),%rax
mov    %rax,-0x18(%rbp)
cmpq   $0x400,-0x18(%rbp)
jbe    1258 <siz_move+0x128>
mov    -0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x2048(%rbp)
cmpq   $0x0,-0x2048(%rbp)
jne    1253 <siz_move+0x123>
lea    -0x2040(%rbp),%rax
mov    %rax,-0x2048(%rbp)
movq   $0x400,-0x18(%rbp)
jmp    1258 <siz_move+0x128>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
xor    %ecx,%ecx
sub    -0x18(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x2048(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jbe    12cb <siz_move+0x19b>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%rcx
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x40(%rbp)
mov    %rcx,(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    128b <siz_move+0x15b>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
xor    %ecx,%ecx
sub    -0x18(%rbp),%rcx
shl    $0x3,%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    1337 <siz_move+0x207>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%rcx
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x40(%rbp)
mov    %rcx,(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    12f7 <siz_move+0x1c7>
mov    -0x2048(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jbe    138a <siz_move+0x25a>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%rcx
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x40(%rbp)
mov    %rcx,(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    134a <siz_move+0x21a>
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 <siz_move+0xc3>
jmp    1588 <siz_move+0x458>
jmp    13b7 <siz_move+0x287>
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jbe    1583 <siz_move+0x453>
mov    -0x30(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %rax,-0x18(%rbp)
cmpq   $0x400,-0x18(%rbp)
jbe    141c <siz_move+0x2ec>
mov    -0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x2048(%rbp)
cmpq   $0x0,-0x2048(%rbp)
jne    1417 <siz_move+0x2e7>
lea    -0x2040(%rbp),%rax
mov    %rax,-0x2048(%rbp)
movq   $0x400,-0x18(%rbp)
jmp    141c <siz_move+0x2ec>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x2048(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jbe    149a <siz_move+0x36a>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x38(%rbp)
mov    -0x8(%rax),%rcx
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffff8,%rdx
mov    %rdx,-0x40(%rbp)
mov    %rcx,-0x8(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    1458 <siz_move+0x328>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%rcx
shl    $0x3,%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    1506 <siz_move+0x3d6>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x38(%rbp)
mov    -0x8(%rax),%rcx
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffff8,%rdx
mov    %rdx,-0x40(%rbp)
mov    %rcx,-0x8(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    14c4 <siz_move+0x394>
mov    -0x2048(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jbe    1566 <siz_move+0x436>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x38(%rbp)
mov    -0x8(%rax),%rcx
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffff8,%rdx
mov    %rdx,-0x40(%rbp)
mov    %rcx,-0x8(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    1524 <siz_move+0x3f4>
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    13b7 <siz_move+0x287>
jmp    1588 <siz_move+0x458>
mov    -0x2048(%rbp),%rax
lea    -0x2040(%rbp),%rcx
cmp    %rcx,%rax
je     15ab <siz_move+0x47b>
mov    -0x2048(%rbp),%rdi
call   1030 <free@plt>
add    $0x2050,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<siz_move>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2018,%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 <siz_move+0x34>
cmp    %r14,%rbx
ja     1d14 <siz_move+0xbe4>
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    1757 <siz_move+0x627>
cmp    %r14,%r15
jbe    1d14 <siz_move+0xbe4>
lea    0x10(%rsp),%r13
mov    %r13,%r11
jmp    11af <siz_move+0x7f>
nopl   0x0(%rax,%rax,1)
sub    %r12,%r15
sub    %r12,%r10
cmp    %r14,%r15
jbe    1d02 <siz_move+0xbd2>
mov    %r15,%r12
sub    %r14,%r12
cmp    $0x401,%r12
jb     1200 <siz_move+0xd0>
lea    0x0(,%r12,8),%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,8),%rax
lea    0x0(,%r12,8),%rcx
sub    %rcx,%rax
jmp    1218 <siz_move+0xe8>
nopl   0x0(%rax)
mov    (%rsp),%rax
lea    (%rax,%r15,8),%rax
lea    0x0(,%r12,8),%rcx
sub    %rcx,%rax
test   %r12,%r12
je     1272 <siz_move+0x142>
mov    %r11,%rdx
mov    %rax,%rcx
mov    %r12,%rbx
cmp    $0x4,%r12
jb     1350 <siz_move+0x220>
lea    (%rax,%r12,8),%rcx
cmp    %rcx,%r11
jae    124a <siz_move+0x11a>
lea    (%r11,%r12,8),%rsi
mov    %r11,%rdx
mov    %rax,%rcx
mov    %r12,%rbx
cmp    %rsi,%rax
jb     1350 <siz_move+0x220>
mov    %r12,%rdx
and    $0xfffffffffffffffc,%rdx
lea    -0x4(%rdx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%ecx
and    $0x3,%ecx
cmp    $0xc,%rdi
jae    1280 <siz_move+0x150>
xor    %ebp,%ebp
jmp    12f0 <siz_move+0x1c0>
mov    $0x1,%r8b
xor    %r12d,%r12d
mov    %rax,%rcx
jmp    13e6 <siz_move+0x2b6>
movabs $0x7ffffffffffffffc,%rdi
ff ff 7f
and    %rdi,%rsi
xor    %ebp,%ebp
nop
movups (%rax,%rbp,8),%xmm0
movups 0x10(%rax,%rbp,8),%xmm1
movups %xmm0,(%r11,%rbp,8)
movups %xmm1,0x10(%r11,%rbp,8)
movups 0x20(%rax,%rbp,8),%xmm0
movups 0x30(%rax,%rbp,8),%xmm1
movups %xmm0,0x20(%r11,%rbp,8)
movups %xmm1,0x30(%r11,%rbp,8)
movups 0x40(%rax,%rbp,8),%xmm0
movups 0x50(%rax,%rbp,8),%xmm1
movups %xmm0,0x40(%r11,%rbp,8)
movups %xmm1,0x50(%r11,%rbp,8)
movups 0x60(%rax,%rbp,8),%xmm0
movups 0x70(%rax,%rbp,8),%xmm1
movups %xmm0,0x60(%r11,%rbp,8)
movups %xmm1,0x70(%r11,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rsi
jne    1290 <siz_move+0x160>
test   %rcx,%rcx
je     132b <siz_move+0x1fb>
lea    (%rax,%rbp,8),%rsi
add    $0x10,%rsi
lea    (%r11,%rbp,8),%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 <siz_move+0x1e0>
lea    (%rax,%rdx,8),%rcx
cmp    %rdx,%r12
je     13e3 <siz_move+0x2b3>
mov    %r12d,%ebx
and    $0x3,%ebx
lea    (%r11,%rdx,8),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    -0x1(%rbx),%r8
mov    %rbx,%rsi
and    $0x7,%rsi
je     137a <siz_move+0x24a>
xor    %edi,%edi
nop
mov    (%rcx),%rbp
add    $0x8,%rcx
mov    %rbp,(%rdx)
add    $0x8,%rdx
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    1360 <siz_move+0x230>
sub    %rdi,%rbx
cmp    $0x7,%r8
jb     13e3 <siz_move+0x2b3>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rcx),%rsi
mov    %rsi,(%rdx,%rbp,8)
mov    0x8(%rcx),%rsi
mov    %rsi,0x8(%rdx,%rbp,8)
mov    0x10(%rcx),%rsi
mov    %rsi,0x10(%rdx,%rbp,8)
mov    0x18(%rcx),%rsi
mov    %rsi,0x18(%rdx,%rbp,8)
mov    0x20(%rcx),%rsi
mov    %rsi,0x20(%rdx,%rbp,8)
mov    0x28(%rcx),%rsi
mov    %rsi,0x28(%rdx,%rbp,8)
mov    0x30(%rcx),%rsi
mov    %rsi,0x30(%rdx,%rbp,8)
mov    0x38(%rcx),%rsi
add    $0x40,%rcx
mov    %rsi,0x38(%rdx,%rbp,8)
add    $0x8,%rbp
cmp    %rbp,%rbx
jne    1390 <siz_move+0x260>
xor    %r8d,%r8d
mov    %r10,%rsi
sub    %r15,%rsi
je     1593 <siz_move+0x463>
cmp    $0x4,%rsi
jb     1500 <siz_move+0x3d0>
lea    (%rcx,%rsi,8),%rdx
cmp    %rdx,%rax
jae    1412 <siz_move+0x2e2>
lea    (%rax,%rsi,8),%rdx
cmp    %rdx,%rcx
jb     1500 <siz_move+0x3d0>
mov    %rsi,%r9
and    $0xfffffffffffffffc,%r9
lea    -0x4(%r9),%rdi
mov    %rdi,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
mov    %ebx,%edx
and    $0x3,%edx
cmp    $0xc,%rdi
jae    1437 <siz_move+0x307>
xor    %ebp,%ebp
jmp    14a8 <siz_move+0x378>
movabs $0x7ffffffffffffffc,%rdi
ff ff 7f
and    %rdi,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movups (%rcx,%rbp,8),%xmm0
movups 0x10(%rcx,%rbp,8),%xmm1
movups %xmm0,(%rax,%rbp,8)
movups %xmm1,0x10(%rax,%rbp,8)
movups 0x20(%rcx,%rbp,8),%xmm0
movups 0x30(%rcx,%rbp,8),%xmm1
movups %xmm0,0x20(%rax,%rbp,8)
movups %xmm1,0x30(%rax,%rbp,8)
movups 0x40(%rcx,%rbp,8),%xmm0
movups 0x50(%rcx,%rbp,8),%xmm1
movups %xmm0,0x40(%rax,%rbp,8)
movups %xmm1,0x50(%rax,%rbp,8)
movups 0x60(%rcx,%rbp,8),%xmm0
movups 0x70(%rcx,%rbp,8),%xmm1
movups %xmm0,0x60(%rax,%rbp,8)
movups %xmm1,0x70(%rax,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rbx
jne    1450 <siz_move+0x320>
test   %rdx,%rdx
je     14ec <siz_move+0x3bc>
lea    (%rcx,%rbp,8),%rdi
add    $0x10,%rdi
lea    (%rax,%rbp,8),%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    14d0 <siz_move+0x3a0>
lea    (%rax,%r9,8),%rax
cmp    %r9,%rsi
je     1593 <siz_move+0x463>
and    $0x3,%esi
lea    (%rcx,%r9,8),%rcx
lea    -0x1(%rsi),%rbp
mov    %rsi,%rdx
and    $0x7,%rdx
je     152a <siz_move+0x3fa>
xor    %edi,%edi
nop
mov    (%rcx),%rbx
add    $0x8,%rcx
mov    %rbx,(%rax)
add    $0x8,%rax
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    1510 <siz_move+0x3e0>
sub    %rdi,%rsi
cmp    $0x7,%rbp
jb     1593 <siz_move+0x463>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rcx,%rdx,8),%rdi
mov    %rdi,(%rax)
mov    0x8(%rcx,%rdx,8),%rdi
mov    %rdi,0x8(%rax)
mov    0x10(%rcx,%rdx,8),%rdi
mov    %rdi,0x10(%rax)
mov    0x18(%rcx,%rdx,8),%rdi
mov    %rdi,0x18(%rax)
mov    0x20(%rcx,%rdx,8),%rdi
mov    %rdi,0x20(%rax)
mov    0x28(%rcx,%rdx,8),%rdi
mov    %rdi,0x28(%rax)
mov    0x30(%rcx,%rdx,8),%rdi
mov    %rdi,0x30(%rax)
mov    0x38(%rcx,%rdx,8),%rdi
mov    %rdi,0x38(%rax)
add    $0x40,%rax
add    $0x8,%rdx
cmp    %rdx,%rsi
jne    1540 <siz_move+0x410>
test   %r8b,%r8b
jne    11a0 <siz_move+0x70>
cmp    $0x4,%r12
jb     15bc <siz_move+0x48c>
lea    (%r11,%r12,8),%rcx
cmp    %rcx,%rax
jae    166c <siz_move+0x53c>
lea    (%rax,%r12,8),%rcx
cmp    %rcx,%r11
jae    166c <siz_move+0x53c>
mov    %r11,%rdx
mov    %r12,%rbp
lea    -0x1(%rbp),%rsi
mov    %rbp,%rcx
and    $0x7,%rcx
je     15fa <siz_move+0x4ca>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rdx),%rbx
add    $0x8,%rdx
mov    %rbx,(%rax)
add    $0x8,%rax
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    15e0 <siz_move+0x4b0>
sub    %rdi,%rbp
cmp    $0x7,%rsi
jb     11a0 <siz_move+0x70>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
mov    (%rdx,%rcx,8),%rsi
mov    %rsi,(%rax,%rcx,8)
mov    0x8(%rdx,%rcx,8),%rsi
mov    %rsi,0x8(%rax,%rcx,8)
mov    0x10(%rdx,%rcx,8),%rsi
mov    %rsi,0x10(%rax,%rcx,8)
mov    0x18(%rdx,%rcx,8),%rsi
mov    %rsi,0x18(%rax,%rcx,8)
mov    0x20(%rdx,%rcx,8),%rsi
mov    %rsi,0x20(%rax,%rcx,8)
mov    0x28(%rdx,%rcx,8),%rsi
mov    %rsi,0x28(%rax,%rcx,8)
mov    0x30(%rdx,%rcx,8),%rsi
mov    %rsi,0x30(%rax,%rcx,8)
mov    0x38(%rdx,%rcx,8),%rsi
mov    %rsi,0x38(%rax,%rcx,8)
add    $0x8,%rcx
cmp    %rcx,%rbp
jne    1610 <siz_move+0x4e0>
jmp    11a0 <siz_move+0x70>
mov    %r12,%rdx
and    $0xfffffffffffffffc,%rdx
lea    -0x4(%rdx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%ecx
and    $0x3,%ecx
cmp    $0xc,%rdi
jae    1691 <siz_move+0x561>
xor    %ebp,%ebp
jmp    1700 <siz_move+0x5d0>
movabs $0x7ffffffffffffffc,%rdi
ff ff 7f
and    %rdi,%rsi
xor    %ebp,%ebp
movups (%r11,%rbp,8),%xmm0
movups 0x10(%r11,%rbp,8),%xmm1
movups %xmm0,(%rax,%rbp,8)
movups %xmm1,0x10(%rax,%rbp,8)
movups 0x20(%r11,%rbp,8),%xmm0
movups 0x30(%r11,%rbp,8),%xmm1
movups %xmm0,0x20(%rax,%rbp,8)
movups %xmm1,0x30(%rax,%rbp,8)
movups 0x40(%r11,%rbp,8),%xmm0
movups 0x50(%r11,%rbp,8),%xmm1
movups %xmm0,0x40(%rax,%rbp,8)
movups %xmm1,0x50(%rax,%rbp,8)
movups 0x60(%r11,%rbp,8),%xmm0
movups 0x70(%r11,%rbp,8),%xmm1
movups %xmm0,0x60(%rax,%rbp,8)
movups %xmm1,0x70(%rax,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rsi
jne    16a0 <siz_move+0x570>
test   %rcx,%rcx
je     173b <siz_move+0x60b>
lea    (%r11,%rbp,8),%rsi
add    $0x10,%rsi
lea    (%rax,%rbp,8),%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    1720 <siz_move+0x5f0>
cmp    %rdx,%r12
je     11a0 <siz_move+0x70>
mov    %r12d,%ebp
and    $0x3,%ebp
lea    (%rax,%rdx,8),%rax
lea    (%r11,%rdx,8),%rdx
jmp    15c2 <siz_move+0x492>
cmp    %r15,%r10
jbe    1d14 <siz_move+0xbe4>
lea    0x10(%rsp),%r11
mov    (%rsp),%rax
lea    (%rax,%r10,8),%rax
mov    %rax,0x8(%rsp)
mov    %r10,%r12
jmp    178f <siz_move+0x65f>
nopw   0x0(%rax,%rax,1)
add    %r13,%r15
add    %r13,%r14
cmp    %r15,%r10
jbe    1d02 <siz_move+0xbd2>
mov    %r10,%r13
sub    %r15,%r13
cmp    $0x401,%r13
jb     17e0 <siz_move+0x6b0>
lea    0x0(,%r13,8),%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,8),%rax
lea    (%rax,%r13,8),%rbx
lea    (%r11,%r13,8),%rcx
jmp    17f2 <siz_move+0x6c2>
nopl   0x0(%rax,%rax,1)
lea    (%r11,%r13,8),%rcx
test   %r13,%r13
je     1897 <siz_move+0x767>
mov    0x8(%rsp),%rbx
mov    %rcx,%rax
mov    %rbx,%rsi
mov    %r13,%r9
cmp    $0x4,%r13
jb     1900 <siz_move+0x7d0>
lea    0x0(,%r13,8),%rax
mov    %rcx,%rdx
sub    %rax,%rdx
cmp    %rbx,%rdx
jae    1830 <siz_move+0x700>
mov    %rbx,%rdx
sub    %rax,%rdx
mov    %rcx,%rax
mov    %rbx,%rsi
mov    %r13,%r9
cmp    %rcx,%rdx
jb     1900 <siz_move+0x7d0>
mov    %r13,%rax
and    $0xfffffffffffffffc,%rax
lea    -0x4(%rax),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     18aa <siz_move+0x77a>
movabs $0x7ffffffffffffffc,%rsi
ff ff 7f
lea    0x2(%rsi),%rdi
and    %rdx,%rdi
xor    %esi,%esi
xchg   %ax,%ax
movups -0x20(%rbx,%rsi,8),%xmm0
movups -0x10(%rbx,%rsi,8),%xmm1
movups %xmm1,-0x10(%rcx,%rsi,8)
movups %xmm0,-0x20(%rcx,%rsi,8)
movups -0x40(%rbx,%rsi,8),%xmm0
movups -0x30(%rbx,%rsi,8),%xmm1
movups %xmm1,-0x30(%rcx,%rsi,8)
movups %xmm0,-0x40(%rcx,%rsi,8)
add    $0xfffffffffffffff8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1860 <siz_move+0x730>
neg    %rsi
jmp    18ac <siz_move+0x77c>
mov    $0x1,%r8b
mov    0x8(%rsp),%rsi
mov    %rsi,%rbx
xor    %r13d,%r13d
jmp    1998 <siz_move+0x868>
xor    %esi,%esi
lea    0x0(,%rax,8),%rbp
test   $0x1,%dl
je     18d9 <siz_move+0x7a9>
shl    $0x3,%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     1995 <siz_move+0x865>
mov    %r13d,%r9d
and    $0x3,%r9d
mov    %rcx,%rax
sub    %rbp,%rax
cs nopw 0x0(%rax,%rax,1)
nop
lea    -0x1(%r9),%r8
mov    %r9,%rdx
and    $0x7,%rdx
je     192c <siz_move+0x7fc>
xor    %ebp,%ebp
nop
mov    -0x8(%rsi),%rdi
add    $0xfffffffffffffff8,%rsi
mov    %rdi,-0x8(%rax)
add    $0xfffffffffffffff8,%rax
add    $0x1,%rbp
cmp    %rbp,%rdx
jne    1910 <siz_move+0x7e0>
sub    %rbp,%r9
cmp    $0x7,%r8
jb     1995 <siz_move+0x865>
neg    %r9
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    -0x8(%rsi),%rdx
mov    %rdx,-0x8(%rax,%rbp,8)
mov    -0x10(%rsi),%rdx
mov    %rdx,-0x10(%rax,%rbp,8)
mov    -0x18(%rsi),%rdx
mov    %rdx,-0x18(%rax,%rbp,8)
mov    -0x20(%rsi),%rdx
mov    %rdx,-0x20(%rax,%rbp,8)
mov    -0x28(%rsi),%rdx
mov    %rdx,-0x28(%rax,%rbp,8)
mov    -0x30(%rsi),%rdx
mov    %rdx,-0x30(%rax,%rbp,8)
mov    -0x38(%rsi),%rdx
mov    %rdx,-0x38(%rax,%rbp,8)
mov    -0x40(%rsi),%rdx
add    $0xffffffffffffffc0,%rsi
mov    %rdx,-0x40(%rax,%rbp,8)
add    $0xfffffffffffffff8,%rbp
cmp    %rbp,%r9
jne    1940 <siz_move+0x810>
xor    %r8d,%r8d
mov    %r15,%rbp
sub    %r14,%rbp
je     1a45 <siz_move+0x915>
cmp    $0x4,%rbp
jae    1b20 <siz_move+0x9f0>
lea    -0x1(%rbp),%r9
mov    %rbp,%rdx
and    $0x7,%rdx
je     19dc <siz_move+0x8ac>
xor    %edi,%edi
nopl   (%rax)
mov    -0x8(%rsi),%rax
add    $0xfffffffffffffff8,%rsi
mov    %rax,-0x8(%rbx)
add    $0xfffffffffffffff8,%rbx
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    19c0 <siz_move+0x890>
sub    %rdi,%rbp
mov    %r12,%r10
cmp    $0x7,%r9
jb     1a45 <siz_move+0x915>
neg    %rbp
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
mov    -0x8(%rsi,%rax,8),%rdx
mov    %rdx,-0x8(%rbx)
mov    -0x10(%rsi,%rax,8),%rdx
mov    %rdx,-0x10(%rbx)
mov    -0x18(%rsi,%rax,8),%rdx
mov    %rdx,-0x18(%rbx)
mov    -0x20(%rsi,%rax,8),%rdx
mov    %rdx,-0x20(%rbx)
mov    -0x28(%rsi,%rax,8),%rdx
mov    %rdx,-0x28(%rbx)
mov    -0x30(%rsi,%rax,8),%rdx
mov    %rdx,-0x30(%rbx)
mov    -0x38(%rsi,%rax,8),%rdx
mov    %rdx,-0x38(%rbx)
mov    -0x40(%rsi,%rax,8),%rdx
mov    %rdx,-0x40(%rbx)
add    $0xffffffffffffffc0,%rbx
add    $0xfffffffffffffff8,%rax
cmp    %rax,%rbp
jne    19f0 <siz_move+0x8c0>
test   %r8b,%r8b
jne    1780 <siz_move+0x650>
cmp    $0x4,%r13
jb     1a7a <siz_move+0x94a>
lea    0x0(,%r13,8),%rax
mov    %rbx,%rdx
sub    %rax,%rdx
cmp    %rcx,%rdx
jae    1bfa <siz_move+0xaca>
mov    %rcx,%rdx
sub    %rax,%rdx
cmp    %rbx,%rdx
jae    1bfa <siz_move+0xaca>
mov    %r13,%rax
lea    -0x1(%rax),%rdx
mov    %rax,%rsi
and    $0x7,%rsi
je     1aac <siz_move+0x97c>
xor    %edi,%edi
nopl   0x0(%rax)
mov    -0x8(%rcx),%rbp
add    $0xfffffffffffffff8,%rcx
mov    %rbp,-0x8(%rbx)
add    $0xfffffffffffffff8,%rbx
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    1a90 <siz_move+0x960>
sub    %rdi,%rax
cmp    $0x7,%rdx
jb     1780 <siz_move+0x650>
neg    %rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
mov    -0x8(%rcx,%rdx,8),%rsi
mov    %rsi,-0x8(%rbx,%rdx,8)
mov    -0x10(%rcx,%rdx,8),%rsi
mov    %rsi,-0x10(%rbx,%rdx,8)
mov    -0x18(%rcx,%rdx,8),%rsi
mov    %rsi,-0x18(%rbx,%rdx,8)
mov    -0x20(%rcx,%rdx,8),%rsi
mov    %rsi,-0x20(%rbx,%rdx,8)
mov    -0x28(%rcx,%rdx,8),%rsi
mov    %rsi,-0x28(%rbx,%rdx,8)
mov    -0x30(%rcx,%rdx,8),%rsi
mov    %rsi,-0x30(%rbx,%rdx,8)
mov    -0x38(%rcx,%rdx,8),%rsi
mov    %rsi,-0x38(%rbx,%rdx,8)
mov    -0x40(%rcx,%rdx,8),%rsi
mov    %rsi,-0x40(%rbx,%rdx,8)
add    $0xfffffffffffffff8,%rdx
cmp    %rdx,%rax
jne    1ac0 <siz_move+0x990>
jmp    1780 <siz_move+0x650>
xchg   %ax,%ax
mov    %r14,%rax
not    %rax
add    %r15,%rax
mov    $0x8,%edx
mul    %rdx
lea    -0x8(%rbx),%rdx
seto   %r9b
mov    %rdx,%rdi
sub    %rax,%rdi
cmp    %rdx,%rdi
ja     19ae <siz_move+0x87e>
test   %r9b,%r9b
jne    19ae <siz_move+0x87e>
lea    -0x8(%rsi),%rdx
mov    %rdx,%rdi
sub    %rax,%rdi
cmp    %rdx,%rdi
ja     19ae <siz_move+0x87e>
test   %r9b,%r9b
jne    19ae <siz_move+0x87e>
mov    %r14,%rax
sub    %r15,%rax
lea    (%rbx,%rax,8),%rdx
cmp    %rsi,%rdx
jae    1b89 <siz_move+0xa59>
lea    (%rsi,%rax,8),%rax
cmp    %rbx,%rax
jb     19ae <siz_move+0x87e>
mov    %rbp,%r9
and    $0xfffffffffffffffc,%r9
lea    -0x4(%r9),%rax
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rax,%rax
je     1caf <siz_move+0xb7f>
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
lea    0x2(%rax),%rdi
and    %rdx,%rdi
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups -0x20(%rsi,%rax,8),%xmm0
movups -0x10(%rsi,%rax,8),%xmm1
movups %xmm1,-0x10(%rbx,%rax,8)
movups %xmm0,-0x20(%rbx,%rax,8)
movups -0x40(%rsi,%rax,8),%xmm0
movups -0x30(%rsi,%rax,8),%xmm1
movups %xmm1,-0x30(%rbx,%rax,8)
movups %xmm0,-0x40(%rbx,%rax,8)
add    $0xfffffffffffffff8,%rax
add    $0xfffffffffffffffe,%rdi
jne    1bc0 <siz_move+0xa90>
neg    %rax
jmp    1cb1 <siz_move+0xb81>
mov    %r13,%rdx
and    $0xfffffffffffffffc,%rdx
lea    -0x4(%rdx),%rsi
mov    %rsi,%rax
shr    $0x2,%rax
add    $0x1,%rax
test   %rsi,%rsi
je     1ca7 <siz_move+0xb77>
movabs $0x7ffffffffffffffc,%rsi
ff ff 7f
lea    0x2(%rsi),%rdi
and    %rax,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
movups -0x20(%rcx,%rsi,8),%xmm0
movups -0x10(%rcx,%rsi,8),%xmm1
movups %xmm1,-0x10(%rbx,%rsi,8)
movups %xmm0,-0x20(%rbx,%rsi,8)
movups -0x40(%rcx,%rsi,8),%xmm0
movups -0x30(%rcx,%rsi,8),%xmm1
movups %xmm1,-0x30(%rbx,%rsi,8)
movups %xmm0,-0x40(%rbx,%rsi,8)
add    $0xfffffffffffffff8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1c30 <siz_move+0xb00>
neg    %rsi
test   $0x1,%al
je     1c89 <siz_move+0xb59>
shl    $0x3,%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     1780 <siz_move+0x650>
shl    $0x3,%rdx
mov    %r13d,%eax
and    $0x3,%eax
sub    %rdx,%rbx
sub    %rdx,%rcx
jmp    1a7d <siz_move+0x94d>
xor    %esi,%esi
test   $0x1,%al
jne    1c69 <siz_move+0xb39>
jmp    1c89 <siz_move+0xb59>
xor    %eax,%eax
lea    0x0(,%r9,8),%r10
test   $0x1,%dl
je     1cde <siz_move+0xbae>
shl    $0x3,%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    1cf7 <siz_move+0xbc7>
mov    %r12,%r10
test   %r8b,%r8b
jne    1780 <siz_move+0x650>
jmp    1a4e <siz_move+0x91e>
and    $0x3,%ebp
sub    %r10,%rsi
jmp    19ae <siz_move+0x87e>
lea    0x10(%rsp),%rax
cmp    %rax,%r11
je     1d14 <siz_move+0xbe4>
mov    %r11,%rdi
call   1030 <free@plt>
add    $0x2018,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @siz_move(i64* %0, i64 %1, i64 %2, i64 %3) {
%5 = alloca i64*
%6 = alloca i64
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64
%11 = alloca i64*
%12 = alloca i64*
%13 = alloca [1024 x i64]
%14 = alloca i64*
store i64* %0, i64** %5
store i64 %1, i64* %6
store i64 %2, i64* %7
store i64 %3, i64* %8
%15 = load i64*, i64** %5
%16 = call i32 @assert(i64* %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 i64], [1024 x i64]* %13, i64 0, i64 0
store i64* %46, i64** %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, 8
%68 = call i64 @malloc(i64 %67)
%69 = inttoptr i64 %68 to i64*
store i64* %69, i64** %14
%70 = load i64*, i64** %14
%71 = icmp ne i64* %70, null
br i1 %71, label %74, label %72
72: ; preds = %65
%73 = getelementptr inbounds [1024 x i64], [1024 x i64]* %13, i64 0, i64 0
store i64* %73, i64** %14
store i64 1024, i64* %7
br label %74
74: ; preds = %72, %65
br label %75
75: ; preds = %74, %59
%76 = load i64*, i64** %5
%77 = load i64, i64* %8
%78 = getelementptr inbounds i64, i64* %76, i64 %77
%79 = load i64, i64* %7
%80 = sub i64 0, %79
%81 = getelementptr inbounds i64, i64* %78, i64 %80
store i64* %81, i64** %11
%82 = load i64*, i64** %14
store i64* %82, i64** %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 i64*, i64** %11
%89 = getelementptr inbounds i64, i64* %88, i32 1
store i64* %89, i64** %11
%90 = load i64, i64* %88
%91 = load i64*, i64** %12
%92 = getelementptr inbounds i64, i64* %91, i32 1
store i64* %92, i64** %12
store i64 %90, i64* %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 i64*, i64** %5
%98 = load i64, i64* %8
%99 = getelementptr inbounds i64, i64* %97, i64 %98
%100 = load i64, i64* %7
%101 = sub i64 0, %100
%102 = getelementptr inbounds i64, i64* %99, i64 %101
store i64* %102, i64** %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 i64*, i64** %11
%111 = getelementptr inbounds i64, i64* %110, i32 1
store i64* %111, i64** %11
%112 = load i64, i64* %110
%113 = load i64*, i64** %12
%114 = getelementptr inbounds i64, i64* %113, i32 1
store i64* %114, i64** %12
store i64 %112, i64* %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 i64*, i64** %14
store i64* %119, i64** %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 i64*, i64** %11
%126 = getelementptr inbounds i64, i64* %125, i32 1
store i64* %126, i64** %11
%127 = load i64, i64* %125
%128 = load i64*, i64** %12
%129 = getelementptr inbounds i64, i64* %128, i32 1
store i64* %129, i64** %12
store i64 %127, i64* %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, 8
%155 = call i64 @malloc(i64 %154)
%156 = inttoptr i64 %155 to i64*
store i64* %156, i64** %14
%157 = load i64*, i64** %14
%158 = icmp ne i64* %157, null
br i1 %158, label %161, label %159
159: ; preds = %152
%160 = getelementptr inbounds [1024 x i64], [1024 x i64]* %13, i64 0, i64 0
store i64* %160, i64** %14
store i64 1024, i64* %7
br label %161
161: ; preds = %159, %152
br label %162
162: ; preds = %161, %146
%163 = load i64*, i64** %5
%164 = load i64, i64* %8
%165 = getelementptr inbounds i64, i64* %163, i64 %164
%166 = load i64, i64* %7
%167 = getelementptr inbounds i64, i64* %165, i64 %166
store i64* %167, i64** %11
%168 = load i64*, i64** %14
%169 = load i64, i64* %7
%170 = getelementptr inbounds i64, i64* %168, i64 %169
store i64* %170, i64** %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 i64*, i64** %11
%177 = getelementptr inbounds i64, i64* %176, i32 -1
store i64* %177, i64** %11
%178 = load i64, i64* %177
%179 = load i64*, i64** %12
%180 = getelementptr inbounds i64, i64* %179, i32 -1
store i64* %180, i64** %12
store i64 %178, i64* %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 i64*, i64** %5
%186 = load i64, i64* %8
%187 = getelementptr inbounds i64, i64* %185, i64 %186
%188 = load i64, i64* %7
%189 = getelementptr inbounds i64, i64* %187, i64 %188
store i64* %189, i64** %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 i64*, i64** %11
%198 = getelementptr inbounds i64, i64* %197, i32 -1
store i64* %198, i64** %11
%199 = load i64, i64* %198
%200 = load i64*, i64** %12
%201 = getelementptr inbounds i64, i64* %200, i32 -1
store i64* %201, i64** %12
store i64 %199, i64* %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 i64*, i64** %14
%207 = load i64, i64* %7
%208 = getelementptr inbounds i64, i64* %206, i64 %207
store i64* %208, i64** %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 i64*, i64** %11
%215 = getelementptr inbounds i64, i64* %214, i32 -1
store i64* %215, i64** %11
%216 = load i64, i64* %215
%217 = load i64*, i64** %12
%218 = getelementptr inbounds i64, i64* %217, i32 -1
store i64* %218, i64** %12
store i64 %216, i64* %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 i64*, i64** %14
%232 = getelementptr inbounds [1024 x i64], [1024 x i64]* %13, i64 0, i64 0
%233 = icmp ne i64* %231, %232
br i1 %233, label %234, label %237
234: ; preds = %230
%235 = load i64*, i64** %14
%236 = call i32 @free(i64* %235)
br label %237
237: ; preds = %26, %234, %230
ret void
}

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