#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(int *);
int /*<<< orphan*/ free(int *);
scalar_t__ malloc(size_t);
void int_move(int *array, size_t off, size_t n, size_t pos) {
  size_t i, end;
  int *src, *dst;
  int 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 = (int *)malloc(n * sizeof(int));
        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 = (int *)malloc(n * sizeof(int));
        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):
<int_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 <int_move+0x4c>
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x18(%rbp),%rcx
cmp    %rcx,%rax
jae    117c <int_move+0x4c>
jmp    159f <int_move+0x46f>
mov    -0x20(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    11af <int_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 <int_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    13ac <int_move+0x27c>
jmp    11f3 <int_move+0xc3>
mov    -0x20(%rbp),%rax
cmp    -0x10(%rbp),%rax
jbe    13a7 <int_move+0x277>
mov    -0x20(%rbp),%rax
sub    -0x10(%rbp),%rax
mov    %rax,-0x18(%rbp)
cmpq   $0x400,-0x18(%rbp)
jbe    1258 <int_move+0x128>
mov    -0x18(%rbp),%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x1048(%rbp)
cmpq   $0x0,-0x1048(%rbp)
jne    1253 <int_move+0x123>
lea    -0x1040(%rbp),%rax
mov    %rax,-0x1048(%rbp)
movq   $0x400,-0x18(%rbp)
jmp    1258 <int_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    12c9 <int_move+0x199>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%ecx
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x40(%rbp)
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    128b <int_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    1333 <int_move+0x203>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%ecx
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x40(%rbp)
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    12f5 <int_move+0x1c5>
mov    -0x1048(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jbe    1384 <int_move+0x254>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%ecx
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x40(%rbp)
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    1346 <int_move+0x216>
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 <int_move+0xc3>
jmp    157c <int_move+0x44c>
jmp    13b1 <int_move+0x281>
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jbe    1577 <int_move+0x447>
mov    -0x30(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %rax,-0x18(%rbp)
cmpq   $0x400,-0x18(%rbp)
jbe    1416 <int_move+0x2e6>
mov    -0x18(%rbp),%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x1048(%rbp)
cmpq   $0x0,-0x1048(%rbp)
jne    1411 <int_move+0x2e1>
lea    -0x1040(%rbp),%rax
mov    %rax,-0x1048(%rbp)
movq   $0x400,-0x18(%rbp)
jmp    1416 <int_move+0x2e6>
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    1492 <int_move+0x362>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
mov    -0x4(%rax),%ecx
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x40(%rbp)
mov    %ecx,-0x4(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    1452 <int_move+0x322>
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    14fc <int_move+0x3cc>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
mov    -0x4(%rax),%ecx
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x40(%rbp)
mov    %ecx,-0x4(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    14bc <int_move+0x38c>
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    155a <int_move+0x42a>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
mov    -0x4(%rax),%ecx
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x40(%rbp)
mov    %ecx,-0x4(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    151a <int_move+0x3ea>
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    13b1 <int_move+0x281>
jmp    157c <int_move+0x44c>
mov    -0x1048(%rbp),%rax
lea    -0x1040(%rbp),%rcx
cmp    %rcx,%rax
je     159f <int_move+0x46f>
mov    -0x1048(%rbp),%rdi
call   1030 <free@plt>
add    $0x1050,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<int_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 <int_move+0x34>
cmp    %r14,%rbx
ja     1c84 <int_move+0xb54>
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    16f7 <int_move+0x5c7>
cmp    %r14,%r15
jbe    1c84 <int_move+0xb54>
lea    0x10(%rsp),%r13
mov    %r13,%r11
jmp    11af <int_move+0x7f>
nopl   0x0(%rax,%rax,1)
sub    %r12,%r15
sub    %r12,%r10
cmp    %r14,%r15
jbe    1c72 <int_move+0xb42>
mov    %r15,%r12
sub    %r14,%r12
cmp    $0x401,%r12
jb     1200 <int_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 <int_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 <int_move+0x142>
mov    %r11,%rdx
mov    %rax,%rcx
mov    %r12,%rbx
cmp    $0x8,%r12
jb     1340 <int_move+0x210>
lea    (%rax,%r12,4),%rcx
cmp    %rcx,%r11
jae    124a <int_move+0x11a>
lea    (%r11,%r12,4),%rsi
mov    %r11,%rdx
mov    %rax,%rcx
mov    %r12,%rbx
cmp    %rsi,%rax
jb     1340 <int_move+0x210>
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 <int_move+0x150>
xor    %ebp,%ebp
jmp    12f0 <int_move+0x1c0>
mov    $0x1,%r8b
xor    %r12d,%r12d
mov    %rax,%rcx
jmp    13b6 <int_move+0x286>
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 <int_move+0x160>
test   %rcx,%rcx
je     132b <int_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 <int_move+0x1e0>
lea    (%rax,%rdx,4),%rcx
cmp    %rdx,%r12
je     13b3 <int_move+0x283>
mov    %r12d,%ebx
and    $0x7,%ebx
lea    (%r11,%rdx,4),%rdx
xchg   %ax,%ax
lea    -0x1(%rbx),%r8
mov    %rbx,%rsi
and    $0x7,%rsi
je     1368 <int_move+0x238>
xor    %edi,%edi
nop
mov    (%rcx),%ebp
add    $0x4,%rcx
mov    %ebp,(%rdx)
add    $0x4,%rdx
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    1350 <int_move+0x220>
sub    %rdi,%rbx
cmp    $0x7,%r8
jb     13b3 <int_move+0x283>
xor    %ebp,%ebp
mov    (%rcx),%esi
mov    %esi,(%rdx,%rbp,4)
mov    0x4(%rcx),%esi
mov    %esi,0x4(%rdx,%rbp,4)
mov    0x8(%rcx),%esi
mov    %esi,0x8(%rdx,%rbp,4)
mov    0xc(%rcx),%esi
mov    %esi,0xc(%rdx,%rbp,4)
mov    0x10(%rcx),%esi
mov    %esi,0x10(%rdx,%rbp,4)
mov    0x14(%rcx),%esi
mov    %esi,0x14(%rdx,%rbp,4)
mov    0x18(%rcx),%esi
mov    %esi,0x18(%rdx,%rbp,4)
mov    0x1c(%rcx),%esi
add    $0x20,%rcx
mov    %esi,0x1c(%rdx,%rbp,4)
add    $0x8,%rbp
cmp    %rbp,%rbx
jne    1370 <int_move+0x240>
xor    %r8d,%r8d
mov    %r10,%rsi
sub    %r15,%rsi
je     1543 <int_move+0x413>
cmp    $0x8,%rsi
jb     14d0 <int_move+0x3a0>
lea    (%rcx,%rsi,4),%rdx
cmp    %rdx,%rax
jae    13e2 <int_move+0x2b2>
lea    (%rax,%rsi,4),%rdx
cmp    %rdx,%rcx
jb     14d0 <int_move+0x3a0>
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    1407 <int_move+0x2d7>
xor    %ebp,%ebp
jmp    1478 <int_move+0x348>
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    1420 <int_move+0x2f0>
test   %rdx,%rdx
je     14bc <int_move+0x38c>
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    14a0 <int_move+0x370>
lea    (%rax,%r9,4),%rax
cmp    %r9,%rsi
je     1543 <int_move+0x413>
and    $0x7,%esi
lea    (%rcx,%r9,4),%rcx
nopl   0x0(%rax)
lea    -0x1(%rsi),%rbp
mov    %rsi,%rdx
and    $0x7,%rdx
je     14f8 <int_move+0x3c8>
xor    %edi,%edi
nop
mov    (%rcx),%ebx
add    $0x4,%rcx
mov    %ebx,(%rax)
add    $0x4,%rax
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    14e0 <int_move+0x3b0>
sub    %rdi,%rsi
cmp    $0x7,%rbp
jb     1543 <int_move+0x413>
xor    %edx,%edx
mov    (%rcx,%rdx,4),%edi
mov    %edi,(%rax)
mov    0x4(%rcx,%rdx,4),%edi
mov    %edi,0x4(%rax)
mov    0x8(%rcx,%rdx,4),%edi
mov    %edi,0x8(%rax)
mov    0xc(%rcx,%rdx,4),%edi
mov    %edi,0xc(%rax)
mov    0x10(%rcx,%rdx,4),%edi
mov    %edi,0x10(%rax)
mov    0x14(%rcx,%rdx,4),%edi
mov    %edi,0x14(%rax)
mov    0x18(%rcx,%rdx,4),%edi
mov    %edi,0x18(%rax)
mov    0x1c(%rcx,%rdx,4),%edi
mov    %edi,0x1c(%rax)
add    $0x20,%rax
add    $0x8,%rdx
cmp    %rdx,%rsi
jne    1500 <int_move+0x3d0>
test   %r8b,%r8b
jne    11a0 <int_move+0x70>
cmp    $0x8,%r12
jb     156c <int_move+0x43c>
lea    (%r11,%r12,4),%rcx
cmp    %rcx,%rax
jae    160c <int_move+0x4dc>
lea    (%rax,%r12,4),%rcx
cmp    %rcx,%r11
jae    160c <int_move+0x4dc>
mov    %r11,%rdx
mov    %r12,%rbp
lea    -0x1(%rbp),%rsi
mov    %rbp,%rcx
and    $0x7,%rcx
je     15a8 <int_move+0x478>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rdx),%ebx
add    $0x4,%rdx
mov    %ebx,(%rax)
add    $0x4,%rax
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    1590 <int_move+0x460>
sub    %rdi,%rbp
cmp    $0x7,%rsi
jb     11a0 <int_move+0x70>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rdx,%rcx,4),%esi
mov    %esi,(%rax,%rcx,4)
mov    0x4(%rdx,%rcx,4),%esi
mov    %esi,0x4(%rax,%rcx,4)
mov    0x8(%rdx,%rcx,4),%esi
mov    %esi,0x8(%rax,%rcx,4)
mov    0xc(%rdx,%rcx,4),%esi
mov    %esi,0xc(%rax,%rcx,4)
mov    0x10(%rdx,%rcx,4),%esi
mov    %esi,0x10(%rax,%rcx,4)
mov    0x14(%rdx,%rcx,4),%esi
mov    %esi,0x14(%rax,%rcx,4)
mov    0x18(%rdx,%rcx,4),%esi
mov    %esi,0x18(%rax,%rcx,4)
mov    0x1c(%rdx,%rcx,4),%esi
mov    %esi,0x1c(%rax,%rcx,4)
add    $0x8,%rcx
cmp    %rcx,%rbp
jne    15c0 <int_move+0x490>
jmp    11a0 <int_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    1631 <int_move+0x501>
xor    %ebp,%ebp
jmp    16a0 <int_move+0x570>
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    1640 <int_move+0x510>
test   %rcx,%rcx
je     16db <int_move+0x5ab>
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    16c0 <int_move+0x590>
cmp    %rdx,%r12
je     11a0 <int_move+0x70>
mov    %r12d,%ebp
and    $0x7,%ebp
lea    (%rax,%rdx,4),%rax
lea    (%r11,%rdx,4),%rdx
jmp    1572 <int_move+0x442>
cmp    %r15,%r10
jbe    1c84 <int_move+0xb54>
lea    0x10(%rsp),%r11
mov    (%rsp),%rax
lea    (%rax,%r10,4),%rax
mov    %rax,0x8(%rsp)
mov    %r10,%r12
jmp    172f <int_move+0x5ff>
nopw   0x0(%rax,%rax,1)
add    %r13,%r15
add    %r13,%r14
cmp    %r15,%r10
jbe    1c72 <int_move+0xb42>
mov    %r10,%r13
sub    %r15,%r13
cmp    $0x401,%r13
jb     1780 <int_move+0x650>
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    1792 <int_move+0x662>
nopl   0x0(%rax,%rax,1)
lea    (%r11,%r13,4),%rcx
test   %r13,%r13
je     1837 <int_move+0x707>
mov    0x8(%rsp),%rbx
mov    %rcx,%rax
mov    %rbx,%rsi
mov    %r13,%r9
cmp    $0x8,%r13
jb     18a0 <int_move+0x770>
lea    0x0(,%r13,4),%rax
mov    %rcx,%rdx
sub    %rax,%rdx
cmp    %rbx,%rdx
jae    17d0 <int_move+0x6a0>
mov    %rbx,%rdx
sub    %rax,%rdx
mov    %rcx,%rax
mov    %rbx,%rsi
mov    %r13,%r9
cmp    %rcx,%rdx
jb     18a0 <int_move+0x770>
mov    %r13,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     184a <int_move+0x71a>
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    1800 <int_move+0x6d0>
neg    %rsi
jmp    184c <int_move+0x71c>
mov    $0x1,%r8b
mov    0x8(%rsp),%rsi
mov    %rsi,%rbx
xor    %r13d,%r13d
jmp    1928 <int_move+0x7f8>
xor    %esi,%esi
lea    0x0(,%rax,4),%rbp
test   $0x1,%dl
je     1879 <int_move+0x749>
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     1925 <int_move+0x7f5>
mov    %r13d,%r9d
and    $0x7,%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     18ca <int_move+0x79a>
xor    %ebp,%ebp
nop
mov    -0x4(%rsi),%edi
add    $0xfffffffffffffffc,%rsi
mov    %edi,-0x4(%rax)
add    $0xfffffffffffffffc,%rax
add    $0x1,%rbp
cmp    %rbp,%rdx
jne    18b0 <int_move+0x780>
sub    %rbp,%r9
cmp    $0x7,%r8
jb     1925 <int_move+0x7f5>
neg    %r9
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x4(%rsi),%edx
mov    %edx,-0x4(%rax,%rbp,4)
mov    -0x8(%rsi),%edx
mov    %edx,-0x8(%rax,%rbp,4)
mov    -0xc(%rsi),%edx
mov    %edx,-0xc(%rax,%rbp,4)
mov    -0x10(%rsi),%edx
mov    %edx,-0x10(%rax,%rbp,4)
mov    -0x14(%rsi),%edx
mov    %edx,-0x14(%rax,%rbp,4)
mov    -0x18(%rsi),%edx
mov    %edx,-0x18(%rax,%rbp,4)
mov    -0x1c(%rsi),%edx
mov    %edx,-0x1c(%rax,%rbp,4)
mov    -0x20(%rsi),%edx
add    $0xffffffffffffffe0,%rsi
mov    %edx,-0x20(%rax,%rbp,4)
add    $0xfffffffffffffff8,%rbp
cmp    %rbp,%r9
jne    18e0 <int_move+0x7b0>
xor    %r8d,%r8d
mov    %r15,%rbp
sub    %r14,%rbp
je     19c5 <int_move+0x895>
cmp    $0x8,%rbp
jae    1a90 <int_move+0x960>
lea    -0x1(%rbp),%r9
mov    %rbp,%rdx
and    $0x7,%rdx
je     196a <int_move+0x83a>
xor    %edi,%edi
nopl   (%rax)
mov    -0x4(%rsi),%eax
add    $0xfffffffffffffffc,%rsi
mov    %eax,-0x4(%rbx)
add    $0xfffffffffffffffc,%rbx
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    1950 <int_move+0x820>
sub    %rdi,%rbp
mov    %r12,%r10
cmp    $0x7,%r9
jb     19c5 <int_move+0x895>
neg    %rbp
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
mov    -0x4(%rsi,%rax,4),%edx
mov    %edx,-0x4(%rbx)
mov    -0x8(%rsi,%rax,4),%edx
mov    %edx,-0x8(%rbx)
mov    -0xc(%rsi,%rax,4),%edx
mov    %edx,-0xc(%rbx)
mov    -0x10(%rsi,%rax,4),%edx
mov    %edx,-0x10(%rbx)
mov    -0x14(%rsi,%rax,4),%edx
mov    %edx,-0x14(%rbx)
mov    -0x18(%rsi,%rax,4),%edx
mov    %edx,-0x18(%rbx)
mov    -0x1c(%rsi,%rax,4),%edx
mov    %edx,-0x1c(%rbx)
mov    -0x20(%rsi,%rax,4),%edx
mov    %edx,-0x20(%rbx)
add    $0xffffffffffffffe0,%rbx
add    $0xfffffffffffffff8,%rax
cmp    %rax,%rbp
jne    1980 <int_move+0x850>
test   %r8b,%r8b
jne    1720 <int_move+0x5f0>
cmp    $0x8,%r13
jb     19fa <int_move+0x8ca>
lea    0x0(,%r13,4),%rax
mov    %rbx,%rdx
sub    %rax,%rdx
cmp    %rcx,%rdx
jae    1b6a <int_move+0xa3a>
mov    %rcx,%rdx
sub    %rax,%rdx
cmp    %rbx,%rdx
jae    1b6a <int_move+0xa3a>
mov    %r13,%rax
lea    -0x1(%rax),%rdx
mov    %rax,%rsi
and    $0x7,%rsi
je     1a2a <int_move+0x8fa>
xor    %edi,%edi
nopl   0x0(%rax)
mov    -0x4(%rcx),%ebp
add    $0xfffffffffffffffc,%rcx
mov    %ebp,-0x4(%rbx)
add    $0xfffffffffffffffc,%rbx
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    1a10 <int_move+0x8e0>
sub    %rdi,%rax
cmp    $0x7,%rdx
jb     1720 <int_move+0x5f0>
neg    %rax
xor    %edx,%edx
nopl   0x0(%rax)
mov    -0x4(%rcx,%rdx,4),%esi
mov    %esi,-0x4(%rbx,%rdx,4)
mov    -0x8(%rcx,%rdx,4),%esi
mov    %esi,-0x8(%rbx,%rdx,4)
mov    -0xc(%rcx,%rdx,4),%esi
mov    %esi,-0xc(%rbx,%rdx,4)
mov    -0x10(%rcx,%rdx,4),%esi
mov    %esi,-0x10(%rbx,%rdx,4)
mov    -0x14(%rcx,%rdx,4),%esi
mov    %esi,-0x14(%rbx,%rdx,4)
mov    -0x18(%rcx,%rdx,4),%esi
mov    %esi,-0x18(%rbx,%rdx,4)
mov    -0x1c(%rcx,%rdx,4),%esi
mov    %esi,-0x1c(%rbx,%rdx,4)
mov    -0x20(%rcx,%rdx,4),%esi
mov    %esi,-0x20(%rbx,%rdx,4)
add    $0xfffffffffffffff8,%rdx
cmp    %rdx,%rax
jne    1a40 <int_move+0x910>
jmp    1720 <int_move+0x5f0>
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     193e <int_move+0x80e>
test   %r9b,%r9b
jne    193e <int_move+0x80e>
lea    -0x4(%rsi),%rdx
mov    %rdx,%rdi
sub    %rax,%rdi
cmp    %rdx,%rdi
ja     193e <int_move+0x80e>
test   %r9b,%r9b
jne    193e <int_move+0x80e>
mov    %r14,%rax
sub    %r15,%rax
lea    (%rbx,%rax,4),%rdx
cmp    %rsi,%rdx
jae    1af9 <int_move+0x9c9>
lea    (%rsi,%rax,4),%rax
cmp    %rbx,%rax
jb     193e <int_move+0x80e>
mov    %rbp,%r9
and    $0xfffffffffffffff8,%r9
lea    -0x8(%r9),%rax
mov    %rax,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rax,%rax
je     1c1f <int_move+0xaef>
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    1b30 <int_move+0xa00>
neg    %rax
jmp    1c21 <int_move+0xaf1>
mov    %r13,%rdx
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%rsi
mov    %rsi,%rax
shr    $0x3,%rax
add    $0x1,%rax
test   %rsi,%rsi
je     1c17 <int_move+0xae7>
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    1ba0 <int_move+0xa70>
neg    %rsi
test   $0x1,%al
je     1bf9 <int_move+0xac9>
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     1720 <int_move+0x5f0>
shl    $0x2,%rdx
mov    %r13d,%eax
and    $0x7,%eax
sub    %rdx,%rbx
sub    %rdx,%rcx
jmp    19fd <int_move+0x8cd>
xor    %esi,%esi
test   $0x1,%al
jne    1bd9 <int_move+0xaa9>
jmp    1bf9 <int_move+0xac9>
xor    %eax,%eax
lea    0x0(,%r9,4),%r10
test   $0x1,%dl
je     1c4e <int_move+0xb1e>
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    1c67 <int_move+0xb37>
mov    %r12,%r10
test   %r8b,%r8b
jne    1720 <int_move+0x5f0>
jmp    19ce <int_move+0x89e>
and    $0x7,%ebp
sub    %r10,%rsi
jmp    193e <int_move+0x80e>
lea    0x10(%rsp),%rax
cmp    %rax,%r11
je     1c84 <int_move+0xb54>
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 @int_move(i32* %0, i64 %1, i64 %2, i64 %3) {
%5 = alloca i32*
%6 = alloca i64
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64
%11 = alloca i32*
%12 = alloca i32*
%13 = alloca [1024 x i32]
%14 = alloca i32*
store i32* %0, i32** %5
store i64 %1, i64* %6
store i64 %2, i64* %7
store i64 %3, i64* %8
%15 = load i32*, i32** %5
%16 = call i32 @assert(i32* %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 i32], [1024 x i32]* %13, i64 0, i64 0
store i32* %46, i32** %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 i32*
store i32* %69, i32** %14
%70 = load i32*, i32** %14
%71 = icmp ne i32* %70, null
br i1 %71, label %74, label %72
72: ; preds = %65
%73 = getelementptr inbounds [1024 x i32], [1024 x i32]* %13, i64 0, i64 0
store i32* %73, i32** %14
store i64 1024, i64* %7
br label %74
74: ; preds = %72, %65
br label %75
75: ; preds = %74, %59
%76 = load i32*, i32** %5
%77 = load i64, i64* %8
%78 = getelementptr inbounds i32, i32* %76, i64 %77
%79 = load i64, i64* %7
%80 = sub i64 0, %79
%81 = getelementptr inbounds i32, i32* %78, i64 %80
store i32* %81, i32** %11
%82 = load i32*, i32** %14
store i32* %82, i32** %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 i32*, i32** %11
%89 = getelementptr inbounds i32, i32* %88, i32 1
store i32* %89, i32** %11
%90 = load i32, i32* %88
%91 = load i32*, i32** %12
%92 = getelementptr inbounds i32, i32* %91, i32 1
store i32* %92, i32** %12
store i32 %90, i32* %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 i32*, i32** %5
%98 = load i64, i64* %8
%99 = getelementptr inbounds i32, i32* %97, i64 %98
%100 = load i64, i64* %7
%101 = sub i64 0, %100
%102 = getelementptr inbounds i32, i32* %99, i64 %101
store i32* %102, i32** %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 i32*, i32** %11
%111 = getelementptr inbounds i32, i32* %110, i32 1
store i32* %111, i32** %11
%112 = load i32, i32* %110
%113 = load i32*, i32** %12
%114 = getelementptr inbounds i32, i32* %113, i32 1
store i32* %114, i32** %12
store i32 %112, i32* %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 i32*, i32** %14
store i32* %119, i32** %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 i32*, i32** %11
%126 = getelementptr inbounds i32, i32* %125, i32 1
store i32* %126, i32** %11
%127 = load i32, i32* %125
%128 = load i32*, i32** %12
%129 = getelementptr inbounds i32, i32* %128, i32 1
store i32* %129, i32** %12
store i32 %127, i32* %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 i32*
store i32* %156, i32** %14
%157 = load i32*, i32** %14
%158 = icmp ne i32* %157, null
br i1 %158, label %161, label %159
159: ; preds = %152
%160 = getelementptr inbounds [1024 x i32], [1024 x i32]* %13, i64 0, i64 0
store i32* %160, i32** %14
store i64 1024, i64* %7
br label %161
161: ; preds = %159, %152
br label %162
162: ; preds = %161, %146
%163 = load i32*, i32** %5
%164 = load i64, i64* %8
%165 = getelementptr inbounds i32, i32* %163, i64 %164
%166 = load i64, i64* %7
%167 = getelementptr inbounds i32, i32* %165, i64 %166
store i32* %167, i32** %11
%168 = load i32*, i32** %14
%169 = load i64, i64* %7
%170 = getelementptr inbounds i32, i32* %168, i64 %169
store i32* %170, i32** %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 i32*, i32** %11
%177 = getelementptr inbounds i32, i32* %176, i32 -1
store i32* %177, i32** %11
%178 = load i32, i32* %177
%179 = load i32*, i32** %12
%180 = getelementptr inbounds i32, i32* %179, i32 -1
store i32* %180, i32** %12
store i32 %178, i32* %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 i32*, i32** %5
%186 = load i64, i64* %8
%187 = getelementptr inbounds i32, i32* %185, i64 %186
%188 = load i64, i64* %7
%189 = getelementptr inbounds i32, i32* %187, i64 %188
store i32* %189, i32** %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 i32*, i32** %11
%198 = getelementptr inbounds i32, i32* %197, i32 -1
store i32* %198, i32** %11
%199 = load i32, i32* %198
%200 = load i32*, i32** %12
%201 = getelementptr inbounds i32, i32* %200, i32 -1
store i32* %201, i32** %12
store i32 %199, i32* %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 i32*, i32** %14
%207 = load i64, i64* %7
%208 = getelementptr inbounds i32, i32* %206, i64 %207
store i32* %208, i32** %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 i32*, i32** %11
%215 = getelementptr inbounds i32, i32* %214, i32 -1
store i32* %215, i32** %11
%216 = load i32, i32* %215
%217 = load i32*, i32** %12
%218 = getelementptr inbounds i32, i32* %217, i32 -1
store i32* %218, i32** %12
store i32 %216, i32* %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 i32*, i32** %14
%232 = getelementptr inbounds [1024 x i32], [1024 x i32]* %13, i64 0, i64 0
%233 = icmp ne i32* %231, %232
br i1 %233, label %234, label %237
234: ; preds = %230
%235 = load i32*, i32** %14
%236 = call i32 @free(i32* %235)
br label %237
237: ; preds = %26, %234, %230
ret void
}

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