#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(void *);
int /*<<< orphan*/ free(void **);
scalar_t__ malloc(size_t);
void ptr_move(void *array, size_t off, size_t n, size_t pos) {
  size_t i, end;
  void **src, **dst;
  void *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 = (void **)malloc(n * sizeof(void *));
        if (!buf) {
          buf = fxd;
          n = 1024;
        }
      }
      src = (void **)array + pos - n;
      dst = buf;
      for (i = n; i > 0; i--)
        *dst++ = *src++;
      dst = (void **)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 = (void **)malloc(n * sizeof(void *));
        if (!buf) {
          buf = fxd;
          n = 1024;
        }
      }
      src = (void **)array + pos + n;
      dst = buf + n;
      for (i = n; i > 0; i--)
        *--dst = *--src;
      dst = (void **)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):
<ptr_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 <ptr_move+0x4c>
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x18(%rbp),%rcx
cmp    %rcx,%rax
jae    117c <ptr_move+0x4c>
jmp    15ab <ptr_move+0x47b>
mov    -0x20(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    11af <ptr_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 <ptr_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 <ptr_move+0x282>
jmp    11f3 <ptr_move+0xc3>
mov    -0x20(%rbp),%rax
cmp    -0x10(%rbp),%rax
jbe    13ad <ptr_move+0x27d>
mov    -0x20(%rbp),%rax
sub    -0x10(%rbp),%rax
mov    %rax,-0x18(%rbp)
cmpq   $0x400,-0x18(%rbp)
jbe    1258 <ptr_move+0x128>
mov    -0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x2048(%rbp)
cmpq   $0x0,-0x2048(%rbp)
jne    1253 <ptr_move+0x123>
lea    -0x2040(%rbp),%rax
mov    %rax,-0x2048(%rbp)
movq   $0x400,-0x18(%rbp)
jmp    1258 <ptr_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 <ptr_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 <ptr_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 <ptr_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 <ptr_move+0x1c7>
mov    -0x2048(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jbe    138a <ptr_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 <ptr_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 <ptr_move+0xc3>
jmp    1588 <ptr_move+0x458>
jmp    13b7 <ptr_move+0x287>
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jbe    1583 <ptr_move+0x453>
mov    -0x30(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %rax,-0x18(%rbp)
cmpq   $0x400,-0x18(%rbp)
jbe    141c <ptr_move+0x2ec>
mov    -0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x2048(%rbp)
cmpq   $0x0,-0x2048(%rbp)
jne    1417 <ptr_move+0x2e7>
lea    -0x2040(%rbp),%rax
mov    %rax,-0x2048(%rbp)
movq   $0x400,-0x18(%rbp)
jmp    141c <ptr_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 <ptr_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 <ptr_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 <ptr_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 <ptr_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 <ptr_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 <ptr_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 <ptr_move+0x287>
jmp    1588 <ptr_move+0x458>
mov    -0x2048(%rbp),%rax
lea    -0x2040(%rbp),%rcx
cmp    %rcx,%rax
je     15ab <ptr_move+0x47b>
mov    -0x2048(%rbp),%rdi
call   1030 <free@plt>
add    $0x2050,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ptr_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 <ptr_move+0x34>
cmp    %r14,%rbx
ja     1d14 <ptr_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 <ptr_move+0x627>
cmp    %r14,%r15
jbe    1d14 <ptr_move+0xbe4>
lea    0x10(%rsp),%r13
mov    %r13,%r11
jmp    11af <ptr_move+0x7f>
nopl   0x0(%rax,%rax,1)
sub    %r12,%r15
sub    %r12,%r10
cmp    %r14,%r15
jbe    1d02 <ptr_move+0xbd2>
mov    %r15,%r12
sub    %r14,%r12
cmp    $0x401,%r12
jb     1200 <ptr_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 <ptr_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 <ptr_move+0x142>
mov    %r11,%rdx
mov    %rax,%rcx
mov    %r12,%rbx
cmp    $0x4,%r12
jb     1350 <ptr_move+0x220>
lea    (%rax,%r12,8),%rcx
cmp    %rcx,%r11
jae    124a <ptr_move+0x11a>
lea    (%r11,%r12,8),%rsi
mov    %r11,%rdx
mov    %rax,%rcx
mov    %r12,%rbx
cmp    %rsi,%rax
jb     1350 <ptr_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 <ptr_move+0x150>
xor    %ebp,%ebp
jmp    12f0 <ptr_move+0x1c0>
mov    $0x1,%r8b
xor    %r12d,%r12d
mov    %rax,%rcx
jmp    13e6 <ptr_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 <ptr_move+0x160>
test   %rcx,%rcx
je     132b <ptr_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 <ptr_move+0x1e0>
lea    (%rax,%rdx,8),%rcx
cmp    %rdx,%r12
je     13e3 <ptr_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 <ptr_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 <ptr_move+0x230>
sub    %rdi,%rbx
cmp    $0x7,%r8
jb     13e3 <ptr_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 <ptr_move+0x260>
xor    %r8d,%r8d
mov    %r10,%rsi
sub    %r15,%rsi
je     1593 <ptr_move+0x463>
cmp    $0x4,%rsi
jb     1500 <ptr_move+0x3d0>
lea    (%rcx,%rsi,8),%rdx
cmp    %rdx,%rax
jae    1412 <ptr_move+0x2e2>
lea    (%rax,%rsi,8),%rdx
cmp    %rdx,%rcx
jb     1500 <ptr_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 <ptr_move+0x307>
xor    %ebp,%ebp
jmp    14a8 <ptr_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 <ptr_move+0x320>
test   %rdx,%rdx
je     14ec <ptr_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 <ptr_move+0x3a0>
lea    (%rax,%r9,8),%rax
cmp    %r9,%rsi
je     1593 <ptr_move+0x463>
and    $0x3,%esi
lea    (%rcx,%r9,8),%rcx
lea    -0x1(%rsi),%rbp
mov    %rsi,%rdx
and    $0x7,%rdx
je     152a <ptr_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 <ptr_move+0x3e0>
sub    %rdi,%rsi
cmp    $0x7,%rbp
jb     1593 <ptr_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 <ptr_move+0x410>
test   %r8b,%r8b
jne    11a0 <ptr_move+0x70>
cmp    $0x4,%r12
jb     15bc <ptr_move+0x48c>
lea    (%r11,%r12,8),%rcx
cmp    %rcx,%rax
jae    166c <ptr_move+0x53c>
lea    (%rax,%r12,8),%rcx
cmp    %rcx,%r11
jae    166c <ptr_move+0x53c>
mov    %r11,%rdx
mov    %r12,%rbp
lea    -0x1(%rbp),%rsi
mov    %rbp,%rcx
and    $0x7,%rcx
je     15fa <ptr_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 <ptr_move+0x4b0>
sub    %rdi,%rbp
cmp    $0x7,%rsi
jb     11a0 <ptr_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 <ptr_move+0x4e0>
jmp    11a0 <ptr_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 <ptr_move+0x561>
xor    %ebp,%ebp
jmp    1700 <ptr_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 <ptr_move+0x570>
test   %rcx,%rcx
je     173b <ptr_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 <ptr_move+0x5f0>
cmp    %rdx,%r12
je     11a0 <ptr_move+0x70>
mov    %r12d,%ebp
and    $0x3,%ebp
lea    (%rax,%rdx,8),%rax
lea    (%r11,%rdx,8),%rdx
jmp    15c2 <ptr_move+0x492>
cmp    %r15,%r10
jbe    1d14 <ptr_move+0xbe4>
lea    0x10(%rsp),%r11
mov    (%rsp),%rax
lea    (%rax,%r10,8),%rax
mov    %rax,0x8(%rsp)
mov    %r10,%r12
jmp    178f <ptr_move+0x65f>
nopw   0x0(%rax,%rax,1)
add    %r13,%r15
add    %r13,%r14
cmp    %r15,%r10
jbe    1d02 <ptr_move+0xbd2>
mov    %r10,%r13
sub    %r15,%r13
cmp    $0x401,%r13
jb     17e0 <ptr_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 <ptr_move+0x6c2>
nopl   0x0(%rax,%rax,1)
lea    (%r11,%r13,8),%rcx
test   %r13,%r13
je     1897 <ptr_move+0x767>
mov    0x8(%rsp),%rbx
mov    %rcx,%rax
mov    %rbx,%rsi
mov    %r13,%r9
cmp    $0x4,%r13
jb     1900 <ptr_move+0x7d0>
lea    0x0(,%r13,8),%rax
mov    %rcx,%rdx
sub    %rax,%rdx
cmp    %rbx,%rdx
jae    1830 <ptr_move+0x700>
mov    %rbx,%rdx
sub    %rax,%rdx
mov    %rcx,%rax
mov    %rbx,%rsi
mov    %r13,%r9
cmp    %rcx,%rdx
jb     1900 <ptr_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 <ptr_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 <ptr_move+0x730>
neg    %rsi
jmp    18ac <ptr_move+0x77c>
mov    $0x1,%r8b
mov    0x8(%rsp),%rsi
mov    %rsi,%rbx
xor    %r13d,%r13d
jmp    1998 <ptr_move+0x868>
xor    %esi,%esi
lea    0x0(,%rax,8),%rbp
test   $0x1,%dl
je     18d9 <ptr_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 <ptr_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 <ptr_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 <ptr_move+0x7e0>
sub    %rbp,%r9
cmp    $0x7,%r8
jb     1995 <ptr_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 <ptr_move+0x810>
xor    %r8d,%r8d
mov    %r15,%rbp
sub    %r14,%rbp
je     1a45 <ptr_move+0x915>
cmp    $0x4,%rbp
jae    1b20 <ptr_move+0x9f0>
lea    -0x1(%rbp),%r9
mov    %rbp,%rdx
and    $0x7,%rdx
je     19dc <ptr_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 <ptr_move+0x890>
sub    %rdi,%rbp
mov    %r12,%r10
cmp    $0x7,%r9
jb     1a45 <ptr_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 <ptr_move+0x8c0>
test   %r8b,%r8b
jne    1780 <ptr_move+0x650>
cmp    $0x4,%r13
jb     1a7a <ptr_move+0x94a>
lea    0x0(,%r13,8),%rax
mov    %rbx,%rdx
sub    %rax,%rdx
cmp    %rcx,%rdx
jae    1bfa <ptr_move+0xaca>
mov    %rcx,%rdx
sub    %rax,%rdx
cmp    %rbx,%rdx
jae    1bfa <ptr_move+0xaca>
mov    %r13,%rax
lea    -0x1(%rax),%rdx
mov    %rax,%rsi
and    $0x7,%rsi
je     1aac <ptr_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 <ptr_move+0x960>
sub    %rdi,%rax
cmp    $0x7,%rdx
jb     1780 <ptr_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 <ptr_move+0x990>
jmp    1780 <ptr_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 <ptr_move+0x87e>
test   %r9b,%r9b
jne    19ae <ptr_move+0x87e>
lea    -0x8(%rsi),%rdx
mov    %rdx,%rdi
sub    %rax,%rdi
cmp    %rdx,%rdi
ja     19ae <ptr_move+0x87e>
test   %r9b,%r9b
jne    19ae <ptr_move+0x87e>
mov    %r14,%rax
sub    %r15,%rax
lea    (%rbx,%rax,8),%rdx
cmp    %rsi,%rdx
jae    1b89 <ptr_move+0xa59>
lea    (%rsi,%rax,8),%rax
cmp    %rbx,%rax
jb     19ae <ptr_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 <ptr_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 <ptr_move+0xa90>
neg    %rax
jmp    1cb1 <ptr_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 <ptr_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 <ptr_move+0xb00>
neg    %rsi
test   $0x1,%al
je     1c89 <ptr_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 <ptr_move+0x650>
shl    $0x3,%rdx
mov    %r13d,%eax
and    $0x3,%eax
sub    %rdx,%rbx
sub    %rdx,%rcx
jmp    1a7d <ptr_move+0x94d>
xor    %esi,%esi
test   $0x1,%al
jne    1c69 <ptr_move+0xb39>
jmp    1c89 <ptr_move+0xb59>
xor    %eax,%eax
lea    0x0(,%r9,8),%r10
test   $0x1,%dl
je     1cde <ptr_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 <ptr_move+0xbc7>
mov    %r12,%r10
test   %r8b,%r8b
jne    1780 <ptr_move+0x650>
jmp    1a4e <ptr_move+0x91e>
and    $0x3,%ebp
sub    %r10,%rsi
jmp    19ae <ptr_move+0x87e>
lea    0x10(%rsp),%rax
cmp    %rax,%r11
je     1d14 <ptr_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 @ptr_move(i8* %0, i64 %1, i64 %2, i64 %3) {
%5 = alloca i8*
%6 = alloca i64
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64
%11 = alloca i8**
%12 = alloca i8**
%13 = alloca [1024 x i8*]
%14 = alloca i8**
store i8* %0, i8** %5
store i64 %1, i64* %6
store i64 %2, i64* %7
store i64 %3, i64* %8
%15 = load i8*, i8** %5
%16 = call i32 @assert(i8* %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 %241
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 i8*], [1024 x i8*]* %13, i64 0, i64 0
store i8** %46, i8*** %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 %143
54: ; preds = %45
br label %55
55: ; preds = %135, %54
%56 = load i64, i64* %8
%57 = load i64, i64* %6
%58 = icmp ugt i64 %56, %57
br i1 %58, label %59, label %142
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 i8**
store i8** %69, i8*** %14
%70 = load i8**, i8*** %14
%71 = icmp ne i8** %70, null
br i1 %71, label %74, label %72
72: ; preds = %65
%73 = getelementptr inbounds [1024 x i8*], [1024 x i8*]* %13, i64 0, i64 0
store i8** %73, i8*** %14
store i64 1024, i64* %7
br label %74
74: ; preds = %72, %65
br label %75
75: ; preds = %74, %59
%76 = load i8*, i8** %5
%77 = bitcast i8* %76 to i8**
%78 = load i64, i64* %8
%79 = getelementptr inbounds i8*, i8** %77, i64 %78
%80 = load i64, i64* %7
%81 = sub i64 0, %80
%82 = getelementptr inbounds i8*, i8** %79, i64 %81
store i8** %82, i8*** %11
%83 = load i8**, i8*** %14
store i8** %83, i8*** %12
%84 = load i64, i64* %7
store i64 %84, i64* %9
br label %85
85: ; preds = %94, %75
%86 = load i64, i64* %9
%87 = icmp ugt i64 %86, 0
br i1 %87, label %88, label %97
88: ; preds = %85
%89 = load i8**, i8*** %11
%90 = getelementptr inbounds i8*, i8** %89, i32 1
store i8** %90, i8*** %11
%91 = load i8*, i8** %89
%92 = load i8**, i8*** %12
%93 = getelementptr inbounds i8*, i8** %92, i32 1
store i8** %93, i8*** %12
store i8* %91, i8** %92
br label %94
94: ; preds = %88
%95 = load i64, i64* %9
%96 = add i64 %95, -1
store i64 %96, i64* %9
br label %85
97: ; preds = %85
%98 = load i8*, i8** %5
%99 = bitcast i8* %98 to i8**
%100 = load i64, i64* %8
%101 = getelementptr inbounds i8*, i8** %99, i64 %100
%102 = load i64, i64* %7
%103 = sub i64 0, %102
%104 = getelementptr inbounds i8*, i8** %101, i64 %103
store i8** %104, i8*** %12
%105 = load i64, i64* %10
%106 = load i64, i64* %8
%107 = sub i64 %105, %106
store i64 %107, i64* %9
br label %108
108: ; preds = %117, %97
%109 = load i64, i64* %9
%110 = icmp ugt i64 %109, 0
br i1 %110, label %111, label %120
111: ; preds = %108
%112 = load i8**, i8*** %11
%113 = getelementptr inbounds i8*, i8** %112, i32 1
store i8** %113, i8*** %11
%114 = load i8*, i8** %112
%115 = load i8**, i8*** %12
%116 = getelementptr inbounds i8*, i8** %115, i32 1
store i8** %116, i8*** %12
store i8* %114, i8** %115
br label %117
117: ; preds = %111
%118 = load i64, i64* %9
%119 = add i64 %118, -1
store i64 %119, i64* %9
br label %108
120: ; preds = %108
%121 = load i8**, i8*** %14
store i8** %121, i8*** %11
%122 = load i64, i64* %7
store i64 %122, i64* %9
br label %123
123: ; preds = %132, %120
%124 = load i64, i64* %9
%125 = icmp ugt i64 %124, 0
br i1 %125, label %126, label %135
126: ; preds = %123
%127 = load i8**, i8*** %11
%128 = getelementptr inbounds i8*, i8** %127, i32 1
store i8** %128, i8*** %11
%129 = load i8*, i8** %127
%130 = load i8**, i8*** %12
%131 = getelementptr inbounds i8*, i8** %130, i32 1
store i8** %131, i8*** %12
store i8* %129, i8** %130
br label %132
132: ; preds = %126
%133 = load i64, i64* %9
%134 = add i64 %133, -1
store i64 %134, i64* %9
br label %123
135: ; preds = %123
%136 = load i64, i64* %7
%137 = load i64, i64* %8
%138 = sub i64 %137, %136
store i64 %138, i64* %8
%139 = load i64, i64* %7
%140 = load i64, i64* %10
%141 = sub i64 %140, %139
store i64 %141, i64* %10
br label %55
142: ; preds = %55
br label %234
143: ; preds = %45
br label %144
144: ; preds = %226, %143
%145 = load i64, i64* %10
%146 = load i64, i64* %8
%147 = icmp ugt i64 %145, %146
br i1 %147, label %148, label %233
148: ; preds = %144
%149 = load i64, i64* %10
%150 = load i64, i64* %8
%151 = sub i64 %149, %150
store i64 %151, i64* %7
%152 = load i64, i64* %7
%153 = icmp ugt i64 %152, 1024
br i1 %153, label %154, label %164
154: ; preds = %148
%155 = load i64, i64* %7
%156 = mul i64 %155, 8
%157 = call i64 @malloc(i64 %156)
%158 = inttoptr i64 %157 to i8**
store i8** %158, i8*** %14
%159 = load i8**, i8*** %14
%160 = icmp ne i8** %159, null
br i1 %160, label %163, label %161
161: ; preds = %154
%162 = getelementptr inbounds [1024 x i8*], [1024 x i8*]* %13, i64 0, i64 0
store i8** %162, i8*** %14
store i64 1024, i64* %7
br label %163
163: ; preds = %161, %154
br label %164
164: ; preds = %163, %148
%165 = load i8*, i8** %5
%166 = bitcast i8* %165 to i8**
%167 = load i64, i64* %8
%168 = getelementptr inbounds i8*, i8** %166, i64 %167
%169 = load i64, i64* %7
%170 = getelementptr inbounds i8*, i8** %168, i64 %169
store i8** %170, i8*** %11
%171 = load i8**, i8*** %14
%172 = load i64, i64* %7
%173 = getelementptr inbounds i8*, i8** %171, i64 %172
store i8** %173, i8*** %12
%174 = load i64, i64* %7
store i64 %174, i64* %9
br label %175
175: ; preds = %184, %164
%176 = load i64, i64* %9
%177 = icmp ugt i64 %176, 0
br i1 %177, label %178, label %187
178: ; preds = %175
%179 = load i8**, i8*** %11
%180 = getelementptr inbounds i8*, i8** %179, i32 -1
store i8** %180, i8*** %11
%181 = load i8*, i8** %180
%182 = load i8**, i8*** %12
%183 = getelementptr inbounds i8*, i8** %182, i32 -1
store i8** %183, i8*** %12
store i8* %181, i8** %183
br label %184
184: ; preds = %178
%185 = load i64, i64* %9
%186 = add i64 %185, -1
store i64 %186, i64* %9
br label %175
187: ; preds = %175
%188 = load i8*, i8** %5
%189 = bitcast i8* %188 to i8**
%190 = load i64, i64* %8
%191 = getelementptr inbounds i8*, i8** %189, i64 %190
%192 = load i64, i64* %7
%193 = getelementptr inbounds i8*, i8** %191, i64 %192
store i8** %193, i8*** %12
%194 = load i64, i64* %8
%195 = load i64, i64* %6
%196 = sub i64 %194, %195
store i64 %196, i64* %9
br label %197
197: ; preds = %206, %187
%198 = load i64, i64* %9
%199 = icmp ugt i64 %198, 0
br i1 %199, label %200, label %209
200: ; preds = %197
%201 = load i8**, i8*** %11
%202 = getelementptr inbounds i8*, i8** %201, i32 -1
store i8** %202, i8*** %11
%203 = load i8*, i8** %202
%204 = load i8**, i8*** %12
%205 = getelementptr inbounds i8*, i8** %204, i32 -1
store i8** %205, i8*** %12
store i8* %203, i8** %205
br label %206
206: ; preds = %200
%207 = load i64, i64* %9
%208 = add i64 %207, -1
store i64 %208, i64* %9
br label %197
209: ; preds = %197
%210 = load i8**, i8*** %14
%211 = load i64, i64* %7
%212 = getelementptr inbounds i8*, i8** %210, i64 %211
store i8** %212, i8*** %11
%213 = load i64, i64* %7
store i64 %213, i64* %9
br label %214
214: ; preds = %223, %209
%215 = load i64, i64* %9
%216 = icmp ugt i64 %215, 0
br i1 %216, label %217, label %226
217: ; preds = %214
%218 = load i8**, i8*** %11
%219 = getelementptr inbounds i8*, i8** %218, i32 -1
store i8** %219, i8*** %11
%220 = load i8*, i8** %219
%221 = load i8**, i8*** %12
%222 = getelementptr inbounds i8*, i8** %221, i32 -1
store i8** %222, i8*** %12
store i8* %220, i8** %222
br label %223
223: ; preds = %217
%224 = load i64, i64* %9
%225 = add i64 %224, -1
store i64 %225, i64* %9
br label %214
226: ; preds = %214
%227 = load i64, i64* %7
%228 = load i64, i64* %8
%229 = add i64 %228, %227
store i64 %229, i64* %8
%230 = load i64, i64* %7
%231 = load i64, i64* %6
%232 = add i64 %231, %230
store i64 %232, i64* %6
br label %144
233: ; preds = %144
br label %234
234: ; preds = %233, %142
%235 = load i8**, i8*** %14
%236 = getelementptr inbounds [1024 x i8*], [1024 x i8*]* %13, i64 0, i64 0
%237 = icmp ne i8** %235, %236
br i1 %237, label %238, label %241
238: ; preds = %234
%239 = load i8**, i8*** %14
%240 = call i32 @free(i8** %239)
br label %241
241: ; preds = %26, %238, %234
ret void
}

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