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

x86 assembly (clang, -O2):
<sht_move>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x828,%rsp
mov    %rcx,%r14
mov    %rdx,%rbx
mov    %rsi,%r15
mov    %rdi,0x8(%rsp)
call   1040 <assert@plt>
add    %r15,%rbx
cmp    %r15,%r14
jb     1165 <sht_move+0x35>
cmp    %r14,%rbx
ja     1d0e <sht_move+0xbde>
lea    0x1(%r14),%r11
cmp    %r15,%r14
cmovae %r15,%r14
cmovae %rbx,%r15
cmovb  %rbx,%r11
lea    (%r15,%r15,1),%rax
lea    (%r11,%r14,1),%rcx
cmp    %rcx,%rax
jbe    1748 <sht_move+0x618>
cmp    %r14,%r15
jbe    1d0e <sht_move+0xbde>
lea    0x20(%rsp),%r13
mov    %r13,%rax
jmp    11af <sht_move+0x7f>
nopl   0x0(%rax)
sub    %r12,%r15
sub    %r12,%r11
cmp    %r14,%r15
jbe    1cfc <sht_move+0xbcc>
mov    %r15,%r12
sub    %r14,%r12
cmp    $0x401,%r12
jb     11f0 <sht_move+0xc0>
lea    (%r12,%r12,1),%rdi
mov    %r11,%rbx
call   1050 <malloc@plt>
mov    %rbx,%r11
test   %rax,%rax
mov    $0x400,%ecx
cmove  %rcx,%r12
cmove  %r13,%rax
mov    0x8(%rsp),%rcx
lea    (%rcx,%r15,2),%rcx
sub    %r12,%rcx
sub    %r12,%rcx
jmp    1204 <sht_move+0xd4>
xchg   %ax,%ax
mov    0x8(%rsp),%rcx
lea    (%rcx,%r15,2),%rcx
sub    %r12,%rcx
sub    %r12,%rcx
test   %r12,%r12
je     125b <sht_move+0x12b>
mov    %rax,%rsi
mov    %rcx,%rdx
mov    %r12,%r9
cmp    $0x10,%r12
jb     1340 <sht_move+0x210>
lea    (%rcx,%r12,2),%rdx
cmp    %rdx,%rax
jae    1236 <sht_move+0x106>
lea    (%rax,%r12,2),%rdi
mov    %rax,%rsi
mov    %rcx,%rdx
mov    %r12,%r9
cmp    %rdi,%rcx
jb     1340 <sht_move+0x210>
mov    %r12,%rsi
and    $0xfffffffffffffff0,%rsi
lea    -0x10(%rsi),%rbp
mov    %rbp,%rdi
shr    $0x4,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x30,%rbp
jae    1269 <sht_move+0x139>
xor    %ebp,%ebp
jmp    12d8 <sht_move+0x1a8>
mov    $0x1,%r8b
xor    %r12d,%r12d
mov    %rcx,%rdx
jmp    13d6 <sht_move+0x2a6>
movabs $0x1ffffffffffffffc,%rbp
ff ff 1f
and    %rbp,%rdi
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movups (%rcx,%rbp,2),%xmm0
movups 0x10(%rcx,%rbp,2),%xmm1
movups %xmm0,(%rax,%rbp,2)
movups %xmm1,0x10(%rax,%rbp,2)
movups 0x20(%rcx,%rbp,2),%xmm0
movups 0x30(%rcx,%rbp,2),%xmm1
movups %xmm0,0x20(%rax,%rbp,2)
movups %xmm1,0x30(%rax,%rbp,2)
movups 0x40(%rcx,%rbp,2),%xmm0
movups 0x50(%rcx,%rbp,2),%xmm1
movups %xmm0,0x40(%rax,%rbp,2)
movups %xmm1,0x50(%rax,%rbp,2)
movups 0x60(%rcx,%rbp,2),%xmm0
movups 0x70(%rcx,%rbp,2),%xmm1
movups %xmm0,0x60(%rax,%rbp,2)
movups %xmm1,0x70(%rax,%rbp,2)
add    $0x40,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1280 <sht_move+0x150>
test   %rdx,%rdx
je     131c <sht_move+0x1ec>
lea    (%rcx,%rbp,2),%rdi
add    $0x10,%rdi
lea    (%rax,%rbp,2),%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    1300 <sht_move+0x1d0>
lea    (%rcx,%rsi,2),%rdx
cmp    %rsi,%r12
je     13d3 <sht_move+0x2a3>
mov    %r12d,%r9d
and    $0xf,%r9d
lea    (%rax,%rsi,2),%rsi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    -0x1(%r9),%r8
mov    %r9,%rdi
and    $0x7,%rdi
je     136a <sht_move+0x23a>
xor    %ebp,%ebp
nop
movzwl (%rdx),%ebx
add    $0x2,%rdx
mov    %bx,(%rsi)
add    $0x2,%rsi
add    $0x1,%rbp
cmp    %rbp,%rdi
jne    1350 <sht_move+0x220>
sub    %rbp,%r9
cmp    $0x7,%r8
jb     13d3 <sht_move+0x2a3>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzwl (%rdx),%edi
mov    %di,(%rsi,%rbp,2)
movzwl 0x2(%rdx),%edi
mov    %di,0x2(%rsi,%rbp,2)
movzwl 0x4(%rdx),%edi
mov    %di,0x4(%rsi,%rbp,2)
movzwl 0x6(%rdx),%edi
mov    %di,0x6(%rsi,%rbp,2)
movzwl 0x8(%rdx),%edi
mov    %di,0x8(%rsi,%rbp,2)
movzwl 0xa(%rdx),%edi
mov    %di,0xa(%rsi,%rbp,2)
movzwl 0xc(%rdx),%edi
mov    %di,0xc(%rsi,%rbp,2)
movzwl 0xe(%rdx),%edi
add    $0x10,%rdx
mov    %di,0xe(%rsi,%rbp,2)
add    $0x8,%rbp
cmp    %rbp,%r9
jne    1380 <sht_move+0x250>
xor    %r8d,%r8d
mov    %r11,%rdi
sub    %r15,%rdi
je     1583 <sht_move+0x453>
cmp    $0x10,%rdi
jb     14f0 <sht_move+0x3c0>
lea    (%rdx,%rdi,2),%rsi
cmp    %rsi,%rcx
jae    1402 <sht_move+0x2d2>
lea    (%rcx,%rdi,2),%rsi
cmp    %rsi,%rdx
jb     14f0 <sht_move+0x3c0>
mov    %rdi,%r9
and    $0xfffffffffffffff0,%r9
lea    -0x10(%r9),%rsi
mov    %rsi,%rbp
shr    $0x4,%rbp
add    $0x1,%rbp
mov    %ebp,%r10d
and    $0x3,%r10d
cmp    $0x30,%rsi
jae    1429 <sht_move+0x2f9>
xor    %ebx,%ebx
jmp    1498 <sht_move+0x368>
movabs $0x1ffffffffffffffc,%rsi
ff ff 1f
and    %rsi,%rbp
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups (%rdx,%rbx,2),%xmm0
movups 0x10(%rdx,%rbx,2),%xmm1
movups %xmm0,(%rcx,%rbx,2)
movups %xmm1,0x10(%rcx,%rbx,2)
movups 0x20(%rdx,%rbx,2),%xmm0
movups 0x30(%rdx,%rbx,2),%xmm1
movups %xmm0,0x20(%rcx,%rbx,2)
movups %xmm1,0x30(%rcx,%rbx,2)
movups 0x40(%rdx,%rbx,2),%xmm0
movups 0x50(%rdx,%rbx,2),%xmm1
movups %xmm0,0x40(%rcx,%rbx,2)
movups %xmm1,0x50(%rcx,%rbx,2)
movups 0x60(%rdx,%rbx,2),%xmm0
movups 0x70(%rdx,%rbx,2),%xmm1
movups %xmm0,0x60(%rcx,%rbx,2)
movups %xmm1,0x70(%rcx,%rbx,2)
add    $0x40,%rbx
add    $0xfffffffffffffffc,%rbp
jne    1440 <sht_move+0x310>
test   %r10,%r10
je     14dc <sht_move+0x3ac>
lea    (%rdx,%rbx,2),%rbp
add    $0x10,%rbp
lea    (%rcx,%rbx,2),%rbx
add    $0x10,%rbx
shl    $0x5,%r10
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rbp,%rsi,1),%xmm0
movups 0x0(%rbp,%rsi,1),%xmm1
movups %xmm0,-0x10(%rbx,%rsi,1)
movups %xmm1,(%rbx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r10
jne    14c0 <sht_move+0x390>
lea    (%rcx,%r9,2),%rcx
cmp    %r9,%rdi
je     1583 <sht_move+0x453>
and    $0xf,%edi
lea    (%rdx,%r9,2),%rdx
lea    -0x1(%rdi),%r9
mov    %rdi,%rsi
and    $0x7,%rsi
je     151a <sht_move+0x3ea>
xor    %ebx,%ebx
nop
movzwl (%rdx),%ebp
add    $0x2,%rdx
mov    %bp,(%rcx)
add    $0x2,%rcx
add    $0x1,%rbx
cmp    %rbx,%rsi
jne    1500 <sht_move+0x3d0>
sub    %rbx,%rdi
cmp    $0x7,%r9
jb     1583 <sht_move+0x453>
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzwl (%rdx,%rsi,2),%ebp
mov    %bp,(%rcx)
movzwl 0x2(%rdx,%rsi,2),%ebp
mov    %bp,0x2(%rcx)
movzwl 0x4(%rdx,%rsi,2),%ebp
mov    %bp,0x4(%rcx)
movzwl 0x6(%rdx,%rsi,2),%ebp
mov    %bp,0x6(%rcx)
movzwl 0x8(%rdx,%rsi,2),%ebp
mov    %bp,0x8(%rcx)
movzwl 0xa(%rdx,%rsi,2),%ebp
mov    %bp,0xa(%rcx)
movzwl 0xc(%rdx,%rsi,2),%ebp
mov    %bp,0xc(%rcx)
movzwl 0xe(%rdx,%rsi,2),%ebp
mov    %bp,0xe(%rcx)
add    $0x10,%rcx
add    $0x8,%rsi
cmp    %rsi,%rdi
jne    1530 <sht_move+0x400>
test   %r8b,%r8b
jne    11a0 <sht_move+0x70>
cmp    $0x10,%r12
jb     15ac <sht_move+0x47c>
lea    (%rax,%r12,2),%rdx
cmp    %rdx,%rcx
jae    165c <sht_move+0x52c>
lea    (%rcx,%r12,2),%rdx
cmp    %rdx,%rax
jae    165c <sht_move+0x52c>
mov    %rax,%rsi
mov    %r12,%rbp
lea    -0x1(%rbp),%r8
mov    %rbp,%rdx
and    $0x7,%rdx
je     15ea <sht_move+0x4ba>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzwl (%rsi),%edi
add    $0x2,%rsi
mov    %di,(%rcx)
add    $0x2,%rcx
add    $0x1,%rbx
cmp    %rbx,%rdx
jne    15d0 <sht_move+0x4a0>
sub    %rbx,%rbp
cmp    $0x7,%r8
jb     11a0 <sht_move+0x70>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movzwl (%rsi,%rdx,2),%edi
mov    %di,(%rcx,%rdx,2)
movzwl 0x2(%rsi,%rdx,2),%edi
mov    %di,0x2(%rcx,%rdx,2)
movzwl 0x4(%rsi,%rdx,2),%edi
mov    %di,0x4(%rcx,%rdx,2)
movzwl 0x6(%rsi,%rdx,2),%edi
mov    %di,0x6(%rcx,%rdx,2)
movzwl 0x8(%rsi,%rdx,2),%edi
mov    %di,0x8(%rcx,%rdx,2)
movzwl 0xa(%rsi,%rdx,2),%edi
mov    %di,0xa(%rcx,%rdx,2)
movzwl 0xc(%rsi,%rdx,2),%edi
mov    %di,0xc(%rcx,%rdx,2)
movzwl 0xe(%rsi,%rdx,2),%edi
mov    %di,0xe(%rcx,%rdx,2)
add    $0x8,%rdx
cmp    %rdx,%rbp
jne    1600 <sht_move+0x4d0>
jmp    11a0 <sht_move+0x70>
mov    %r12,%rsi
and    $0xfffffffffffffff0,%rsi
lea    -0x10(%rsi),%rbp
mov    %rbp,%rdi
shr    $0x4,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x30,%rbp
jae    1681 <sht_move+0x551>
xor    %ebp,%ebp
jmp    16e8 <sht_move+0x5b8>
movabs $0x1ffffffffffffffc,%rbp
ff ff 1f
and    %rbp,%rdi
xor    %ebp,%ebp
movups (%rax,%rbp,2),%xmm0
movups 0x10(%rax,%rbp,2),%xmm1
movups %xmm0,(%rcx,%rbp,2)
movups %xmm1,0x10(%rcx,%rbp,2)
movups 0x20(%rax,%rbp,2),%xmm0
movups 0x30(%rax,%rbp,2),%xmm1
movups %xmm0,0x20(%rcx,%rbp,2)
movups %xmm1,0x30(%rcx,%rbp,2)
movups 0x40(%rax,%rbp,2),%xmm0
movups 0x50(%rax,%rbp,2),%xmm1
movups %xmm0,0x40(%rcx,%rbp,2)
movups %xmm1,0x50(%rcx,%rbp,2)
movups 0x60(%rax,%rbp,2),%xmm0
movups 0x70(%rax,%rbp,2),%xmm1
movups %xmm0,0x60(%rcx,%rbp,2)
movups %xmm1,0x70(%rcx,%rbp,2)
add    $0x40,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1690 <sht_move+0x560>
test   %rdx,%rdx
je     172c <sht_move+0x5fc>
lea    (%rax,%rbp,2),%rdi
add    $0x10,%rdi
lea    (%rcx,%rbp,2),%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    1710 <sht_move+0x5e0>
cmp    %rsi,%r12
je     11a0 <sht_move+0x70>
mov    %r12d,%ebp
and    $0xf,%ebp
lea    (%rcx,%rsi,2),%rcx
lea    (%rax,%rsi,2),%rsi
jmp    15b2 <sht_move+0x482>
cmp    %r15,%r11
jbe    1d0e <sht_move+0xbde>
lea    0x20(%rsp),%rcx
mov    0x8(%rsp),%rax
lea    (%rax,%r11,2),%rax
mov    %rax,0x10(%rsp)
mov    %rcx,%rax
mov    %r11,0x18(%rsp)
jmp    177f <sht_move+0x64f>
xchg   %ax,%ax
add    %r13,%r15
add    %r13,%r14
cmp    %r15,%r11
jbe    1cfc <sht_move+0xbcc>
mov    %r11,%r13
sub    %r15,%r13
cmp    $0x401,%r13
jb     17d0 <sht_move+0x6a0>
mov    %r13,%rdi
add    %r13,%rdi
call   1050 <malloc@plt>
mov    0x18(%rsp),%r11
test   %rax,%rax
mov    $0x400,%ecx
cmove  %rcx,%r13
lea    0x20(%rsp),%rcx
cmove  %rcx,%rax
mov    0x8(%rsp),%rcx
lea    (%rcx,%r15,2),%rcx
lea    (%rcx,%r13,2),%rdx
lea    (%rax,%r13,2),%r12
jmp    17e2 <sht_move+0x6b2>
cs nopw 0x0(%rax,%rax,1)
lea    (%rax,%r13,2),%r12
test   %r13,%r13
je     188b <sht_move+0x75b>
mov    0x10(%rsp),%rdx
mov    %r12,%rdi
mov    %rdx,%rsi
mov    %r13,%r9
cmp    $0x10,%r13
jb     18f0 <sht_move+0x7c0>
mov    %r13,%rsi
add    %r13,%rsi
mov    %r12,%rdi
sub    %rsi,%rdi
cmp    %rdx,%rdi
jae    181e <sht_move+0x6ee>
mov    %rdx,%rbp
sub    %rsi,%rbp
mov    %r12,%rdi
mov    %rdx,%rsi
mov    %r13,%r9
cmp    %r12,%rbp
jb     18f0 <sht_move+0x7c0>
mov    %r13,%r9
and    $0xfffffffffffffff0,%r9
lea    -0x10(%r9),%rsi
mov    %rsi,%rdi
shr    $0x4,%rdi
add    $0x1,%rdi
test   %rsi,%rsi
je     189e <sht_move+0x76e>
movabs $0x1ffffffffffffffc,%rcx
ff ff 1f
lea    0x2(%rcx),%rbx
and    %rdi,%rbx
xor    %ebp,%ebp
nopl   0x0(%rax)
movups -0x20(%rdx,%rbp,2),%xmm0
movups -0x10(%rdx,%rbp,2),%xmm1
movups %xmm1,-0x10(%r12,%rbp,2)
movups %xmm0,-0x20(%r12,%rbp,2)
movups -0x40(%rdx,%rbp,2),%xmm0
movups -0x30(%rdx,%rbp,2),%xmm1
movups %xmm1,-0x30(%r12,%rbp,2)
movups %xmm0,-0x40(%r12,%rbp,2)
add    $0xffffffffffffffe0,%rbp
add    $0xfffffffffffffffe,%rbx
jne    1850 <sht_move+0x720>
neg    %rbp
jmp    18a0 <sht_move+0x770>
mov    $0x1,%r9b
mov    0x10(%rsp),%rsi
mov    %rsi,%rdx
xor    %r13d,%r13d
jmp    1988 <sht_move+0x858>
xor    %ebp,%ebp
lea    (%r9,%r9,1),%r8
test   $0x1,%dil
je     18c9 <sht_move+0x799>
add    %rbp,%rbp
mov    %r12,%rsi
sub    %rbp,%rsi
mov    %rdx,%rdi
sub    %rbp,%rdi
movups -0x20(%rdi),%xmm0
movups -0x10(%rdi),%xmm1
movups %xmm1,-0x10(%rsi)
movups %xmm0,-0x20(%rsi)
mov    %rdx,%rsi
sub    %r8,%rsi
cmp    %r9,%r13
je     1985 <sht_move+0x855>
mov    %r13d,%r9d
and    $0xf,%r9d
mov    %r12,%rdi
sub    %r8,%rdi
cs nopw 0x0(%rax,%rax,1)
nop
lea    -0x1(%r9),%r8
mov    %r9,%rbx
and    $0x7,%rbx
je     191c <sht_move+0x7ec>
xor    %ebp,%ebp
nop
movzwl -0x2(%rsi),%ecx
add    $0xfffffffffffffffe,%rsi
mov    %cx,-0x2(%rdi)
add    $0xfffffffffffffffe,%rdi
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1900 <sht_move+0x7d0>
sub    %rbp,%r9
cmp    $0x7,%r8
jb     1985 <sht_move+0x855>
neg    %r9
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movzwl -0x2(%rsi),%ecx
mov    %cx,-0x2(%rdi,%rbp,2)
movzwl -0x4(%rsi),%ecx
mov    %cx,-0x4(%rdi,%rbp,2)
movzwl -0x6(%rsi),%ecx
mov    %cx,-0x6(%rdi,%rbp,2)
movzwl -0x8(%rsi),%ecx
mov    %cx,-0x8(%rdi,%rbp,2)
movzwl -0xa(%rsi),%ecx
mov    %cx,-0xa(%rdi,%rbp,2)
movzwl -0xc(%rsi),%ecx
mov    %cx,-0xc(%rdi,%rbp,2)
movzwl -0xe(%rsi),%ecx
mov    %cx,-0xe(%rdi,%rbp,2)
movzwl -0x10(%rsi),%ecx
add    $0xfffffffffffffff0,%rsi
mov    %cx,-0x10(%rdi,%rbp,2)
add    $0xfffffffffffffff8,%rbp
cmp    %rbp,%r9
jne    1930 <sht_move+0x800>
xor    %r9d,%r9d
mov    %r15,%rbx
sub    %r14,%rbx
je     1a35 <sht_move+0x905>
cmp    $0x10,%rbx
jae    1b20 <sht_move+0x9f0>
lea    -0x1(%rbx),%r8
mov    %rbx,%rdi
and    $0x7,%rdi
je     19cc <sht_move+0x89c>
xor    %ebp,%ebp
nopl   (%rax)
movzwl -0x2(%rsi),%ecx
add    $0xfffffffffffffffe,%rsi
mov    %cx,-0x2(%rdx)
add    $0xfffffffffffffffe,%rdx
add    $0x1,%rbp
cmp    %rbp,%rdi
jne    19b0 <sht_move+0x880>
sub    %rbp,%rbx
cmp    $0x7,%r8
jb     1a35 <sht_move+0x905>
neg    %rbx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movzwl -0x2(%rsi,%rdi,2),%ecx
mov    %cx,-0x2(%rdx)
movzwl -0x4(%rsi,%rdi,2),%ecx
mov    %cx,-0x4(%rdx)
movzwl -0x6(%rsi,%rdi,2),%ecx
mov    %cx,-0x6(%rdx)
movzwl -0x8(%rsi,%rdi,2),%ecx
mov    %cx,-0x8(%rdx)
movzwl -0xa(%rsi,%rdi,2),%ecx
mov    %cx,-0xa(%rdx)
movzwl -0xc(%rsi,%rdi,2),%ecx
mov    %cx,-0xc(%rdx)
movzwl -0xe(%rsi,%rdi,2),%ecx
mov    %cx,-0xe(%rdx)
movzwl -0x10(%rsi,%rdi,2),%ecx
mov    %cx,-0x10(%rdx)
add    $0xfffffffffffffff0,%rdx
add    $0xfffffffffffffff8,%rdi
cmp    %rdi,%rbx
jne    19e0 <sht_move+0x8b0>
test   %r9b,%r9b
jne    1770 <sht_move+0x640>
cmp    $0x10,%r13
jb     1a68 <sht_move+0x938>
mov    %r13,%rsi
add    %r13,%rsi
mov    %rdx,%rcx
sub    %rsi,%rcx
cmp    %r12,%rcx
jae    1bfa <sht_move+0xaca>
mov    %r12,%rcx
sub    %rsi,%rcx
cmp    %rdx,%rcx
jae    1bfa <sht_move+0xaca>
mov    %r13,%rbp
lea    -0x1(%rbp),%rdi
mov    %rbp,%rsi
and    $0x7,%rsi
je     1a9e <sht_move+0x96e>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movzwl -0x2(%r12),%ecx
add    $0xfffffffffffffffe,%r12
mov    %cx,-0x2(%rdx)
add    $0xfffffffffffffffe,%rdx
add    $0x1,%rbx
cmp    %rbx,%rsi
jne    1a80 <sht_move+0x950>
sub    %rbx,%rbp
cmp    $0x7,%rdi
jb     1770 <sht_move+0x640>
neg    %rbp
xor    %esi,%esi
nopl   (%rax)
movzwl -0x2(%r12,%rsi,2),%ecx
mov    %cx,-0x2(%rdx,%rsi,2)
movzwl -0x4(%r12,%rsi,2),%ecx
mov    %cx,-0x4(%rdx,%rsi,2)
movzwl -0x6(%r12,%rsi,2),%ecx
mov    %cx,-0x6(%rdx,%rsi,2)
movzwl -0x8(%r12,%rsi,2),%ecx
mov    %cx,-0x8(%rdx,%rsi,2)
movzwl -0xa(%r12,%rsi,2),%ecx
mov    %cx,-0xa(%rdx,%rsi,2)
movzwl -0xc(%r12,%rsi,2),%ecx
mov    %cx,-0xc(%rdx,%rsi,2)
movzwl -0xe(%r12,%rsi,2),%ecx
mov    %cx,-0xe(%rdx,%rsi,2)
movzwl -0x10(%r12,%rsi,2),%ecx
mov    %cx,-0x10(%rdx,%rsi,2)
add    $0xfffffffffffffff8,%rsi
cmp    %rsi,%rbp
jne    1ab0 <sht_move+0x980>
jmp    1770 <sht_move+0x640>
cs nopw 0x0(%rax,%rax,1)
mov    %r14,%rdi
not    %rdi
add    %r15,%rdi
lea    -0x2(%rdx),%rbp
add    %rdi,%rdi
setb   %r8b
mov    %rbp,%rcx
sub    %rdi,%rcx
cmp    %rbp,%rcx
ja     199e <sht_move+0x86e>
test   %r8b,%r8b
jne    199e <sht_move+0x86e>
lea    -0x2(%rsi),%rbp
mov    %rbp,%rcx
sub    %rdi,%rcx
cmp    %rbp,%rcx
ja     199e <sht_move+0x86e>
test   %r8b,%r8b
jne    199e <sht_move+0x86e>
mov    %r14,%rdi
sub    %r15,%rdi
lea    (%rdx,%rdi,2),%rcx
cmp    %rsi,%rcx
jae    1b84 <sht_move+0xa54>
lea    (%rsi,%rdi,2),%rcx
cmp    %rdx,%rcx
jb     199e <sht_move+0x86e>
mov    %rbx,%r8
and    $0xfffffffffffffff0,%r8
lea    -0x10(%r8),%rcx
mov    %rcx,%r11
shr    $0x4,%r11
add    $0x1,%r11
test   %rcx,%rcx
je     1cb5 <sht_move+0xb85>
movabs $0x1ffffffffffffffc,%rcx
ff ff 1f
lea    0x2(%rcx),%rbp
and    %r11,%rbp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movups -0x20(%rsi,%rdi,2),%xmm0
movups -0x10(%rsi,%rdi,2),%xmm1
movups %xmm1,-0x10(%rdx,%rdi,2)
movups %xmm0,-0x20(%rdx,%rdi,2)
movups -0x40(%rsi,%rdi,2),%xmm0
movups -0x30(%rsi,%rdi,2),%xmm1
movups %xmm1,-0x30(%rdx,%rdi,2)
movups %xmm0,-0x40(%rdx,%rdi,2)
add    $0xffffffffffffffe0,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1bc0 <sht_move+0xa90>
neg    %rdi
jmp    1cb7 <sht_move+0xb87>
mov    %r13,%rdi
and    $0xfffffffffffffff0,%rdi
lea    -0x10(%rdi),%rcx
mov    %rcx,%rsi
shr    $0x4,%rsi
add    $0x1,%rsi
test   %rcx,%rcx
je     1cab <sht_move+0xb7b>
movabs $0x1ffffffffffffffc,%rcx
ff ff 1f
lea    0x2(%rcx),%rbx
and    %rsi,%rbx
xor    %ebp,%ebp
nopl   0x0(%rax)
movups -0x20(%r12,%rbp,2),%xmm0
movups -0x10(%r12,%rbp,2),%xmm1
movups %xmm1,-0x10(%rdx,%rbp,2)
movups %xmm0,-0x20(%rdx,%rbp,2)
movups -0x40(%r12,%rbp,2),%xmm0
movups -0x30(%r12,%rbp,2),%xmm1
movups %xmm1,-0x30(%rdx,%rbp,2)
movups %xmm0,-0x40(%rdx,%rbp,2)
add    $0xffffffffffffffe0,%rbp
add    $0xfffffffffffffffe,%rbx
jne    1c30 <sht_move+0xb00>
neg    %rbp
test   $0x1,%sil
je     1c8e <sht_move+0xb5e>
add    %rbp,%rbp
mov    %rdx,%rcx
sub    %rbp,%rcx
mov    %r12,%rsi
sub    %rbp,%rsi
movups -0x20(%rsi),%xmm0
movups -0x10(%rsi),%xmm1
movups %xmm1,-0x10(%rcx)
movups %xmm0,-0x20(%rcx)
cmp    %rdi,%r13
je     1770 <sht_move+0x640>
add    %rdi,%rdi
mov    %r13d,%ebp
and    $0xf,%ebp
sub    %rdi,%rdx
sub    %rdi,%r12
jmp    1a6b <sht_move+0x93b>
xor    %ebp,%ebp
test   $0x1,%sil
jne    1c6f <sht_move+0xb3f>
jmp    1c8e <sht_move+0xb5e>
xor    %edi,%edi
lea    (%r8,%r8,1),%r10
test   $0x1,%r11b
je     1ce0 <sht_move+0xbb0>
add    %rdi,%rdi
mov    %rdx,%rcx
sub    %rdi,%rcx
mov    %rsi,%rbp
sub    %rdi,%rbp
movups -0x20(%rbp),%xmm0
movups -0x10(%rbp),%xmm1
movups %xmm1,-0x10(%rcx)
movups %xmm0,-0x20(%rcx)
sub    %r10,%rdx
cmp    %r8,%rbx
mov    0x18(%rsp),%r11
je     1a35 <sht_move+0x905>
and    $0xf,%ebx
sub    %r10,%rsi
jmp    199e <sht_move+0x86e>
lea    0x20(%rsp),%rcx
cmp    %rcx,%rax
je     1d0e <sht_move+0xbde>
mov    %rax,%rdi
call   1030 <free@plt>
add    $0x828,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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