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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ assert(int);
void v_move(void *vec, int off, int n, int pos, int esz) {
  int i;
  int mid, end;
  int *src, *dst;
  int buf[4096];
  assert(vec && (off >= 0) && (n >= 0) && (pos >= 0) && (esz >= 0));
  esz /= (int)sizeof(int);
  pos *= esz;
  off *= esz;
  n *= esz;
  end = off + n;
  if (pos <= off) {
    mid = off;
    off = pos;
  } else {
    mid = end;
    end = pos;
  }
  if (mid - off < end - mid) {
    while (mid > off) {
      n = (mid - off < 4096) ? mid - off : 4096;
      src = (int *)vec + mid - n;
      dst = buf;
      for (i = n; --i >= 0;)
        *dst++ = *src++;
      dst = (int *)vec + mid - n;
      for (i = end - mid; --i >= 0;)
        *dst++ = *src++;
      src = buf;
      for (i = n; --i >= 0;)
        *dst++ = *src++;
      mid -= n;
      end -= n;
    }
  } else {
    while (end > mid) {
      n = (end - mid < 4096) ? end - mid : 4096;
      src = (int *)vec + mid + n;
      dst = buf + n;
      for (i = n; --i >= 0;)
        *--dst = *--src;
      dst = (int *)vec + mid + n;
      for (i = mid - off; --i >= 0;)
        *--dst = *--src;
      src = buf + n;
      for (i = n; --i >= 0;)
        *--dst = *--src;
      mid += n;
      off += n;
    }
  }
}


x86 assembly (clang, -O0):
<v_move>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4050,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
xor    %eax,%eax
cmpq   $0x0,-0x8(%rbp)
mov    %al,-0x4041(%rbp)
je     1182 <v_move+0x72>
xor    %eax,%eax
cmpl   $0x0,-0xc(%rbp)
mov    %al,-0x4041(%rbp)
jl     1182 <v_move+0x72>
xor    %eax,%eax
cmpl   $0x0,-0x10(%rbp)
mov    %al,-0x4041(%rbp)
jl     1182 <v_move+0x72>
xor    %eax,%eax
cmpl   $0x0,-0x14(%rbp)
mov    %al,-0x4041(%rbp)
jl     1182 <v_move+0x72>
cmpl   $0x0,-0x18(%rbp)
setge  %al
mov    %al,-0x4041(%rbp)
mov    -0x4041(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x18(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0xc(%rbp)
mov    -0x18(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0xc(%rbp),%eax
add    -0x10(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     11e4 <v_move+0xd4>
mov    -0xc(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0xc(%rbp)
jmp    11f0 <v_move+0xe0>
mov    -0x24(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
sub    -0xc(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    -0x20(%rbp),%ecx
cmp    %ecx,%eax
jge    138c <v_move+0x27c>
jmp    1209 <v_move+0xf9>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jle    1387 <v_move+0x277>
mov    -0x20(%rbp),%eax
sub    -0xc(%rbp),%eax
cmp    $0x1000,%eax
jge    1237 <v_move+0x127>
mov    -0x20(%rbp),%eax
sub    -0xc(%rbp),%eax
mov    %eax,-0x4048(%rbp)
jmp    1247 <v_move+0x137>
mov    $0x1000,%eax
mov    %eax,-0x4048(%rbp)
jmp    1247 <v_move+0x137>
mov    -0x4048(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
lea    -0x4040(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
cmp    $0x0,%eax
jl     12bd <v_move+0x1ad>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%ecx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x38(%rbp)
mov    %ecx,(%rax)
jmp    1284 <v_move+0x174>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x24(%rbp),%eax
sub    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
cmp    $0x0,%eax
jl     1322 <v_move+0x212>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%ecx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x38(%rbp)
mov    %ecx,(%rax)
jmp    12e9 <v_move+0x1d9>
lea    -0x4040(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
cmp    $0x0,%eax
jl     136c <v_move+0x25c>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%ecx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x38(%rbp)
mov    %ecx,(%rax)
jmp    1333 <v_move+0x223>
mov    -0x10(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%ecx
mov    -0x24(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x24(%rbp)
jmp    1209 <v_move+0xf9>
jmp    1522 <v_move+0x412>
jmp    1391 <v_move+0x281>
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jle    151d <v_move+0x40d>
mov    -0x24(%rbp),%eax
sub    -0x20(%rbp),%eax
cmp    $0x1000,%eax
jge    13bf <v_move+0x2af>
mov    -0x24(%rbp),%eax
sub    -0x20(%rbp),%eax
mov    %eax,-0x404c(%rbp)
jmp    13cf <v_move+0x2bf>
mov    $0x1000,%eax
mov    %eax,-0x404c(%rbp)
jmp    13cf <v_move+0x2bf>
mov    -0x404c(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
lea    -0x4040(%rbp),%rax
movslq -0x10(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
cmp    $0x0,%eax
jl     144d <v_move+0x33d>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x30(%rbp)
mov    -0x4(%rax),%ecx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x38(%rbp)
mov    %ecx,-0x4(%rax)
jmp    1412 <v_move+0x302>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%eax
sub    -0xc(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
cmp    $0x0,%eax
jl     14af <v_move+0x39f>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x30(%rbp)
mov    -0x4(%rax),%ecx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x38(%rbp)
mov    %ecx,-0x4(%rax)
jmp    1474 <v_move+0x364>
lea    -0x4040(%rbp),%rax
movslq -0x10(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
cmp    $0x0,%eax
jl     1506 <v_move+0x3f6>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x30(%rbp)
mov    -0x4(%rax),%ecx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x38(%rbp)
mov    %ecx,-0x4(%rax)
jmp    14cb <v_move+0x3bb>
mov    -0x10(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%eax
add    -0xc(%rbp),%eax
mov    %eax,-0xc(%rbp)
jmp    1391 <v_move+0x281>
jmp    1522 <v_move+0x412>
add    $0x4050,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<v_move>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x4048,%rsp
mov    %r8d,%r12d
mov    %ecx,%ebx
mov    %edx,%r14d
mov    %esi,%ebp
mov    %edx,%ecx
or     %esi,%ecx
mov    %r8d,%eax
not    %eax
shr    $0x1f,%eax
xor    %edx,%edx
or     %ebx,%ecx
cmovs  %edx,%eax
mov    %rdi,0x20(%rsp)
test   %rdi,%rdi
cmove  %edx,%eax
mov    %eax,%edi
call   1030 <assert@plt>
lea    0x3(%r12),%r10d
test   %r12d,%r12d
cmovns %r12d,%r10d
sar    $0x2,%r10d
imul   %r10d,%ebx
imul   %r10d,%ebp
imul   %r14d,%r10d
add    %ebp,%r10d
cmp    %ebp,%ebx
mov    %ebx,%r8d
cmovg  %ebp,%r8d
cmovg  %r10d,%ebp
cmovg  %ebx,%r10d
mov    %ebp,%eax
sub    %r8d,%eax
mov    %r10d,%ecx
mov    %ebp,0x4(%rsp)
sub    %ebp,%ecx
cmp    %ecx,%eax
jge    15fb <v_move+0x4db>
cmp    %r8d,0x4(%rsp)
mov    0x20(%rsp),%r11
jle    19e0 <v_move+0x8c0>
lea    0x4(%r11),%rax
mov    %rax,0x18(%rsp)
lea    0x70(%r11),%rax
mov    %rax,0x30(%rsp)
lea    0x10(%r11),%rax
mov    %rax,0x38(%rsp)
lea    0x40(%rsp),%rdi
mov    %r8d,0xc(%rsp)
jmp    11f7 <v_move+0xd7>
nopl   (%rax)
mov    0x4(%rsp),%eax
sub    %r15d,%eax
sub    %r15d,%r10d
mov    %eax,0x4(%rsp)
cmp    %r8d,%eax
jle    19e0 <v_move+0x8c0>
mov    0x4(%rsp),%eax
mov    %eax,%r12d
sub    %r8d,%r12d
cmp    $0x1000,%r12d
mov    $0x1000,%r15d
cmovl  %r12d,%r15d
movslq %eax,%r13
lea    (%r11,%r13,4),%rbx
movslq %r15d,%rbp
lea    0x0(,%rbp,4),%r14
sub    %r14,%rbx
mov    %rbx,%rax
test   %r12d,%r12d
jle    12b7 <v_move+0x197>
lea    0x0(,%r13,4),%rsi
sub    %r14,%rsi
add    %r11,%rsi
test   %r12d,%r12d
mov    $0x1,%eax
cmovle %r12d,%eax
mov    %r12d,0x8(%rsp)
mov    %r13,%r12
mov    %r15d,%r13d
sub    %eax,%r13d
lea    0x4(,%r13,4),%rdx
shl    $0x2,%r13
mov    %rbp,0x10(%rsp)
mov    %rdi,%rbp
mov    %r14,0x28(%rsp)
mov    %r15d,%r14d
mov    %r10d,%r15d
call   1040 <memcpy@plt>
mov    0xc(%rsp),%r8d
mov    %r15d,%r10d
mov    %r14d,%r15d
mov    0x28(%rsp),%r14
mov    %rbp,%rdi
mov    0x10(%rsp),%rbp
mov    0x20(%rsp),%r11
lea    0x0(,%r12,4),%rax
add    %r13,%rax
mov    %r12,%r13
mov    0x8(%rsp),%r12d
sub    %r14,%rax
add    0x18(%rsp),%rax
mov    %r10d,%ecx
sub    0x4(%rsp),%ecx
test   %ecx,%ecx
jle    1474 <v_move+0x354>
mov    0x4(%rsp),%edx
mov    %edx,%r9d
not    %r9d
add    %r10d,%r9d
cmp    $0x7,%r9d
jb     1450 <v_move+0x330>
mov    %r13,%rdx
sub    %rbp,%rdx
lea    (%r11,%rdx,4),%rdx
lea    (%rax,%r9,4),%rsi
add    $0x4,%rsi
cmp    %rsi,%rdx
jae    130d <v_move+0x1ed>
lea    (%r9,%r13,1),%rdx
sub    %rbp,%rdx
mov    0x18(%rsp),%rsi
lea    (%rsi,%rdx,4),%rdx
cmp    %rax,%rdx
ja     1450 <v_move+0x330>
mov    %r10d,0x8(%rsp)
add    $0x1,%r9
mov    %r9,%r8
movabs $0x1fffffff8,%rdx
and    %rdx,%r8
lea    -0x8(%r8),%rdx
mov    %rdx,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
mov    %ebp,%r10d
and    $0x3,%r10d
cmp    $0x18,%rdx
jae    1349 <v_move+0x229>
xor    %edx,%edx
jmp    13c8 <v_move+0x2a8>
movabs $0x3ffffffffffffffc,%rdx
ff ff 3f
and    %rdx,%rbp
lea    0x0(,%r13,4),%rsi
sub    %r14,%rsi
add    0x30(%rsp),%rsi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movups (%rax,%rdx,4),%xmm0
movups 0x10(%rax,%rdx,4),%xmm1
movups %xmm0,-0x70(%rsi,%rdx,4)
movups %xmm1,-0x60(%rsi,%rdx,4)
movups 0x20(%rax,%rdx,4),%xmm0
movups 0x30(%rax,%rdx,4),%xmm1
movups %xmm0,-0x50(%rsi,%rdx,4)
movups %xmm1,-0x40(%rsi,%rdx,4)
movups 0x40(%rax,%rdx,4),%xmm0
movups 0x50(%rax,%rdx,4),%xmm1
movups %xmm0,-0x30(%rsi,%rdx,4)
movups %xmm1,-0x20(%rsi,%rdx,4)
movups 0x60(%rax,%rdx,4),%xmm0
movups 0x70(%rax,%rdx,4),%xmm1
movups %xmm0,-0x10(%rsi,%rdx,4)
movups %xmm1,(%rsi,%rdx,4)
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rbp
jne    1370 <v_move+0x250>
test   %r10,%r10
je     141b <v_move+0x2fb>
lea    (%rax,%rdx,4),%rsi
add    $0x10,%rsi
shl    $0x2,%r13
lea    0x0(,%rdx,4),%rdx
add    %r13,%rdx
sub    %r14,%rdx
add    0x38(%rsp),%rdx
shl    $0x5,%r10
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rsi,%rbp,1),%xmm0
movups (%rsi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdx,%rbp,1)
movups %xmm1,(%rdx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r10
jne    1400 <v_move+0x2e0>
lea    (%rbx,%r8,4),%rbx
cmp    %r8,%r9
jne    1430 <v_move+0x310>
mov    0x8(%rsp),%r10d
mov    0xc(%rsp),%r8d
jmp    1474 <v_move+0x354>
lea    (%rax,%r8,4),%rax
sub    %r8d,%ecx
mov    0x8(%rsp),%r10d
mov    0xc(%rsp),%r8d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rax),%edx
add    $0x4,%rax
mov    %edx,(%rbx)
add    $0x4,%rbx
add    $0xffffffff,%ecx
cmp    $0x1,%ecx
ja     1460 <v_move+0x340>
test   %r12d,%r12d
jle    11e0 <v_move+0xc0>
mov    $0x1,%ecx
cmovle %r12d,%ecx
mov    %r15d,%eax
sub    %ecx,%eax
cmp    $0x7,%eax
jb     14c2 <v_move+0x3a2>
test   %r12d,%r12d
mov    $0x1,%ecx
cmovg  %ecx,%r12d
mov    %r15d,%ecx
sub    %r12d,%ecx
lea    (%rbx,%rcx,4),%rdx
add    $0x4,%rdx
lea    0x44(%rsp),%rsi
lea    (%rsi,%rcx,4),%rsi
cmp    %rdx,%rdi
setb   %cl
cmp    %rsi,%rbx
jae    14e7 <v_move+0x3c7>
test   %cl,%cl
je     14e7 <v_move+0x3c7>
mov    %rdi,%rax
mov    %r15d,%edx
add    $0x1,%edx
xor    %ecx,%ecx
nopl   (%rax)
mov    (%rax,%rcx,1),%esi
mov    %esi,(%rbx,%rcx,1)
add    $0x4,%rcx
add    $0xffffffff,%edx
cmp    $0x1,%edx
jg     14d0 <v_move+0x3b0>
jmp    11e0 <v_move+0xc0>
add    $0x1,%rax
mov    %rax,%r9
movabs $0x1fffffff8,%rdx
and    %rdx,%r9
lea    -0x8(%r9),%rbp
mov    %rbp,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rbp
jae    1519 <v_move+0x3f9>
xor    %ebp,%ebp
jmp    1595 <v_move+0x475>
movabs $0x3ffffffffffffffc,%rcx
ff ff 3f
and    %rcx,%rsi
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movaps 0x40(%rsp,%rbp,4),%xmm0
movaps 0x50(%rsp,%rbp,4),%xmm1
movups %xmm0,(%rbx,%rbp,4)
movups %xmm1,0x10(%rbx,%rbp,4)
movaps 0x60(%rsp,%rbp,4),%xmm0
movaps 0x70(%rsp,%rbp,4),%xmm1
movups %xmm0,0x20(%rbx,%rbp,4)
movups %xmm1,0x30(%rbx,%rbp,4)
movaps 0x80(%rsp,%rbp,4),%xmm0
movaps 0x90(%rsp,%rbp,4),%xmm1
movups %xmm0,0x40(%rbx,%rbp,4)
movups %xmm1,0x50(%rbx,%rbp,4)
movaps 0xa0(%rsp,%rbp,4),%xmm0
movaps 0xb0(%rsp,%rbp,4),%xmm1
movups %xmm0,0x60(%rbx,%rbp,4)
movups %xmm1,0x70(%rbx,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rsi
jne    1530 <v_move+0x410>
test   %rdx,%rdx
je     15db <v_move+0x4bb>
lea    0x44(%rsp),%rsi
lea    (%rsi,%rbp,4),%rsi
add    $0xc,%rsi
lea    (%rbx,%rbp,4),%rcx
add    $0x10,%rcx
shl    $0x5,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movaps -0x10(%rsi,%rbp,1),%xmm0
movaps (%rsi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rcx,%rbp,1)
movups %xmm1,(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    15c0 <v_move+0x4a0>
cmp    %r9,%rax
je     11e0 <v_move+0xc0>
lea    (%rbx,%r9,4),%rbx
lea    (%rsp,%r9,4),%rax
add    $0x40,%rax
mov    %r15d,%edx
sub    %r9d,%edx
jmp    14c8 <v_move+0x3a8>
cmp    0x4(%rsp),%r10d
mov    0x20(%rsp),%r9
jle    19e0 <v_move+0x8c0>
lea    -0x4(%r9),%rax
mov    %rax,0x10(%rsp)
lea    -0x10(%r9),%rax
mov    %rax,0x18(%rsp)
jmp    1637 <v_move+0x517>
nop
mov    0x4(%rsp),%eax
add    %r11d,%eax
add    %r11d,%r8d
mov    %eax,0x4(%rsp)
cmp    %eax,%r10d
jle    19e0 <v_move+0x8c0>
mov    %r10d,%r13d
mov    0x4(%rsp),%eax
sub    %eax,%r13d
cmp    $0x1000,%r13d
mov    $0x1000,%r11d
cmovl  %r13d,%r11d
movslq %eax,%rbx
lea    (%r9,%rbx,4),%rax
movslq %r11d,%r15
lea    (%rax,%r15,4),%r12
mov    %r12,%r14
test   %r13d,%r13d
jle    16d6 <v_move+0x5b6>
mov    $0x1,%eax
cmovle %r13d,%eax
mov    %r15d,%ecx
sub    %eax,%ecx
mov    %r15,%rax
sub    %rcx,%rax
lea    0x3c(%rsp),%rdx
lea    (%rdx,%rax,4),%rdi
lea    (%rbx,%r15,1),%rax
sub    %rcx,%rax
mov    0x10(%rsp),%rdx
lea    (%rdx,%rax,4),%r14
lea    0x4(,%rcx,4),%rdx
mov    %r14,%rsi
mov    %rbx,0x28(%rsp)
mov    %r10d,%ebx
mov    %r15,%rbp
mov    %r8d,%r15d
mov    %r13d,0x8(%rsp)
mov    %r11d,%r13d
call   1040 <memcpy@plt>
mov    %r13d,%r11d
mov    0x8(%rsp),%r13d
mov    %r15d,%r8d
mov    %rbp,%r15
mov    %ebx,%r10d
mov    0x28(%rsp),%rbx
mov    0x20(%rsp),%r9
mov    0x4(%rsp),%eax
sub    %r8d,%eax
test   %eax,%eax
jle    1718 <v_move+0x5f8>
mov    %r8d,%ecx
not    %ecx
add    0x4(%rsp),%ecx
cmp    $0x7,%ecx
jae    17b0 <v_move+0x690>
add    $0xfffffffffffffffc,%r14
add    $0x1,%eax
nopw   0x0(%rax,%rax,1)
mov    (%r14),%ecx
mov    %ecx,-0x4(%r12)
add    $0xfffffffffffffffc,%r12
add    $0xfffffffffffffffc,%r14
add    $0xffffffff,%eax
cmp    $0x1,%eax
ja     1700 <v_move+0x5e0>
test   %r13d,%r13d
jle    1620 <v_move+0x500>
lea    0x40(%rsp,%r15,4),%rax
mov    $0x1,%edx
cmovle %r13d,%edx
mov    %r15d,%ecx
sub    %edx,%ecx
cmp    $0x7,%ecx
jb     1786 <v_move+0x666>
test   %r13d,%r13d
mov    $0x1,%edx
cmovg  %edx,%r13d
mov    %r15d,%edx
sub    %r13d,%edx
lea    0x0(,%rdx,4),%rsi
mov    %r12,%rdi
sub    %rsi,%rdi
add    $0xfffffffffffffffc,%rdi
lea    (%rsp,%r15,4),%rsi
add    $0x40,%rsi
cmp    %rsi,%rdi
jae    18ad <v_move+0x78d>
mov    %r15,%rsi
sub    %rdx,%rsi
lea    0x3c(%rsp),%rdx
lea    (%rdx,%rsi,4),%rdx
cmp    %r12,%rdx
jae    18ad <v_move+0x78d>
mov    %r11d,%ecx
add    $0x1,%ecx
xor    %edx,%edx
xchg   %ax,%ax
mov    -0x4(%rax,%rdx,4),%esi
mov    %esi,-0x4(%r12,%rdx,4)
add    $0xffffffffffffffff,%rdx
lea    (%rdx,%rcx,1),%esi
cmp    $0x1,%esi
jg     1790 <v_move+0x670>
jmp    1620 <v_move+0x500>
nopw   0x0(%rax,%rax,1)
lea    (%rbx,%r15,1),%rdx
mov    0x10(%rsp),%rsi
lea    (%rsi,%rdx,4),%rsi
lea    0x0(,%rcx,4),%rdx
mov    %rsi,%rdi
sub    %rdx,%rdi
cmp    %rsi,%rdi
ja     16f3 <v_move+0x5d3>
lea    -0x4(%r14),%rsi
mov    %rsi,%rdi
sub    %rdx,%rdi
cmp    %rsi,%rdi
ja     16f3 <v_move+0x5d3>
lea    0x0(,%r15,4),%rdx
lea    (%rdx,%rbx,4),%rsi
lea    0x0(,%rcx,4),%rdx
mov    %rsi,%rdi
sub    %rdx,%rdi
add    0x10(%rsp),%rdi
cmp    %r14,%rdi
jae    1822 <v_move+0x702>
lea    (%r9,%rsi,1),%rdi
mov    %r14,%rbx
sub    %rdx,%rbx
add    $0xfffffffffffffffc,%rbx
cmp    %rbx,%rdi
ja     16f3 <v_move+0x5d3>
mov    %r8d,%ebx
add    $0x1,%rcx
mov    %rcx,%r8
movabs $0x1fffffff8,%rdx
and    %rdx,%r8
lea    -0x8(%r8),%rdx
mov    %rdx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
test   %rdx,%rdx
je     1989 <v_move+0x869>
movabs $0x3ffffffffffffffc,%rdx
ff ff 3f
add    $0x2,%rdx
and    %rdi,%rdx
add    0x18(%rsp),%rsi
xor    %ebp,%ebp
nopl   0x0(%rax)
movups -0x20(%r14,%rbp,4),%xmm0
movups -0x10(%r14,%rbp,4),%xmm1
movups %xmm1,(%rsi,%rbp,4)
movups %xmm0,-0x10(%rsi,%rbp,4)
movups -0x40(%r14,%rbp,4),%xmm0
movups -0x30(%r14,%rbp,4),%xmm1
movups %xmm1,-0x20(%rsi,%rbp,4)
movups %xmm0,-0x30(%rsi,%rbp,4)
add    $0xfffffffffffffff0,%rbp
add    $0xfffffffffffffffe,%rdx
jne    1870 <v_move+0x750>
neg    %rbp
jmp    198b <v_move+0x86b>
add    $0x1,%rcx
mov    %rcx,%rdx
movabs $0x1fffffff8,%rsi
and    %rsi,%rdx
lea    -0x8(%rdx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdi,%rdi
je     197f <v_move+0x85f>
movabs $0x3ffffffffffffffc,%rdi
ff ff 3f
lea    0x2(%rdi),%rbp
and    %rsi,%rbp
lea    0x3c(%rsp),%rdi
lea    (%rdi,%r15,4),%rbx
add    $0xfffffffffffffff4,%rbx
xor    %edi,%edi
nopl   0x0(%rax)
movups -0x10(%rbx,%rdi,4),%xmm0
movups (%rbx,%rdi,4),%xmm1
movups %xmm1,-0x10(%r12,%rdi,4)
movups %xmm0,-0x20(%r12,%rdi,4)
movups -0x30(%rbx,%rdi,4),%xmm0
movups -0x20(%rbx,%rdi,4),%xmm1
movups %xmm1,-0x30(%r12,%rdi,4)
movups %xmm0,-0x40(%r12,%rdi,4)
add    $0xfffffffffffffff0,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1900 <v_move+0x7e0>
neg    %rdi
test   $0x1,%sil
je     195e <v_move+0x83e>
shl    $0x2,%rdi
mov    %r12,%rsi
sub    %rdi,%rsi
mov    %rax,%rbp
sub    %rdi,%rbp
movups -0x20(%rbp),%xmm0
movups -0x10(%rbp),%xmm1
movups %xmm1,-0x10(%rsi)
movups %xmm0,-0x20(%rsi)
cmp    %rdx,%rcx
je     1620 <v_move+0x500>
lea    0x0(,%rdx,4),%rcx
sub    %rcx,%r12
sub    %rcx,%rax
mov    %r11d,%ecx
sub    %edx,%ecx
jmp    1789 <v_move+0x669>
xor    %edi,%edi
test   $0x1,%sil
jne    193e <v_move+0x81e>
jmp    195e <v_move+0x83e>
xor    %ebp,%ebp
lea    0x0(,%r8,4),%rdx
test   $0x1,%dil
je     19b9 <v_move+0x899>
shl    $0x2,%rbp
mov    %r12,%rsi
sub    %rbp,%rsi
mov    %r14,%rdi
sub    %rbp,%rdi
movups -0x20(%rdi),%xmm0
movups -0x10(%rdi),%xmm1
movups %xmm1,-0x10(%rsi)
movups %xmm0,-0x20(%rsi)
sub    %rdx,%r12
cmp    %r8,%rcx
jne    19d2 <v_move+0x8b2>
mov    %ebx,%r8d
test   %r13d,%r13d
jg     1721 <v_move+0x601>
jmp    1620 <v_move+0x500>
sub    %rdx,%r14
sub    %r8d,%eax
mov    %ebx,%r8d
jmp    16f3 <v_move+0x5d3>
add    $0x4048,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @v_move(i8* %0, i32 %1, i32 %2, i32 %3, i32 %4) {
%6 = alloca [4096 x i32]
%7 = bitcast [4096 x i32]* %6 to i8*
%8 = icmp ne i8* %0, null
%9 = or i32 %2, %1
%10 = or i32 %9, %3
%11 = icmp sgt i32 %10, -1
%12 = and i1 %8, %11
%13 = xor i32 %4, -1
%14 = lshr i32 %13, 31
%15 = select i1 %12, i32 %14, i32 0
%16 = tail call i32 @assert(i32 %15)
%17 = sdiv i32 %4, 4
%18 = mul nsw i32 %17, %3
%19 = mul nsw i32 %17, %1
%20 = mul nsw i32 %17, %2
%21 = add nsw i32 %19, %20
%22 = icmp sgt i32 %18, %19
%23 = select i1 %22, i32 %19, i32 %18
%24 = select i1 %22, i32 %21, i32 %19
%25 = select i1 %22, i32 %18, i32 %21
%26 = sub nsw i32 %24, %23
%27 = sub nsw i32 %25, %24
%28 = icmp slt i32 %26, %27
br i1 %28, label %38, label %29
29: ; preds = %5
%30 = icmp sgt i32 %25, %24
br i1 %30, label %31, label %600
31: ; preds = %29
%32 = bitcast i8* %0 to i32*
%33 = getelementptr [4096 x i32], [4096 x i32]* %6, i64 0, i64 -1
%34 = getelementptr i8, i8* %0, i64 -4
%35 = getelementptr [4096 x i32], [4096 x i32]* %6, i64 0, i64 -1
%36 = getelementptr i8, i8* %0, i64 -4
%37 = getelementptr i8, i8* %0, i64 -4
br label %315
38: ; preds = %5
%39 = icmp sgt i32 %24, %23
br i1 %39, label %40, label %600
40: ; preds = %38
%41 = bitcast i8* %0 to i32*
%42 = getelementptr inbounds [4096 x i32], [4096 x i32]* %6, i64 0, i64 0
%43 = getelementptr i8, i8* %0, i64 4
%44 = getelementptr inbounds [4096 x i32], [4096 x i32]* %6, i64 0, i64 1
%45 = getelementptr i8, i8* %0, i64 4
br label %46
46: ; preds = %40, %311
%47 = phi i32 [ %25, %40 ], [ %313, %311 ]
%48 = phi i32 [ %24, %40 ], [ %312, %311 ]
%49 = sub i32 %48, %23
%50 = icmp slt i32 %49, 4096
%51 = select i1 %50, i32 %49, i32 4096
%52 = sext i32 %48 to i64
%53 = getelementptr inbounds i32, i32* %41, i64 %52
%54 = sext i32 %51 to i64
%55 = sub nsw i64 0, %54
%56 = getelementptr inbounds i32, i32* %53, i64 %55
%57 = icmp sgt i32 %49, 0
br i1 %57, label %58, label %72
58: ; preds = %46
%59 = shl nsw i64 %52, 2
%60 = shl nsw i64 %54, 2
%61 = sub nsw i64 %59, %60
%62 = getelementptr i8, i8* %0, i64 %61
%63 = call i32 @llvm.smin.i32(i32 %49, i32 1)
%64 = sub i32 %51, %63
%65 = zext i32 %64 to i64
%66 = shl nuw nsw i64 %65, 2
%67 = add nuw nsw i64 %66, 4
%68 = add nsw i64 %59, %66
%69 = sub nsw i64 %68, %60
%70 = getelementptr i8, i8* %43, i64 %69
%71 = bitcast i8* %70 to i32*
br label %72
72: ; preds = %58, %46
%73 = phi i32* [ %56, %46 ], [ %71, %58 ]
%74 = bitcast i32* %73 to i8*
%75 = sub i32 %47, %48
%76 = icmp sgt i32 %75, 0
br i1 %76, label %77, label %187
77: ; preds = %72
%78 = xor i32 %48, -1
%79 = add i32 %47, %78
%80 = zext i32 %79 to i64
%81 = add nuw nsw i64 %80, 1
%82 = icmp ult i32 %79, 7
br i1 %82, label %183, label %83
83: ; preds = %77
%84 = sub nsw i64 %52, %54
%85 = shl nsw i64 %84, 2
%86 = getelementptr i8, i8* %0, i64 %85
%87 = xor i32 %48, -1
%88 = add i32 %47, %87
%89 = zext i32 %88 to i64
%90 = add nsw i64 %52, %89
%91 = sub nsw i64 %90, %54
%92 = shl nsw i64 %91, 2
%93 = getelementptr i8, i8* %45, i64 %92
%94 = getelementptr i32, i32* %73, i64 1
%95 = getelementptr i32, i32* %94, i64 %89
%96 = bitcast i32* %95 to i8*
%97 = icmp ult i8* %86, %96
%98 = icmp ugt i8* %93, %74
%99 = and i1 %97, %98
br i1 %99, label %183, label %100
100: ; preds = %83
%101 = and i64 %81, 8589934584
%102 = getelementptr i32, i32* %56, i64 %101
%103 = getelementptr i32, i32* %73, i64 %101
%104 = trunc i64 %101 to i32
%105 = sub i32 %75, %104
%106 = add nsw i64 %101, -8
%107 = lshr exact i64 %106, 3
%108 = add nuw nsw i64 %107, 1
%109 = and i64 %108, 3
%110 = icmp ult i64 %106, 24
br i1 %110, label %162, label %111
111: ; preds = %100
%112 = and i64 %108, 4611686018427387900
br label %113
113: ; preds = %113, %111
%114 = phi i64 [ 0, %111 ], [ %159, %113 ]
%115 = phi i64 [ 0, %111 ], [ %160, %113 ]
%116 = getelementptr i32, i32* %56, i64 %114
%117 = getelementptr i32, i32* %73, i64 %114
%118 = bitcast i32* %117 to <4 x i32>*
%119 = load <4 x i32>, <4 x i32>* %118
%120 = getelementptr i32, i32* %117, i64 4
%121 = bitcast i32* %120 to <4 x i32>*
%122 = load <4 x i32>, <4 x i32>* %121
%123 = bitcast i32* %116 to <4 x i32>*
store <4 x i32> %119, <4 x i32>* %123
%124 = getelementptr i32, i32* %116, i64 4
%125 = bitcast i32* %124 to <4 x i32>*
store <4 x i32> %122, <4 x i32>* %125
%126 = or i64 %114, 8
%127 = getelementptr i32, i32* %56, i64 %126
%128 = getelementptr i32, i32* %73, i64 %126
%129 = bitcast i32* %128 to <4 x i32>*
%130 = load <4 x i32>, <4 x i32>* %129
%131 = getelementptr i32, i32* %128, i64 4
%132 = bitcast i32* %131 to <4 x i32>*
%133 = load <4 x i32>, <4 x i32>* %132
%134 = bitcast i32* %127 to <4 x i32>*
store <4 x i32> %130, <4 x i32>* %134
%135 = getelementptr i32, i32* %127, i64 4
%136 = bitcast i32* %135 to <4 x i32>*
store <4 x i32> %133, <4 x i32>* %136
%137 = or i64 %114, 16
%138 = getelementptr i32, i32* %56, i64 %137
%139 = getelementptr i32, i32* %73, i64 %137
%140 = bitcast i32* %139 to <4 x i32>*
%141 = load <4 x i32>, <4 x i32>* %140
%142 = getelementptr i32, i32* %139, i64 4
%143 = bitcast i32* %142 to <4 x i32>*
%144 = load <4 x i32>, <4 x i32>* %143
%145 = bitcast i32* %138 to <4 x i32>*
store <4 x i32> %141, <4 x i32>* %145
%146 = getelementptr i32, i32* %138, i64 4
%147 = bitcast i32* %146 to <4 x i32>*
store <4 x i32> %144, <4 x i32>* %147
%148 = or i64 %114, 24
%149 = getelementptr i32, i32* %56, i64 %148
%150 = getelementptr i32, i32* %73, i64 %148
%151 = bitcast i32* %150 to <4 x i32>*
%152 = load <4 x i32>, <4 x i32>* %151
%153 = getelementptr i32, i32* %150, i64 4
%154 = bitcast i32* %153 to <4 x i32>*
%155 = load <4 x i32>, <4 x i32>* %154
%156 = bitcast i32* %149 to <4 x i32>*
store <4 x i32> %152, <4 x i32>* %156
%157 = getelementptr i32, i32* %149, i64 4
%158 = bitcast i32* %157 to <4 x i32>*
store <4 x i32> %155, <4 x i32>* %158
%159 = add nuw i64 %114, 32
%160 = add i64 %115, 4
%161 = icmp eq i64 %160, %112
br i1 %161, label %162, label %113
162: ; preds = %113, %100
%163 = phi i64 [ 0, %100 ], [ %159, %113 ]
%164 = icmp eq i64 %109, 0
br i1 %164, label %181, label %165
165: ; preds = %162, %165
%166 = phi i64 [ %178, %165 ], [ %163, %162 ]
%167 = phi i64 [ %179, %165 ], [ 0, %162 ]
%168 = getelementptr i32, i32* %56, i64 %166
%169 = getelementptr i32, i32* %73, i64 %166
%170 = bitcast i32* %169 to <4 x i32>*
%171 = load <4 x i32>, <4 x i32>* %170
%172 = getelementptr i32, i32* %169, i64 4
%173 = bitcast i32* %172 to <4 x i32>*
%174 = load <4 x i32>, <4 x i32>* %173
%175 = bitcast i32* %168 to <4 x i32>*
store <4 x i32> %171, <4 x i32>* %175
%176 = getelementptr i32, i32* %168, i64 4
%177 = bitcast i32* %176 to <4 x i32>*
store <4 x i32> %174, <4 x i32>* %177
%178 = add nuw i64 %166, 8
%179 = add i64 %167, 1
%180 = icmp eq i64 %179, %109
br i1 %180, label %181, label %165
181: ; preds = %165, %162
%182 = icmp eq i64 %81, %101
br i1 %182, label %187, label %183
183: ; preds = %83, %77, %181
%184 = phi i32* [ %56, %83 ], [ %56, %77 ], [ %102, %181 ]
%185 = phi i32* [ %73, %83 ], [ %73, %77 ], [ %103, %181 ]
%186 = phi i32 [ %75, %83 ], [ %75, %77 ], [ %105, %181 ]
br label %293
187: ; preds = %293, %181, %72
%188 = phi i32* [ %56, %72 ], [ %102, %181 ], [ %300, %293 ]
br i1 %57, label %189, label %311
189: ; preds = %187
%190 = call i32 @llvm.smin.i32(i32 %49, i32 1)
%191 = sub i32 %51, %190
%192 = zext i32 %191 to i64
%193 = add nuw nsw i64 %192, 1
%194 = icmp ult i32 %191, 7
br i1 %194, label %289, label %195
195: ; preds = %189
%196 = getelementptr i32, i32* %188, i64 1
%197 = call i32 @llvm.smin.i32(i32 %49, i32 1)
%198 = sub i32 %51, %197
%199 = zext i32 %198 to i64
%200 = getelementptr i32, i32* %196, i64 %199
%201 = getelementptr i32, i32* %44, i64 %199
%202 = icmp ult i32* %188, %201
%203 = bitcast i32* %200 to [4096 x i32]*
%204 = icmp ult [4096 x i32]* %6, %203
%205 = and i1 %202, %204
br i1 %205, label %289, label %206
206: ; preds = %195
%207 = and i64 %193, 8589934584
%208 = getelementptr i32, i32* %188, i64 %207
%209 = getelementptr [4096 x i32], [4096 x i32]* %6, i64 0, i64 %207
%210 = trunc i64 %207 to i32
%211 = sub i32 %51, %210
%212 = add nsw i64 %207, -8
%213 = lshr exact i64 %212, 3
%214 = add nuw nsw i64 %213, 1
%215 = and i64 %214, 3
%216 = icmp ult i64 %212, 24
br i1 %216, label %268, label %217
217: ; preds = %206
%218 = and i64 %214, 4611686018427387900
br label %219
219: ; preds = %219, %217
%220 = phi i64 [ 0, %217 ], [ %265, %219 ]
%221 = phi i64 [ 0, %217 ], [ %266, %219 ]
%222 = getelementptr i32, i32* %188, i64 %220
%223 = getelementptr [4096 x i32], [4096 x i32]* %6, i64 0, i64 %220
%224 = bitcast i32* %223 to <4 x i32>*
%225 = load <4 x i32>, <4 x i32>* %224
%226 = getelementptr i32, i32* %223, i64 4
%227 = bitcast i32* %226 to <4 x i32>*
%228 = load <4 x i32>, <4 x i32>* %227
%229 = bitcast i32* %222 to <4 x i32>*
store <4 x i32> %225, <4 x i32>* %229
%230 = getelementptr i32, i32* %222, i64 4
%231 = bitcast i32* %230 to <4 x i32>*
store <4 x i32> %228, <4 x i32>* %231
%232 = or i64 %220, 8
%233 = getelementptr i32, i32* %188, i64 %232
%234 = getelementptr [4096 x i32], [4096 x i32]* %6, i64 0, i64 %232
%235 = bitcast i32* %234 to <4 x i32>*
%236 = load <4 x i32>, <4 x i32>* %235
%237 = getelementptr i32, i32* %234, i64 4
%238 = bitcast i32* %237 to <4 x i32>*
%239 = load <4 x i32>, <4 x i32>* %238
%240 = bitcast i32* %233 to <4 x i32>*
store <4 x i32> %236, <4 x i32>* %240
%241 = getelementptr i32, i32* %233, i64 4
%242 = bitcast i32* %241 to <4 x i32>*
store <4 x i32> %239, <4 x i32>* %242
%243 = or i64 %220, 16
%244 = getelementptr i32, i32* %188, i64 %243
%245 = getelementptr [4096 x i32], [4096 x i32]* %6, i64 0, i64 %243
%246 = bitcast i32* %245 to <4 x i32>*
%247 = load <4 x i32>, <4 x i32>* %246
%248 = getelementptr i32, i32* %245, i64 4
%249 = bitcast i32* %248 to <4 x i32>*
%250 = load <4 x i32>, <4 x i32>* %249
%251 = bitcast i32* %244 to <4 x i32>*
store <4 x i32> %247, <4 x i32>* %251
%252 = getelementptr i32, i32* %244, i64 4
%253 = bitcast i32* %252 to <4 x i32>*
store <4 x i32> %250, <4 x i32>* %253
%254 = or i64 %220, 24
%255 = getelementptr i32, i32* %188, i64 %254
%256 = getelementptr [4096 x i32], [4096 x i32]* %6, i64 0, i64 %254
%257 = bitcast i32* %256 to <4 x i32>*
%258 = load <4 x i32>, <4 x i32>* %257
%259 = getelementptr i32, i32* %256, i64 4
%260 = bitcast i32* %259 to <4 x i32>*
%261 = load <4 x i32>, <4 x i32>* %260
%262 = bitcast i32* %255 to <4 x i32>*
store <4 x i32> %258, <4 x i32>* %262
%263 = getelementptr i32, i32* %255, i64 4
%264 = bitcast i32* %263 to <4 x i32>*
store <4 x i32> %261, <4 x i32>* %264
%265 = add nuw i64 %220, 32
%266 = add i64 %221, 4
%267 = icmp eq i64 %266, %218
br i1 %267, label %268, label %219
268: ; preds = %219, %206
%269 = phi i64 [ 0, %206 ], [ %265, %219 ]
%270 = icmp eq i64 %215, 0
br i1 %270, label %287, label %271
271: ; preds = %268, %271
%272 = phi i64 [ %284, %271 ], [ %269, %268 ]
%273 = phi i64 [ %285, %271 ], [ 0, %268 ]
%274 = getelementptr i32, i32* %188, i64 %272
%275 = getelementptr [4096 x i32], [4096 x i32]* %6, i64 0, i64 %272
%276 = bitcast i32* %275 to <4 x i32>*
%277 = load <4 x i32>, <4 x i32>* %276
%278 = getelementptr i32, i32* %275, i64 4
%279 = bitcast i32* %278 to <4 x i32>*
%280 = load <4 x i32>, <4 x i32>* %279
%281 = bitcast i32* %274 to <4 x i32>*
store <4 x i32> %277, <4 x i32>* %281
%282 = getelementptr i32, i32* %274, i64 4
%283 = bitcast i32* %282 to <4 x i32>*
store <4 x i32> %280, <4 x i32>* %283
%284 = add nuw i64 %272, 8
%285 = add i64 %273, 1
%286 = icmp eq i64 %285, %215
br i1 %286, label %287, label %271
287: ; preds = %271, %268
%288 = icmp eq i64 %193, %207
br i1 %288, label %311, label %289
289: ; preds = %195, %189, %287
%290 = phi i32* [ %188, %195 ], [ %188, %189 ], [ %208, %287 ]
%291 = phi i32* [ %42, %195 ], [ %42, %189 ], [ %209, %287 ]
%292 = phi i32 [ %51, %195 ], [ %51, %189 ], [ %211, %287 ]
br label %302
293: ; preds = %183, %293
%294 = phi i32* [ %300, %293 ], [ %184, %183 ]
%295 = phi i32* [ %298, %293 ], [ %185, %183 ]
%296 = phi i32 [ %297, %293 ], [ %186, %183 ]
%297 = add nsw i32 %296, -1
%298 = getelementptr inbounds i32, i32* %295, i64 1
%299 = load i32, i32* %295
%300 = getelementptr inbounds i32, i32* %294, i64 1
store i32 %299, i32* %294
%301 = icmp ugt i32 %296, 1
br i1 %301, label %293, label %187
302: ; preds = %289, %302
%303 = phi i32* [ %309, %302 ], [ %290, %289 ]
%304 = phi i32* [ %307, %302 ], [ %291, %289 ]
%305 = phi i32 [ %306, %302 ], [ %292, %289 ]
%306 = add nsw i32 %305, -1
%307 = getelementptr inbounds i32, i32* %304, i64 1
%308 = load i32, i32* %304
%309 = getelementptr inbounds i32, i32* %303, i64 1
store i32 %308, i32* %303
%310 = icmp sgt i32 %305, 1
br i1 %310, label %302, label %311
311: ; preds = %302, %287, %187
%312 = sub nsw i32 %48, %51
%313 = sub nsw i32 %47, %51
%314 = icmp sgt i32 %312, %23
br i1 %314, label %46, label %600
315: ; preds = %31, %596
%316 = phi i32 [ %24, %31 ], [ %597, %596 ]
%317 = phi i32 [ %23, %31 ], [ %598, %596 ]
%318 = sub i32 %25, %316
%319 = icmp slt i32 %318, 4096
%320 = select i1 %319, i32 %318, i32 4096
%321 = sext i32 %316 to i64
%322 = getelementptr inbounds i32, i32* %32, i64 %321
%323 = sext i32 %320 to i64
%324 = getelementptr inbounds i32, i32* %322, i64 %323
%325 = getelementptr inbounds [4096 x i32], [4096 x i32]* %6, i64 0, i64 %323
%326 = icmp sgt i32 %318, 0
br i1 %326, label %327, label %341
327: ; preds = %315
%328 = call i32 @llvm.smin.i32(i32 %318, i32 1)
%329 = sub i32 %320, %328
%330 = zext i32 %329 to i64
%331 = sub nsw i64 %323, %330
%332 = getelementptr i32, i32* %33, i64 %331
%333 = bitcast i32* %332 to i8*
%334 = add nsw i64 %321, %323
%335 = shl nuw nsw i64 %330, 2
%336 = sub nsw i64 %334, %330
%337 = shl nsw i64 %336, 2
%338 = getelementptr i8, i8* %34, i64 %337
%339 = add nuw nsw i64 %335, 4
%340 = bitcast i8* %338 to i32*
br label %341
341: ; preds = %327, %315
%342 = phi i32* [ %324, %315 ], [ %340, %327 ]
%343 = bitcast i32* %342 to i8*
%344 = sub i32 %316, %317
%345 = icmp sgt i32 %344, 0
br i1 %345, label %346, label %472
346: ; preds = %341
%347 = xor i32 %317, -1
%348 = add i32 %316, %347
%349 = zext i32 %348 to i64
%350 = add nuw nsw i64 %349, 1
%351 = icmp ult i32 %348, 7
br i1 %351, label %468, label %352
352: ; preds = %346
%353 = xor i32 %317, -1
%354 = add i32 %316, %353
%355 = add nsw i64 %321, %323
%356 = shl nsw i64 %355, 2
%357 = getelementptr i8, i8* %36, i64 %356
%358 = zext i32 %354 to i64
%359 = mul nsw i64 %358, -4
%360 = getelementptr i8, i8* %357, i64 %359
%361 = icmp ugt i8* %360, %357
%362 = getelementptr i32, i32* %342, i64 -1
%363 = zext i32 %354 to i64
%364 = sub nsw i64 0, %363
%365 = getelementptr i32, i32* %362, i64 %364
%366 = icmp ugt i32* %365, %362
%367 = or i1 %361, %366
br i1 %367, label %468, label %368
368: ; preds = %352
%369 = shl nsw i64 %321, 2
%370 = shl nsw i64 %323, 2
%371 = add nsw i64 %369, %370
%372 = xor i32 %317, -1
%373 = add i32 %316, %372
%374 = zext i32 %373 to i64
%375 = mul nsw i64 %374, -4
%376 = add nsw i64 %375, %371
%377 = getelementptr i8, i8* %37, i64 %376
%378 = add nsw i64 %369, %370
%379 = getelementptr i8, i8* %0, i64 %378
%380 = getelementptr i32, i32* %342, i64 -1
%381 = sub nsw i64 0, %374
%382 = getelementptr i32, i32* %380, i64 %381
%383 = bitcast i32* %382 to i8*
%384 = icmp ult i8* %377, %343
%385 = icmp ugt i8* %379, %383
%386 = and i1 %384, %385
br i1 %386, label %468, label %387
387: ; preds = %368
%388 = and i64 %350, 8589934584
%389 = sub nsw i64 0, %388
%390 = getelementptr i32, i32* %324, i64 %389
%391 = sub nsw i64 0, %388
%392 = getelementptr i32, i32* %342, i64 %391
%393 = trunc i64 %388 to i32
%394 = sub i32 %344, %393
%395 = add nsw i64 %388, -8
%396 = lshr exact i64 %395, 3
%397 = add nuw nsw i64 %396, 1
%398 = and i64 %397, 1
%399 = icmp eq i64 %395, 0
br i1 %399, label %444, label %400
400: ; preds = %387
%401 = and i64 %397, 4611686018427387902
%402 = getelementptr i32, i32* %324, i64 -1
%403 = getelementptr i32, i32* %342, i64 -1
%404 = getelementptr i32, i32* %324, i64 -1
%405 = getelementptr i32, i32* %342, i64 -1
br label %406
406: ; preds = %406, %400
%407 = phi i64 [ 0, %400 ], [ %441, %406 ]
%408 = phi i64 [ 0, %400 ], [ %442, %406 ]
%409 = sub i64 0, %407
%410 = sub i64 0, %407
%411 = getelementptr inbounds i32, i32* %403, i64 %410
%412 = getelementptr inbounds i32, i32* %411, i64 -3
%413 = bitcast i32* %412 to <4 x i32>*
%414 = load <4 x i32>, <4 x i32>* %413
%415 = getelementptr inbounds i32, i32* %411, i64 -4
%416 = getelementptr inbounds i32, i32* %415, i64 -3
%417 = bitcast i32* %416 to <4 x i32>*
%418 = load <4 x i32>, <4 x i32>* %417
%419 = getelementptr inbounds i32, i32* %402, i64 %409
%420 = getelementptr inbounds i32, i32* %419, i64 -3
%421 = bitcast i32* %420 to <4 x i32>*
store <4 x i32> %414, <4 x i32>* %421
%422 = getelementptr inbounds i32, i32* %419, i64 -4
%423 = getelementptr inbounds i32, i32* %422, i64 -3
%424 = bitcast i32* %423 to <4 x i32>*
store <4 x i32> %418, <4 x i32>* %424
%425 = sub nuw nsw i64 -8, %407
%426 = sub nuw nsw i64 -8, %407
%427 = getelementptr inbounds i32, i32* %405, i64 %426
%428 = getelementptr inbounds i32, i32* %427, i64 -3
%429 = bitcast i32* %428 to <4 x i32>*
%430 = load <4 x i32>, <4 x i32>* %429
%431 = getelementptr inbounds i32, i32* %427, i64 -4
%432 = getelementptr inbounds i32, i32* %431, i64 -3
%433 = bitcast i32* %432 to <4 x i32>*
%434 = load <4 x i32>, <4 x i32>* %433
%435 = getelementptr inbounds i32, i32* %404, i64 %425
%436 = getelementptr inbounds i32, i32* %435, i64 -3
%437 = bitcast i32* %436 to <4 x i32>*
store <4 x i32> %430, <4 x i32>* %437
%438 = getelementptr inbounds i32, i32* %435, i64 -4
%439 = getelementptr inbounds i32, i32* %438, i64 -3
%440 = bitcast i32* %439 to <4 x i32>*
store <4 x i32> %434, <4 x i32>* %440
%441 = add nuw i64 %407, 16
%442 = add i64 %408, 2
%443 = icmp eq i64 %442, %401
br i1 %443, label %444, label %406
444: ; preds = %406, %387
%445 = phi i64 [ 0, %387 ], [ %441, %406 ]
%446 = icmp eq i64 %398, 0
br i1 %446, label %466, label %447
447: ; preds = %444
%448 = sub i64 0, %445
%449 = getelementptr i32, i32* %324, i64 -1
%450 = sub i64 0, %445
%451 = getelementptr i32, i32* %342, i64 -1
%452 = getelementptr inbounds i32, i32* %451, i64 %450
%453 = getelementptr inbounds i32, i32* %452, i64 -3
%454 = bitcast i32* %453 to <4 x i32>*
%455 = load <4 x i32>, <4 x i32>* %454
%456 = getelementptr inbounds i32, i32* %452, i64 -4
%457 = getelementptr inbounds i32, i32* %456, i64 -3
%458 = bitcast i32* %457 to <4 x i32>*
%459 = load <4 x i32>, <4 x i32>* %458
%460 = getelementptr inbounds i32, i32* %449, i64 %448
%461 = getelementptr inbounds i32, i32* %460, i64 -3
%462 = bitcast i32* %461 to <4 x i32>*
store <4 x i32> %455, <4 x i32>* %462
%463 = getelementptr inbounds i32, i32* %460, i64 -4
%464 = getelementptr inbounds i32, i32* %463, i64 -3
%465 = bitcast i32* %464 to <4 x i32>*
store <4 x i32> %459, <4 x i32>* %465
br label %466
466: ; preds = %444, %447
%467 = icmp eq i64 %350, %388
br i1 %467, label %472, label %468
468: ; preds = %368, %352, %346, %466
%469 = phi i32* [ %324, %368 ], [ %324, %352 ], [ %324, %346 ], [ %390, %466 ]
%470 = phi i32* [ %342, %368 ], [ %342, %352 ], [ %342, %346 ], [ %392, %466 ]
%471 = phi i32 [ %344, %368 ], [ %344, %352 ], [ %344, %346 ], [ %394, %466 ]
br label %578
472: ; preds = %578, %466, %341
%473 = phi i32* [ %324, %341 ], [ %390, %466 ], [ %585, %578 ]
br i1 %326, label %474, label %596
474: ; preds = %472
%475 = call i32 @llvm.smin.i32(i32 %318, i32 1)
%476 = sub i32 %320, %475
%477 = zext i32 %476 to i64
%478 = add nuw nsw i64 %477, 1
%479 = icmp ult i32 %476, 7
br i1 %479, label %574, label %480
480: ; preds = %474
%481 = getelementptr i32, i32* %473, i64 -1
%482 = call i32 @llvm.smin.i32(i32 %318, i32 1)
%483 = sub i32 %320, %482
%484 = zext i32 %483 to i64
%485 = sub nsw i64 0, %484
%486 = getelementptr i32, i32* %481, i64 %485
%487 = sub nsw i64 %323, %484
%488 = getelementptr i32, i32* %35, i64 %487
%489 = getelementptr [4096 x i32], [4096 x i32]* %6, i64 0, i64 %323
%490 = icmp ult i32* %486, %489
%491 = icmp ult i32* %488, %473
%492 = and i1 %490, %491
br i1 %492, label %574, label %493
493: ; preds = %480
%494 = and i64 %478, 8589934584
%495 = sub nsw i64 0, %494
%496 = getelementptr i32, i32* %473, i64 %495
%497 = sub nsw i64 0, %494
%498 = getelementptr i32, i32* %325, i64 %497
%499 = trunc i64 %494 to i32
%500 = sub i32 %320, %499
%501 = add nsw i64 %494, -8
%502 = lshr exact i64 %501, 3
%503 = add nuw nsw i64 %502, 1
%504 = and i64 %503, 1
%505 = icmp eq i64 %501, 0
br i1 %505, label %550, label %506
506: ; preds = %493
%507 = and i64 %503, 4611686018427387902
%508 = getelementptr i32, i32* %473, i64 -1
%509 = getelementptr i32, i32* %325, i64 -1
%510 = getelementptr i32, i32* %473, i64 -1
%511 = getelementptr i32, i32* %325, i64 -1
br label %512
512: ; preds = %512, %506
%513 = phi i64 [ 0, %506 ], [ %547, %512 ]
%514 = phi i64 [ 0, %506 ], [ %548, %512 ]
%515 = sub i64 0, %513
%516 = sub i64 0, %513
%517 = getelementptr inbounds i32, i32* %509, i64 %516
%518 = getelementptr inbounds i32, i32* %517, i64 -3
%519 = bitcast i32* %518 to <4 x i32>*
%520 = load <4 x i32>, <4 x i32>* %519
%521 = getelementptr inbounds i32, i32* %517, i64 -4
%522 = getelementptr inbounds i32, i32* %521, i64 -3
%523 = bitcast i32* %522 to <4 x i32>*
%524 = load <4 x i32>, <4 x i32>* %523
%525 = getelementptr inbounds i32, i32* %508, i64 %515
%526 = getelementptr inbounds i32, i32* %525, i64 -3
%527 = bitcast i32* %526 to <4 x i32>*
store <4 x i32> %520, <4 x i32>* %527
%528 = getelementptr inbounds i32, i32* %525, i64 -4
%529 = getelementptr inbounds i32, i32* %528, i64 -3
%530 = bitcast i32* %529 to <4 x i32>*
store <4 x i32> %524, <4 x i32>* %530
%531 = sub nuw nsw i64 -8, %513
%532 = sub nuw nsw i64 -8, %513
%533 = getelementptr inbounds i32, i32* %511, i64 %532
%534 = getelementptr inbounds i32, i32* %533, i64 -3
%535 = bitcast i32* %534 to <4 x i32>*
%536 = load <4 x i32>, <4 x i32>* %535
%537 = getelementptr inbounds i32, i32* %533, i64 -4
%538 = getelementptr inbounds i32, i32* %537, i64 -3
%539 = bitcast i32* %538 to <4 x i32>*
%540 = load <4 x i32>, <4 x i32>* %539
%541 = getelementptr inbounds i32, i32* %510, i64 %531
%542 = getelementptr inbounds i32, i32* %541, i64 -3
%543 = bitcast i32* %542 to <4 x i32>*
store <4 x i32> %536, <4 x i32>* %543
%544 = getelementptr inbounds i32, i32* %541, i64 -4
%545 = getelementptr inbounds i32, i32* %544, i64 -3
%546 = bitcast i32* %545 to <4 x i32>*
store <4 x i32> %540, <4 x i32>* %546
%547 = add nuw i64 %513, 16
%548 = add i64 %514, 2
%549 = icmp eq i64 %548, %507
br i1 %549, label %550, label %512
550: ; preds = %512, %493
%551 = phi i64 [ 0, %493 ], [ %547, %512 ]
%552 = icmp eq i64 %504, 0
br i1 %552, label %572, label %553
553: ; preds = %550
%554 = sub i64 0, %551
%555 = getelementptr i32, i32* %473, i64 -1
%556 = sub i64 0, %551
%557 = getelementptr i32, i32* %325, i64 -1
%558 = getelementptr inbounds i32, i32* %557, i64 %556
%559 = getelementptr inbounds i32, i32* %558, i64 -3
%560 = bitcast i32* %559 to <4 x i32>*
%561 = load <4 x i32>, <4 x i32>* %560
%562 = getelementptr inbounds i32, i32* %558, i64 -4
%563 = getelementptr inbounds i32, i32* %562, i64 -3
%564 = bitcast i32* %563 to <4 x i32>*
%565 = load <4 x i32>, <4 x i32>* %564
%566 = getelementptr inbounds i32, i32* %555, i64 %554
%567 = getelementptr inbounds i32, i32* %566, i64 -3
%568 = bitcast i32* %567 to <4 x i32>*
store <4 x i32> %561, <4 x i32>* %568
%569 = getelementptr inbounds i32, i32* %566, i64 -4
%570 = getelementptr inbounds i32, i32* %569, i64 -3
%571 = bitcast i32* %570 to <4 x i32>*
store <4 x i32> %565, <4 x i32>* %571
br label %572
572: ; preds = %550, %553
%573 = icmp eq i64 %478, %494
br i1 %573, label %596, label %574
574: ; preds = %480, %474, %572
%575 = phi i32* [ %473, %480 ], [ %473, %474 ], [ %496, %572 ]
%576 = phi i32* [ %325, %480 ], [ %325, %474 ], [ %498, %572 ]
%577 = phi i32 [ %320, %480 ], [ %320, %474 ], [ %500, %572 ]
br label %587
578: ; preds = %468, %578
%579 = phi i32* [ %585, %578 ], [ %469, %468 ]
%580 = phi i32* [ %583, %578 ], [ %470, %468 ]
%581 = phi i32 [ %582, %578 ], [ %471, %468 ]
%582 = add nsw i32 %581, -1
%583 = getelementptr inbounds i32, i32* %580, i64 -1
%584 = load i32, i32* %583
%585 = getelementptr inbounds i32, i32* %579, i64 -1
store i32 %584, i32* %585
%586 = icmp ugt i32 %581, 1
br i1 %586, label %578, label %472
587: ; preds = %574, %587
%588 = phi i32* [ %594, %587 ], [ %575, %574 ]
%589 = phi i32* [ %592, %587 ], [ %576, %574 ]
%590 = phi i32 [ %591, %587 ], [ %577, %574 ]
%591 = add nsw i32 %590, -1
%592 = getelementptr inbounds i32, i32* %589, i64 -1
%593 = load i32, i32* %592
%594 = getelementptr inbounds i32, i32* %588, i64 -1
store i32 %593, i32* %594
%595 = icmp sgt i32 %590, 1
br i1 %595, label %587, label %596
596: ; preds = %587, %572, %472
%597 = add nsw i32 %320, %316
%598 = add nsw i32 %320, %317
%599 = icmp sgt i32 %25, %597
br i1 %599, label %315, label %600
600: ; preds = %596, %311, %29, %38
ret void
}