#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 */
typedef int /*<<< orphan*/ uint8_t;
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ fwrite(int /*<<< orphan*/ *, int, int, int /*<<< orphan*/ *);
void save_bank(FILE *fp, int width, uint8_t *glyph, uint8_t *field1,
               uint8_t *field2) {
  for (int ch = 0; ch < 96; ch++) {
    uint8_t *gptr = glyph;
    for (int row = 0; row < 10; row++)
      for (int col = 0; col < width; col++)
        *gptr++ = *field1++ | (*field2++ << 4);
    fwrite(glyph, 10 * width, 1, fp);
  }
}


x86 assembly (clang, -O0):
<save_bank>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x60,-0x2c(%rbp)
jge    11e5 <save_bank+0xd5>
mov    -0x18(%rbp),%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
cmpl   $0xa,-0x3c(%rbp)
jge    11c1 <save_bank+0xb1>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11ae <save_bank+0x9e>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax),%eax
shl    $0x4,%eax
or     %eax,%ecx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x38(%rbp)
mov    %ecx,(%rax)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    115c <save_bank+0x4c>
jmp    11b3 <save_bank+0xa3>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    114b <save_bank+0x3b>
mov    -0x18(%rbp),%rdi
imul   $0xa,-0xc(%rbp),%esi
mov    -0x8(%rbp),%rcx
mov    $0x1,%edx
call   1030 <fwrite@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1132 <save_bank+0x22>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<save_bank>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r8,%r14
mov    %rcx,%rbx
mov    %rdx,%r15
mov    %esi,%r12d
mov    %rdi,0x50(%rsp)
lea    (%r12,%r12,1),%eax
lea    (%rax,%rax,4),%eax
mov    %eax,0x3c(%rsp)
lea    -0x1(%r12),%eax
lea    0x4(%rdx,%rax,4),%rcx
mov    %rcx,0x48(%rsp)
mov    %rax,0x30(%rsp)
add    $0x1,%rax
mov    %rax,0x10(%rsp)
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rcx
mov    %rcx,0x28(%rsp)
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rax,0x8(%rsp)
lea    (%rdx,%rax,4),%rax
mov    %rax,0x40(%rsp)
mov    %rcx,%rax
mov    %rcx,0x20(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x18(%rsp)
xor    %r13d,%r13d
jmp    11b4 <save_bank+0xa4>
mov    %r15,%rdi
mov    0x3c(%rsp),%esi
mov    $0x1,%edx
mov    0x50(%rsp),%rcx
call   1030 <fwrite@plt>
add    $0x1,%r13d
cmp    $0x60,%r13d
je     25aa <save_bank+0x149a>
test   %r12d,%r12d
jle    1190 <save_bank+0x80>
xor    %ebp,%ebp
cmpl   $0x7,0x30(%rsp)
jb     1300 <save_bank+0x1f0>
mov    0x10(%rsp),%rcx
lea    (%rbx,%rcx,4),%rax
lea    (%r14,%rcx,4),%rdx
cmp    %r15,%rax
seta   %sil
mov    0x48(%rsp),%rdi
cmp    %rdi,%rbx
setb   %cl
cmp    %r15,%rdx
seta   %al
cmp    %rdi,%r14
setb   %dl
test   %cl,%sil
jne    1300 <save_bank+0x1f0>
and    %dl,%al
jne    1300 <save_bank+0x1f0>
cmpq   $0x0,0x28(%rsp)
je     1a27 <save_bank+0x917>
mov    0x18(%rsp),%rcx
xor    %eax,%eax
mov    0x8(%rsp),%rdx
nopw   0x0(%rax,%rax,1)
movdqu (%rbx,%rax,4),%xmm0
movdqu 0x10(%rbx,%rax,4),%xmm1
movdqu (%r14,%rax,4),%xmm2
movdqu 0x10(%r14,%rax,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,(%r15,%rax,4)
movdqu %xmm3,0x10(%r15,%rax,4)
movdqu 0x20(%rbx,%rax,4),%xmm0
movdqu 0x30(%rbx,%rax,4),%xmm1
movdqu 0x20(%r14,%rax,4),%xmm2
movdqu 0x30(%r14,%rax,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,0x20(%r15,%rax,4)
movdqu %xmm3,0x30(%r15,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    1220 <save_bank+0x110>
testb  $0x1,0x20(%rsp)
je     12d9 <save_bank+0x1c9>
movdqu (%rbx,%rax,4),%xmm0
movdqu 0x10(%rbx,%rax,4),%xmm1
movdqu (%r14,%rax,4),%xmm2
movdqu 0x10(%r14,%rax,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,(%r15,%rax,4)
movdqu %xmm3,0x10(%r15,%rax,4)
lea    (%r14,%rdx,4),%r14
lea    (%rbx,%rdx,4),%rbx
mov    %edx,%ebp
mov    0x40(%rsp),%rax
cmp    %rdx,0x10(%rsp)
jne    1303 <save_bank+0x1f3>
jmp    13a2 <save_bank+0x292>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r15,%rax
mov    %r12d,%esi
sub    %ebp,%esi
mov    %ebp,%edx
not    %edx
add    %r12d,%edx
and    $0x3,%esi
je     133f <save_bank+0x22f>
neg    %esi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
mov    (%r14),%ecx
add    $0x4,%r14
shl    $0x4,%ecx
or     (%rbx),%ecx
add    $0x4,%rbx
mov    %ecx,(%rax)
add    $0x4,%rax
add    $0xffffffff,%edi
cmp    %edi,%esi
jne    1320 <save_bank+0x210>
sub    %edi,%ebp
cmp    $0x3,%edx
jb     13a2 <save_bank+0x292>
mov    %r12d,%edx
sub    %ebp,%edx
xor    %ecx,%ecx
xor    %esi,%esi
nopl   (%rax)
mov    (%r14,%rsi,4),%edi
shl    $0x4,%edi
or     (%rbx,%rsi,4),%edi
mov    %edi,(%rax,%rsi,4)
mov    0x4(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0x4(%rbx,%rsi,4),%edi
mov    %edi,0x4(%rax,%rsi,4)
mov    0x8(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0x8(%rbx,%rsi,4),%edi
mov    %edi,0x8(%rax,%rsi,4)
mov    0xc(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0xc(%rbx,%rsi,4),%edi
mov    %edi,0xc(%rax,%rsi,4)
add    $0x4,%rsi
add    $0xfffffffffffffff0,%rcx
cmp    %esi,%edx
jne    1350 <save_bank+0x240>
sub    %rcx,%rax
sub    %rcx,%r14
sub    %rcx,%rbx
test   %r12d,%r12d
jle    1190 <save_bank+0x80>
xor    %ebp,%ebp
cmpl   $0x7,0x30(%rsp)
jb     14e0 <save_bank+0x3d0>
mov    0x10(%rsp),%rcx
lea    (%rax,%rcx,4),%rsi
lea    (%rbx,%rcx,4),%rdx
lea    (%r14,%rcx,4),%rdi
cmp    %rdx,%rax
setb   %r8b
cmp    %rsi,%rbx
setb   %cl
cmp    %rdi,%rax
setb   %dl
cmp    %rsi,%r14
setb   %sil
test   %cl,%r8b
jne    14e0 <save_bank+0x3d0>
and    %sil,%dl
jne    14e0 <save_bank+0x3d0>
cmpq   $0x0,0x28(%rsp)
je     23b4 <save_bank+0x12a4>
mov    0x18(%rsp),%rdx
xor    %ecx,%ecx
mov    0x8(%rsp),%rsi
nopl   (%rax)
movdqu (%rbx,%rcx,4),%xmm0
movdqu 0x10(%rbx,%rcx,4),%xmm1
movdqu (%r14,%rcx,4),%xmm2
movdqu 0x10(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,(%rax,%rcx,4)
movdqu %xmm3,0x10(%rax,%rcx,4)
movdqu 0x20(%rbx,%rcx,4),%xmm0
movdqu 0x30(%rbx,%rcx,4),%xmm1
movdqu 0x20(%r14,%rcx,4),%xmm2
movdqu 0x30(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,0x20(%rax,%rcx,4)
movdqu %xmm3,0x30(%rax,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1410 <save_bank+0x300>
testb  $0x1,0x20(%rsp)
je     14c3 <save_bank+0x3b3>
movdqu (%rbx,%rcx,4),%xmm0
movdqu 0x10(%rbx,%rcx,4),%xmm1
movdqu (%r14,%rcx,4),%xmm2
movdqu 0x10(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,(%rax,%rcx,4)
movdqu %xmm3,0x10(%rax,%rcx,4)
lea    (%rax,%rsi,4),%rax
lea    (%r14,%rsi,4),%r14
lea    (%rbx,%rsi,4),%rbx
mov    %esi,%ebp
cmp    %rsi,0x10(%rsp)
je     1582 <save_bank+0x472>
nopl   0x0(%rax)
mov    %r12d,%esi
sub    %ebp,%esi
mov    %ebp,%edx
not    %edx
add    %r12d,%edx
and    $0x3,%esi
je     151f <save_bank+0x40f>
neg    %esi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r14),%ecx
add    $0x4,%r14
shl    $0x4,%ecx
or     (%rbx),%ecx
add    $0x4,%rbx
mov    %ecx,(%rax)
add    $0x4,%rax
add    $0xffffffff,%edi
cmp    %edi,%esi
jne    1500 <save_bank+0x3f0>
sub    %edi,%ebp
cmp    $0x3,%edx
jb     1582 <save_bank+0x472>
mov    %r12d,%edx
sub    %ebp,%edx
xor    %ecx,%ecx
xor    %esi,%esi
nopl   (%rax)
mov    (%r14,%rsi,4),%edi
shl    $0x4,%edi
or     (%rbx,%rsi,4),%edi
mov    %edi,(%rax,%rsi,4)
mov    0x4(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0x4(%rbx,%rsi,4),%edi
mov    %edi,0x4(%rax,%rsi,4)
mov    0x8(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0x8(%rbx,%rsi,4),%edi
mov    %edi,0x8(%rax,%rsi,4)
mov    0xc(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0xc(%rbx,%rsi,4),%edi
mov    %edi,0xc(%rax,%rsi,4)
add    $0x4,%rsi
add    $0xfffffffffffffff0,%rcx
cmp    %esi,%edx
jne    1530 <save_bank+0x420>
sub    %rcx,%rax
sub    %rcx,%r14
sub    %rcx,%rbx
test   %r12d,%r12d
jle    1190 <save_bank+0x80>
xor    %ebp,%ebp
cmpl   $0x7,0x30(%rsp)
jae    1647 <save_bank+0x537>
mov    %r12d,%esi
sub    %ebp,%esi
mov    %ebp,%edx
not    %edx
add    %r12d,%edx
and    $0x3,%esi
je     15cf <save_bank+0x4bf>
neg    %esi
xor    %edi,%edi
nopl   (%rax)
mov    (%r14),%ecx
add    $0x4,%r14
shl    $0x4,%ecx
or     (%rbx),%ecx
add    $0x4,%rbx
mov    %ecx,(%rax)
add    $0x4,%rax
add    $0xffffffff,%edi
cmp    %edi,%esi
jne    15b0 <save_bank+0x4a0>
sub    %edi,%ebp
cmp    $0x3,%edx
jb     1770 <save_bank+0x660>
mov    %r12d,%edx
sub    %ebp,%edx
xor    %ecx,%ecx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r14,%rsi,4),%edi
shl    $0x4,%edi
or     (%rbx,%rsi,4),%edi
mov    %edi,(%rax,%rsi,4)
mov    0x4(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0x4(%rbx,%rsi,4),%edi
mov    %edi,0x4(%rax,%rsi,4)
mov    0x8(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0x8(%rbx,%rsi,4),%edi
mov    %edi,0x8(%rax,%rsi,4)
mov    0xc(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0xc(%rbx,%rsi,4),%edi
mov    %edi,0xc(%rax,%rsi,4)
add    $0x4,%rsi
add    $0xfffffffffffffff0,%rcx
cmp    %esi,%edx
jne    15f0 <save_bank+0x4e0>
sub    %rcx,%rax
sub    %rcx,%r14
sub    %rcx,%rbx
jmp    1770 <save_bank+0x660>
mov    0x10(%rsp),%rcx
lea    (%rax,%rcx,4),%rsi
lea    (%rbx,%rcx,4),%rdx
lea    (%r14,%rcx,4),%rdi
cmp    %rdx,%rax
setb   %r8b
cmp    %rsi,%rbx
setb   %cl
cmp    %rdi,%rax
setb   %dl
cmp    %rsi,%r14
setb   %sil
test   %cl,%r8b
jne    1598 <save_bank+0x488>
and    %sil,%dl
jne    1598 <save_bank+0x488>
cmpq   $0x0,0x28(%rsp)
je     23cb <save_bank+0x12bb>
mov    0x18(%rsp),%rdx
xor    %ecx,%ecx
mov    0x8(%rsp),%rsi
nopl   0x0(%rax)
movdqu (%rbx,%rcx,4),%xmm0
movdqu 0x10(%rbx,%rcx,4),%xmm1
movdqu (%r14,%rcx,4),%xmm2
movdqu 0x10(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,(%rax,%rcx,4)
movdqu %xmm3,0x10(%rax,%rcx,4)
movdqu 0x20(%rbx,%rcx,4),%xmm0
movdqu 0x30(%rbx,%rcx,4),%xmm1
movdqu 0x20(%r14,%rcx,4),%xmm2
movdqu 0x30(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,0x20(%rax,%rcx,4)
movdqu %xmm3,0x30(%rax,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdx
jne    16a0 <save_bank+0x590>
testb  $0x1,0x20(%rsp)
je     1753 <save_bank+0x643>
movdqu (%rbx,%rcx,4),%xmm0
movdqu 0x10(%rbx,%rcx,4),%xmm1
movdqu (%r14,%rcx,4),%xmm2
movdqu 0x10(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,(%rax,%rcx,4)
movdqu %xmm3,0x10(%rax,%rcx,4)
lea    (%rax,%rsi,4),%rax
lea    (%r14,%rsi,4),%r14
lea    (%rbx,%rsi,4),%rbx
mov    %esi,%ebp
cmp    %rsi,0x10(%rsp)
jne    1598 <save_bank+0x488>
nopl   0x0(%rax)
test   %r12d,%r12d
jle    1190 <save_bank+0x80>
xor    %ebp,%ebp
cmpl   $0x7,0x30(%rsp)
jae    1837 <save_bank+0x727>
mov    %r12d,%esi
sub    %ebp,%esi
mov    %ebp,%edx
not    %edx
add    %r12d,%edx
and    $0x3,%esi
je     17bf <save_bank+0x6af>
neg    %esi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
mov    (%r14),%ecx
add    $0x4,%r14
shl    $0x4,%ecx
or     (%rbx),%ecx
add    $0x4,%rbx
mov    %ecx,(%rax)
add    $0x4,%rax
add    $0xffffffff,%edi
cmp    %edi,%esi
jne    17a0 <save_bank+0x690>
sub    %edi,%ebp
cmp    $0x3,%edx
jb     195c <save_bank+0x84c>
mov    %r12d,%edx
sub    %ebp,%edx
xor    %ecx,%ecx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r14,%rsi,4),%edi
shl    $0x4,%edi
or     (%rbx,%rsi,4),%edi
mov    %edi,(%rax,%rsi,4)
mov    0x4(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0x4(%rbx,%rsi,4),%edi
mov    %edi,0x4(%rax,%rsi,4)
mov    0x8(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0x8(%rbx,%rsi,4),%edi
mov    %edi,0x8(%rax,%rsi,4)
mov    0xc(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0xc(%rbx,%rsi,4),%edi
mov    %edi,0xc(%rax,%rsi,4)
add    $0x4,%rsi
add    $0xfffffffffffffff0,%rcx
cmp    %esi,%edx
jne    17e0 <save_bank+0x6d0>
sub    %rcx,%rax
sub    %rcx,%r14
sub    %rcx,%rbx
jmp    195c <save_bank+0x84c>
mov    0x10(%rsp),%rcx
lea    (%rax,%rcx,4),%rsi
lea    (%rbx,%rcx,4),%rdx
lea    (%r14,%rcx,4),%rdi
cmp    %rdx,%rax
setb   %r8b
cmp    %rsi,%rbx
setb   %cl
cmp    %rdi,%rax
setb   %dl
cmp    %rsi,%r14
setb   %sil
test   %cl,%r8b
jne    1786 <save_bank+0x676>
and    %sil,%dl
jne    1786 <save_bank+0x676>
cmpq   $0x0,0x28(%rsp)
je     23e2 <save_bank+0x12d2>
mov    0x18(%rsp),%rdx
xor    %ecx,%ecx
mov    0x8(%rsp),%rsi
nopl   0x0(%rax)
movdqu (%rbx,%rcx,4),%xmm0
movdqu 0x10(%rbx,%rcx,4),%xmm1
movdqu (%r14,%rcx,4),%xmm2
movdqu 0x10(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,(%rax,%rcx,4)
movdqu %xmm3,0x10(%rax,%rcx,4)
movdqu 0x20(%rbx,%rcx,4),%xmm0
movdqu 0x30(%rbx,%rcx,4),%xmm1
movdqu 0x20(%r14,%rcx,4),%xmm2
movdqu 0x30(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,0x20(%rax,%rcx,4)
movdqu %xmm3,0x30(%rax,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1890 <save_bank+0x780>
testb  $0x1,0x20(%rsp)
je     1943 <save_bank+0x833>
movdqu (%rbx,%rcx,4),%xmm0
movdqu 0x10(%rbx,%rcx,4),%xmm1
movdqu (%r14,%rcx,4),%xmm2
movdqu 0x10(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,(%rax,%rcx,4)
movdqu %xmm3,0x10(%rax,%rcx,4)
lea    (%rax,%rsi,4),%rax
lea    (%r14,%rsi,4),%r14
lea    (%rbx,%rsi,4),%rbx
mov    %esi,%ebp
cmp    %rsi,0x10(%rsp)
jne    1786 <save_bank+0x676>
test   %r12d,%r12d
jle    1190 <save_bank+0x80>
xor    %ebp,%ebp
cmpl   $0x7,0x30(%rsp)
jae    1a3e <save_bank+0x92e>
mov    %r12d,%esi
sub    %ebp,%esi
mov    %ebp,%edx
not    %edx
add    %r12d,%edx
and    $0x3,%esi
je     19af <save_bank+0x89f>
neg    %esi
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
mov    (%r14),%ecx
add    $0x4,%r14
shl    $0x4,%ecx
or     (%rbx),%ecx
add    $0x4,%rbx
mov    %ecx,(%rax)
add    $0x4,%rax
add    $0xffffffff,%edi
cmp    %edi,%esi
jne    1990 <save_bank+0x880>
sub    %edi,%ebp
cmp    $0x3,%edx
jb     1b6c <save_bank+0xa5c>
mov    %r12d,%edx
sub    %ebp,%edx
xor    %ecx,%ecx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r14,%rsi,4),%edi
shl    $0x4,%edi
or     (%rbx,%rsi,4),%edi
mov    %edi,(%rax,%rsi,4)
mov    0x4(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0x4(%rbx,%rsi,4),%edi
mov    %edi,0x4(%rax,%rsi,4)
mov    0x8(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0x8(%rbx,%rsi,4),%edi
mov    %edi,0x8(%rax,%rsi,4)
mov    0xc(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0xc(%rbx,%rsi,4),%edi
mov    %edi,0xc(%rax,%rsi,4)
add    $0x4,%rsi
add    $0xfffffffffffffff0,%rcx
cmp    %esi,%edx
jne    19d0 <save_bank+0x8c0>
sub    %rcx,%rax
sub    %rcx,%r14
sub    %rcx,%rbx
jmp    1b6c <save_bank+0xa5c>
xor    %eax,%eax
mov    0x8(%rsp),%rdx
testb  $0x1,0x20(%rsp)
jne    12a2 <save_bank+0x192>
jmp    12d9 <save_bank+0x1c9>
mov    0x10(%rsp),%rcx
lea    (%rax,%rcx,4),%rsi
lea    (%rbx,%rcx,4),%rdx
lea    (%r14,%rcx,4),%rdi
cmp    %rdx,%rax
setb   %r8b
cmp    %rsi,%rbx
setb   %cl
cmp    %rdi,%rax
setb   %dl
cmp    %rsi,%r14
setb   %sil
test   %cl,%r8b
jne    1972 <save_bank+0x862>
and    %sil,%dl
jne    1972 <save_bank+0x862>
cmpq   $0x0,0x28(%rsp)
je     23f9 <save_bank+0x12e9>
mov    0x18(%rsp),%rdx
xor    %ecx,%ecx
mov    0x8(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu (%rbx,%rcx,4),%xmm0
movdqu 0x10(%rbx,%rcx,4),%xmm1
movdqu (%r14,%rcx,4),%xmm2
movdqu 0x10(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,(%rax,%rcx,4)
movdqu %xmm3,0x10(%rax,%rcx,4)
movdqu 0x20(%rbx,%rcx,4),%xmm0
movdqu 0x30(%rbx,%rcx,4),%xmm1
movdqu 0x20(%r14,%rcx,4),%xmm2
movdqu 0x30(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,0x20(%rax,%rcx,4)
movdqu %xmm3,0x30(%rax,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1aa0 <save_bank+0x990>
testb  $0x1,0x20(%rsp)
je     1b53 <save_bank+0xa43>
movdqu (%rbx,%rcx,4),%xmm0
movdqu 0x10(%rbx,%rcx,4),%xmm1
movdqu (%r14,%rcx,4),%xmm2
movdqu 0x10(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,(%rax,%rcx,4)
movdqu %xmm3,0x10(%rax,%rcx,4)
lea    (%rax,%rsi,4),%rax
lea    (%r14,%rsi,4),%r14
lea    (%rbx,%rsi,4),%rbx
mov    %esi,%ebp
cmp    %rsi,0x10(%rsp)
jne    1972 <save_bank+0x862>
test   %r12d,%r12d
jle    1190 <save_bank+0x80>
xor    %ebp,%ebp
cmpl   $0x7,0x30(%rsp)
jb     1cac <save_bank+0xb9c>
mov    0x10(%rsp),%rcx
lea    (%rax,%rcx,4),%rsi
lea    (%rbx,%rcx,4),%rdx
lea    (%r14,%rcx,4),%rdi
cmp    %rdx,%rax
setb   %r8b
cmp    %rsi,%rbx
setb   %cl
cmp    %rdi,%rax
setb   %dl
cmp    %rsi,%r14
setb   %sil
test   %cl,%r8b
jne    1cac <save_bank+0xb9c>
and    %sil,%dl
jne    1cac <save_bank+0xb9c>
cmpq   $0x0,0x28(%rsp)
je     2410 <save_bank+0x1300>
mov    0x18(%rsp),%rdx
xor    %ecx,%ecx
mov    0x8(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
movdqu (%rbx,%rcx,4),%xmm0
movdqu 0x10(%rbx,%rcx,4),%xmm1
movdqu (%r14,%rcx,4),%xmm2
movdqu 0x10(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,(%rax,%rcx,4)
movdqu %xmm3,0x10(%rax,%rcx,4)
movdqu 0x20(%rbx,%rcx,4),%xmm0
movdqu 0x30(%rbx,%rcx,4),%xmm1
movdqu 0x20(%r14,%rcx,4),%xmm2
movdqu 0x30(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,0x20(%rax,%rcx,4)
movdqu %xmm3,0x30(%rax,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1be0 <save_bank+0xad0>
testb  $0x1,0x20(%rsp)
je     1c93 <save_bank+0xb83>
movdqu (%rbx,%rcx,4),%xmm0
movdqu 0x10(%rbx,%rcx,4),%xmm1
movdqu (%r14,%rcx,4),%xmm2
movdqu 0x10(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,(%rax,%rcx,4)
movdqu %xmm3,0x10(%rax,%rcx,4)
lea    (%rax,%rsi,4),%rax
lea    (%r14,%rsi,4),%r14
lea    (%rbx,%rsi,4),%rbx
mov    %esi,%ebp
cmp    %rsi,0x10(%rsp)
je     1d52 <save_bank+0xc42>
mov    %r12d,%esi
sub    %ebp,%esi
mov    %ebp,%edx
not    %edx
add    %r12d,%edx
and    $0x3,%esi
je     1cef <save_bank+0xbdf>
neg    %esi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r14),%ecx
add    $0x4,%r14
shl    $0x4,%ecx
or     (%rbx),%ecx
add    $0x4,%rbx
mov    %ecx,(%rax)
add    $0x4,%rax
add    $0xffffffff,%edi
cmp    %edi,%esi
jne    1cd0 <save_bank+0xbc0>
sub    %edi,%ebp
cmp    $0x3,%edx
jb     1d52 <save_bank+0xc42>
mov    %r12d,%edx
sub    %ebp,%edx
xor    %ecx,%ecx
xor    %esi,%esi
nopl   (%rax)
mov    (%r14,%rsi,4),%edi
shl    $0x4,%edi
or     (%rbx,%rsi,4),%edi
mov    %edi,(%rax,%rsi,4)
mov    0x4(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0x4(%rbx,%rsi,4),%edi
mov    %edi,0x4(%rax,%rsi,4)
mov    0x8(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0x8(%rbx,%rsi,4),%edi
mov    %edi,0x8(%rax,%rsi,4)
mov    0xc(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0xc(%rbx,%rsi,4),%edi
mov    %edi,0xc(%rax,%rsi,4)
add    $0x4,%rsi
add    $0xfffffffffffffff0,%rcx
cmp    %esi,%edx
jne    1d00 <save_bank+0xbf0>
sub    %rcx,%rax
sub    %rcx,%r14
sub    %rcx,%rbx
test   %r12d,%r12d
jle    1190 <save_bank+0x80>
xor    %ebp,%ebp
cmpl   $0x7,0x30(%rsp)
jb     1e8c <save_bank+0xd7c>
mov    0x10(%rsp),%rcx
lea    (%rax,%rcx,4),%rsi
lea    (%rbx,%rcx,4),%rdx
lea    (%r14,%rcx,4),%rdi
cmp    %rdx,%rax
setb   %r8b
cmp    %rsi,%rbx
setb   %cl
cmp    %rdi,%rax
setb   %dl
cmp    %rsi,%r14
setb   %sil
test   %cl,%r8b
jne    1e8c <save_bank+0xd7c>
and    %sil,%dl
jne    1e8c <save_bank+0xd7c>
cmpq   $0x0,0x28(%rsp)
je     2551 <save_bank+0x1441>
mov    0x18(%rsp),%rdx
xor    %ecx,%ecx
mov    0x8(%rsp),%rsi
nopl   (%rax)
movdqu (%rbx,%rcx,4),%xmm0
movdqu 0x10(%rbx,%rcx,4),%xmm1
movdqu (%r14,%rcx,4),%xmm2
movdqu 0x10(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,(%rax,%rcx,4)
movdqu %xmm3,0x10(%rax,%rcx,4)
movdqu 0x20(%rbx,%rcx,4),%xmm0
movdqu 0x30(%rbx,%rcx,4),%xmm1
movdqu 0x20(%r14,%rcx,4),%xmm2
movdqu 0x30(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,0x20(%rax,%rcx,4)
movdqu %xmm3,0x30(%rax,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1dc0 <save_bank+0xcb0>
testb  $0x1,0x20(%rsp)
je     1e73 <save_bank+0xd63>
movdqu (%rbx,%rcx,4),%xmm0
movdqu 0x10(%rbx,%rcx,4),%xmm1
movdqu (%r14,%rcx,4),%xmm2
movdqu 0x10(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,(%rax,%rcx,4)
movdqu %xmm3,0x10(%rax,%rcx,4)
lea    (%rax,%rsi,4),%rax
lea    (%r14,%rsi,4),%r14
lea    (%rbx,%rsi,4),%rbx
mov    %esi,%ebp
cmp    %rsi,0x10(%rsp)
je     1f32 <save_bank+0xe22>
mov    %r12d,%esi
sub    %ebp,%esi
mov    %ebp,%edx
not    %edx
add    %r12d,%edx
and    $0x3,%esi
je     1ecf <save_bank+0xdbf>
neg    %esi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r14),%ecx
add    $0x4,%r14
shl    $0x4,%ecx
or     (%rbx),%ecx
add    $0x4,%rbx
mov    %ecx,(%rax)
add    $0x4,%rax
add    $0xffffffff,%edi
cmp    %edi,%esi
jne    1eb0 <save_bank+0xda0>
sub    %edi,%ebp
cmp    $0x3,%edx
jb     1f32 <save_bank+0xe22>
mov    %r12d,%edx
sub    %ebp,%edx
xor    %ecx,%ecx
xor    %esi,%esi
nopl   (%rax)
mov    (%r14,%rsi,4),%edi
shl    $0x4,%edi
or     (%rbx,%rsi,4),%edi
mov    %edi,(%rax,%rsi,4)
mov    0x4(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0x4(%rbx,%rsi,4),%edi
mov    %edi,0x4(%rax,%rsi,4)
mov    0x8(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0x8(%rbx,%rsi,4),%edi
mov    %edi,0x8(%rax,%rsi,4)
mov    0xc(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0xc(%rbx,%rsi,4),%edi
mov    %edi,0xc(%rax,%rsi,4)
add    $0x4,%rsi
add    $0xfffffffffffffff0,%rcx
cmp    %esi,%edx
jne    1ee0 <save_bank+0xdd0>
sub    %rcx,%rax
sub    %rcx,%r14
sub    %rcx,%rbx
test   %r12d,%r12d
jle    1190 <save_bank+0x80>
xor    %ebp,%ebp
cmpl   $0x7,0x30(%rsp)
jb     206c <save_bank+0xf5c>
mov    0x10(%rsp),%rcx
lea    (%rax,%rcx,4),%rsi
lea    (%rbx,%rcx,4),%rdx
lea    (%r14,%rcx,4),%rdi
cmp    %rdx,%rax
setb   %r8b
cmp    %rsi,%rbx
setb   %cl
cmp    %rdi,%rax
setb   %dl
cmp    %rsi,%r14
setb   %sil
test   %cl,%r8b
jne    206c <save_bank+0xf5c>
and    %sil,%dl
jne    206c <save_bank+0xf5c>
cmpq   $0x0,0x28(%rsp)
je     2568 <save_bank+0x1458>
mov    0x18(%rsp),%rdx
xor    %ecx,%ecx
mov    0x8(%rsp),%rsi
nopl   (%rax)
movdqu (%rbx,%rcx,4),%xmm0
movdqu 0x10(%rbx,%rcx,4),%xmm1
movdqu (%r14,%rcx,4),%xmm2
movdqu 0x10(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,(%rax,%rcx,4)
movdqu %xmm3,0x10(%rax,%rcx,4)
movdqu 0x20(%rbx,%rcx,4),%xmm0
movdqu 0x30(%rbx,%rcx,4),%xmm1
movdqu 0x20(%r14,%rcx,4),%xmm2
movdqu 0x30(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,0x20(%rax,%rcx,4)
movdqu %xmm3,0x30(%rax,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1fa0 <save_bank+0xe90>
testb  $0x1,0x20(%rsp)
je     2053 <save_bank+0xf43>
movdqu (%rbx,%rcx,4),%xmm0
movdqu 0x10(%rbx,%rcx,4),%xmm1
movdqu (%r14,%rcx,4),%xmm2
movdqu 0x10(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,(%rax,%rcx,4)
movdqu %xmm3,0x10(%rax,%rcx,4)
lea    (%rax,%rsi,4),%rax
lea    (%r14,%rsi,4),%r14
lea    (%rbx,%rsi,4),%rbx
mov    %esi,%ebp
cmp    %rsi,0x10(%rsp)
je     2112 <save_bank+0x1002>
mov    %r12d,%esi
sub    %ebp,%esi
mov    %ebp,%edx
not    %edx
add    %r12d,%edx
and    $0x3,%esi
je     20af <save_bank+0xf9f>
neg    %esi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r14),%ecx
add    $0x4,%r14
shl    $0x4,%ecx
or     (%rbx),%ecx
add    $0x4,%rbx
mov    %ecx,(%rax)
add    $0x4,%rax
add    $0xffffffff,%edi
cmp    %edi,%esi
jne    2090 <save_bank+0xf80>
sub    %edi,%ebp
cmp    $0x3,%edx
jb     2112 <save_bank+0x1002>
mov    %r12d,%edx
sub    %ebp,%edx
xor    %ecx,%ecx
xor    %esi,%esi
nopl   (%rax)
mov    (%r14,%rsi,4),%edi
shl    $0x4,%edi
or     (%rbx,%rsi,4),%edi
mov    %edi,(%rax,%rsi,4)
mov    0x4(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0x4(%rbx,%rsi,4),%edi
mov    %edi,0x4(%rax,%rsi,4)
mov    0x8(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0x8(%rbx,%rsi,4),%edi
mov    %edi,0x8(%rax,%rsi,4)
mov    0xc(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0xc(%rbx,%rsi,4),%edi
mov    %edi,0xc(%rax,%rsi,4)
add    $0x4,%rsi
add    $0xfffffffffffffff0,%rcx
cmp    %esi,%edx
jne    20c0 <save_bank+0xfb0>
sub    %rcx,%rax
sub    %rcx,%r14
sub    %rcx,%rbx
test   %r12d,%r12d
jle    1190 <save_bank+0x80>
xor    %ebp,%ebp
cmpl   $0x7,0x30(%rsp)
jb     224c <save_bank+0x113c>
mov    0x10(%rsp),%rcx
lea    (%rax,%rcx,4),%rsi
lea    (%rbx,%rcx,4),%rdx
lea    (%r14,%rcx,4),%rdi
cmp    %rdx,%rax
setb   %r8b
cmp    %rsi,%rbx
setb   %cl
cmp    %rdi,%rax
setb   %dl
cmp    %rsi,%r14
setb   %sil
test   %cl,%r8b
jne    224c <save_bank+0x113c>
and    %sil,%dl
jne    224c <save_bank+0x113c>
cmpq   $0x0,0x28(%rsp)
je     257f <save_bank+0x146f>
mov    0x18(%rsp),%rdx
xor    %ecx,%ecx
mov    0x8(%rsp),%rsi
nopl   (%rax)
movdqu (%rbx,%rcx,4),%xmm0
movdqu 0x10(%rbx,%rcx,4),%xmm1
movdqu (%r14,%rcx,4),%xmm2
movdqu 0x10(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,(%rax,%rcx,4)
movdqu %xmm3,0x10(%rax,%rcx,4)
movdqu 0x20(%rbx,%rcx,4),%xmm0
movdqu 0x30(%rbx,%rcx,4),%xmm1
movdqu 0x20(%r14,%rcx,4),%xmm2
movdqu 0x30(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,0x20(%rax,%rcx,4)
movdqu %xmm3,0x30(%rax,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdx
jne    2180 <save_bank+0x1070>
testb  $0x1,0x20(%rsp)
je     2233 <save_bank+0x1123>
movdqu (%rbx,%rcx,4),%xmm0
movdqu 0x10(%rbx,%rcx,4),%xmm1
movdqu (%r14,%rcx,4),%xmm2
movdqu 0x10(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,(%rax,%rcx,4)
movdqu %xmm3,0x10(%rax,%rcx,4)
lea    (%rax,%rsi,4),%rax
lea    (%r14,%rsi,4),%r14
lea    (%rbx,%rsi,4),%rbx
mov    %esi,%ebp
cmp    %rsi,0x10(%rsp)
je     22f2 <save_bank+0x11e2>
mov    %r12d,%esi
sub    %ebp,%esi
mov    %ebp,%edx
not    %edx
add    %r12d,%edx
and    $0x3,%esi
je     228f <save_bank+0x117f>
neg    %esi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r14),%ecx
add    $0x4,%r14
shl    $0x4,%ecx
or     (%rbx),%ecx
add    $0x4,%rbx
mov    %ecx,(%rax)
add    $0x4,%rax
add    $0xffffffff,%edi
cmp    %edi,%esi
jne    2270 <save_bank+0x1160>
sub    %edi,%ebp
cmp    $0x3,%edx
jb     22f2 <save_bank+0x11e2>
mov    %r12d,%edx
sub    %ebp,%edx
xor    %ecx,%ecx
xor    %esi,%esi
nopl   (%rax)
mov    (%r14,%rsi,4),%edi
shl    $0x4,%edi
or     (%rbx,%rsi,4),%edi
mov    %edi,(%rax,%rsi,4)
mov    0x4(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0x4(%rbx,%rsi,4),%edi
mov    %edi,0x4(%rax,%rsi,4)
mov    0x8(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0x8(%rbx,%rsi,4),%edi
mov    %edi,0x8(%rax,%rsi,4)
mov    0xc(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0xc(%rbx,%rsi,4),%edi
mov    %edi,0xc(%rax,%rsi,4)
add    $0x4,%rsi
add    $0xfffffffffffffff0,%rcx
cmp    %esi,%edx
jne    22a0 <save_bank+0x1190>
sub    %rcx,%rax
sub    %rcx,%r14
sub    %rcx,%rbx
test   %r12d,%r12d
jle    1190 <save_bank+0x80>
xor    %ebp,%ebp
cmpl   $0x7,0x30(%rsp)
jae    2427 <save_bank+0x1317>
mov    %r12d,%esi
sub    %ebp,%esi
mov    %ebp,%edx
not    %edx
add    %r12d,%edx
and    $0x3,%esi
je     233f <save_bank+0x122f>
neg    %esi
xor    %edi,%edi
nopl   (%rax)
mov    (%r14),%ecx
add    $0x4,%r14
shl    $0x4,%ecx
or     (%rbx),%ecx
add    $0x4,%rbx
mov    %ecx,(%rax)
add    $0x4,%rax
add    $0xffffffff,%edi
cmp    %edi,%esi
jne    2320 <save_bank+0x1210>
sub    %edi,%ebp
cmp    $0x3,%edx
jb     1190 <save_bank+0x80>
mov    %r12d,%edx
sub    %ebp,%edx
xor    %ecx,%ecx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r14,%rsi,4),%edi
shl    $0x4,%edi
or     (%rbx,%rsi,4),%edi
mov    %edi,(%rax,%rsi,4)
mov    0x4(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0x4(%rbx,%rsi,4),%edi
mov    %edi,0x4(%rax,%rsi,4)
mov    0x8(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0x8(%rbx,%rsi,4),%edi
mov    %edi,0x8(%rax,%rsi,4)
mov    0xc(%r14,%rsi,4),%edi
shl    $0x4,%edi
or     0xc(%rbx,%rsi,4),%edi
mov    %edi,0xc(%rax,%rsi,4)
add    $0x4,%rsi
add    $0xfffffffffffffff0,%rcx
cmp    %esi,%edx
jne    2360 <save_bank+0x1250>
sub    %rcx,%r14
sub    %rcx,%rbx
jmp    1190 <save_bank+0x80>
xor    %ecx,%ecx
mov    0x8(%rsp),%rsi
testb  $0x1,0x20(%rsp)
jne    148e <save_bank+0x37e>
jmp    14c3 <save_bank+0x3b3>
xor    %ecx,%ecx
mov    0x8(%rsp),%rsi
testb  $0x1,0x20(%rsp)
jne    171e <save_bank+0x60e>
jmp    1753 <save_bank+0x643>
xor    %ecx,%ecx
mov    0x8(%rsp),%rsi
testb  $0x1,0x20(%rsp)
jne    190e <save_bank+0x7fe>
jmp    1943 <save_bank+0x833>
xor    %ecx,%ecx
mov    0x8(%rsp),%rsi
testb  $0x1,0x20(%rsp)
jne    1b1e <save_bank+0xa0e>
jmp    1b53 <save_bank+0xa43>
xor    %ecx,%ecx
mov    0x8(%rsp),%rsi
testb  $0x1,0x20(%rsp)
jne    1c5e <save_bank+0xb4e>
jmp    1c93 <save_bank+0xb83>
mov    0x10(%rsp),%rcx
lea    (%rax,%rcx,4),%rsi
lea    (%rbx,%rcx,4),%rdx
lea    (%r14,%rcx,4),%rdi
cmp    %rdx,%rax
setb   %r8b
cmp    %rsi,%rbx
setb   %cl
cmp    %rdi,%rax
setb   %dl
cmp    %rsi,%r14
setb   %sil
test   %cl,%r8b
jne    2308 <save_bank+0x11f8>
and    %sil,%dl
jne    2308 <save_bank+0x11f8>
cmpq   $0x0,0x28(%rsp)
je     2596 <save_bank+0x1486>
mov    0x18(%rsp),%rdx
xor    %ecx,%ecx
mov    0x8(%rsp),%rsi
nopl   0x0(%rax)
movdqu (%rbx,%rcx,4),%xmm0
movdqu 0x10(%rbx,%rcx,4),%xmm1
movdqu (%r14,%rcx,4),%xmm2
movdqu 0x10(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,(%rax,%rcx,4)
movdqu %xmm3,0x10(%rax,%rcx,4)
movdqu 0x20(%rbx,%rcx,4),%xmm0
movdqu 0x30(%rbx,%rcx,4),%xmm1
movdqu 0x20(%r14,%rcx,4),%xmm2
movdqu 0x30(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,0x20(%rax,%rcx,4)
movdqu %xmm3,0x30(%rax,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdx
jne    2480 <save_bank+0x1370>
testb  $0x1,0x20(%rsp)
je     2533 <save_bank+0x1423>
movdqu (%rbx,%rcx,4),%xmm0
movdqu 0x10(%rbx,%rcx,4),%xmm1
movdqu (%r14,%rcx,4),%xmm2
movdqu 0x10(%r14,%rcx,4),%xmm3
pslld  $0x4,%xmm2
por    %xmm0,%xmm2
pslld  $0x4,%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,(%rax,%rcx,4)
movdqu %xmm3,0x10(%rax,%rcx,4)
lea    (%r14,%rsi,4),%r14
lea    (%rbx,%rsi,4),%rbx
cmp    %rsi,0x10(%rsp)
je     1190 <save_bank+0x80>
lea    (%rax,%rsi,4),%rax
mov    %esi,%ebp
jmp    2308 <save_bank+0x11f8>
xor    %ecx,%ecx
mov    0x8(%rsp),%rsi
testb  $0x1,0x20(%rsp)
jne    1e3e <save_bank+0xd2e>
jmp    1e73 <save_bank+0xd63>
xor    %ecx,%ecx
mov    0x8(%rsp),%rsi
testb  $0x1,0x20(%rsp)
jne    201e <save_bank+0xf0e>
jmp    2053 <save_bank+0xf43>
xor    %ecx,%ecx
mov    0x8(%rsp),%rsi
testb  $0x1,0x20(%rsp)
jne    21fe <save_bank+0x10ee>
jmp    2233 <save_bank+0x1123>
xor    %ecx,%ecx
mov    0x8(%rsp),%rsi
testb  $0x1,0x20(%rsp)
jne    24fe <save_bank+0x13ee>
jmp    2533 <save_bank+0x1423>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @save_bank(i32* %0, i32 %1, i32* %2, i32* %3, i32* %4) {
%6 = alloca i32*
%7 = alloca i32
%8 = alloca i32*
%9 = alloca i32*
%10 = alloca i32*
%11 = alloca i32
%12 = alloca i32*
%13 = alloca i32
%14 = alloca i32
store i32* %0, i32** %6
store i32 %1, i32* %7
store i32* %2, i32** %8
store i32* %3, i32** %9
store i32* %4, i32** %10
store i32 0, i32* %11
br label %15
15: ; preds = %52, %5
%16 = load i32, i32* %11
%17 = icmp slt i32 %16, 96
br i1 %17, label %18, label %55
18: ; preds = %15
%19 = load i32*, i32** %8
store i32* %19, i32** %12
store i32 0, i32* %13
br label %20
20: ; preds = %43, %18
%21 = load i32, i32* %13
%22 = icmp slt i32 %21, 10
br i1 %22, label %23, label %46
23: ; preds = %20
store i32 0, i32* %14
br label %24
24: ; preds = %39, %23
%25 = load i32, i32* %14
%26 = load i32, i32* %7
%27 = icmp slt i32 %25, %26
br i1 %27, label %28, label %42
28: ; preds = %24
%29 = load i32*, i32** %9
%30 = getelementptr inbounds i32, i32* %29, i32 1
store i32* %30, i32** %9
%31 = load i32, i32* %29
%32 = load i32*, i32** %10
%33 = getelementptr inbounds i32, i32* %32, i32 1
store i32* %33, i32** %10
%34 = load i32, i32* %32
%35 = shl i32 %34, 4
%36 = or i32 %31, %35
%37 = load i32*, i32** %12
%38 = getelementptr inbounds i32, i32* %37, i32 1
store i32* %38, i32** %12
store i32 %36, i32* %37
br label %39
39: ; preds = %28
%40 = load i32, i32* %14
%41 = add nsw i32 %40, 1
store i32 %41, i32* %14
br label %24
42: ; preds = %24
br label %43
43: ; preds = %42
%44 = load i32, i32* %13
%45 = add nsw i32 %44, 1
store i32 %45, i32* %13
br label %20
46: ; preds = %20
%47 = load i32*, i32** %8
%48 = load i32, i32* %7
%49 = mul nsw i32 10, %48
%50 = load i32*, i32** %6
%51 = call i32 @fwrite(i32* %47, i32 %49, i32 1, i32* %50)
br label %52
52: ; preds = %46
%53 = load i32, i32* %11
%54 = add nsw i32 %53, 1
store i32 %54, i32* %11
br label %15
55: ; preds = %15
ret void
}

LLVM IR (-O2):
define void @save_bank(i32* nocapture %0, i32 %1, i32* nocapture %2, i32* nocapture %3, i32* nocapture %4) {
%6 = icmp sgt i32 %1, 0
%7 = mul nsw i32 %1, 10
%8 = add i32 %1, -1
%9 = zext i32 %8 to i64
%10 = add nuw nsw i64 %9, 1
%11 = zext i32 %8 to i64
%12 = add nuw nsw i64 %11, 1
%13 = zext i32 %8 to i64
%14 = add nuw nsw i64 %13, 1
%15 = add i32 %1, -1
%16 = zext i32 %15 to i64
%17 = add nuw nsw i64 %16, 1
%18 = zext i32 %15 to i64
%19 = add nuw nsw i64 %18, 1
%20 = zext i32 %15 to i64
%21 = add nuw nsw i64 %20, 1
%22 = add i32 %1, -1
%23 = zext i32 %22 to i64
%24 = add nuw nsw i64 %23, 1
%25 = zext i32 %22 to i64
%26 = add nuw nsw i64 %25, 1
%27 = zext i32 %22 to i64
%28 = add nuw nsw i64 %27, 1
%29 = add i32 %1, -1
%30 = zext i32 %29 to i64
%31 = add nuw nsw i64 %30, 1
%32 = zext i32 %29 to i64
%33 = add nuw nsw i64 %32, 1
%34 = zext i32 %29 to i64
%35 = add nuw nsw i64 %34, 1
%36 = add i32 %1, -1
%37 = zext i32 %36 to i64
%38 = add nuw nsw i64 %37, 1
%39 = zext i32 %36 to i64
%40 = add nuw nsw i64 %39, 1
%41 = zext i32 %36 to i64
%42 = add nuw nsw i64 %41, 1
%43 = add i32 %1, -1
%44 = zext i32 %43 to i64
%45 = add nuw nsw i64 %44, 1
%46 = zext i32 %43 to i64
%47 = add nuw nsw i64 %46, 1
%48 = zext i32 %43 to i64
%49 = add nuw nsw i64 %48, 1
%50 = add i32 %1, -1
%51 = zext i32 %50 to i64
%52 = add nuw nsw i64 %51, 1
%53 = getelementptr i32, i32* %2, i64 %52
%54 = zext i32 %50 to i64
%55 = add nuw nsw i64 %54, 1
%56 = and i64 %55, 8589934584
%57 = add nsw i64 %56, -8
%58 = lshr exact i64 %57, 3
%59 = add nuw nsw i64 %58, 1
%60 = icmp ult i32 %50, 7
%61 = and i64 %55, 8589934584
%62 = trunc i64 %61 to i32
%63 = getelementptr i32, i32* %2, i64 %61
%64 = and i64 %59, 1
%65 = icmp eq i64 %57, 0
%66 = and i64 %59, 4611686018427387902
%67 = icmp eq i64 %64, 0
%68 = icmp eq i64 %55, %61
%69 = icmp ult i32 %43, 7
%70 = and i64 %49, 8589934584
%71 = trunc i64 %70 to i32
%72 = and i64 %59, 1
%73 = icmp eq i64 %57, 0
%74 = and i64 %59, 4611686018427387902
%75 = icmp eq i64 %72, 0
%76 = icmp eq i64 %49, %70
%77 = icmp ult i32 %43, 7
%78 = and i64 %45, 8589934584
%79 = trunc i64 %78 to i32
%80 = and i64 %59, 1
%81 = icmp eq i64 %57, 0
%82 = and i64 %59, 4611686018427387902
%83 = icmp eq i64 %80, 0
%84 = icmp eq i64 %45, %78
%85 = icmp ult i32 %36, 7
%86 = and i64 %40, 8589934584
%87 = trunc i64 %86 to i32
%88 = and i64 %59, 1
%89 = icmp eq i64 %57, 0
%90 = and i64 %59, 4611686018427387902
%91 = icmp eq i64 %88, 0
%92 = icmp eq i64 %40, %86
%93 = icmp ult i32 %29, 7
%94 = and i64 %35, 8589934584
%95 = trunc i64 %94 to i32
%96 = and i64 %59, 1
%97 = icmp eq i64 %57, 0
%98 = and i64 %59, 4611686018427387902
%99 = icmp eq i64 %96, 0
%100 = icmp eq i64 %35, %94
%101 = icmp ult i32 %29, 7
%102 = and i64 %31, 8589934584
%103 = trunc i64 %102 to i32
%104 = and i64 %59, 1
%105 = icmp eq i64 %57, 0
%106 = and i64 %59, 4611686018427387902
%107 = icmp eq i64 %104, 0
%108 = icmp eq i64 %31, %102
%109 = icmp ult i32 %22, 7
%110 = and i64 %26, 8589934584
%111 = trunc i64 %110 to i32
%112 = and i64 %59, 1
%113 = icmp eq i64 %57, 0
%114 = and i64 %59, 4611686018427387902
%115 = icmp eq i64 %112, 0
%116 = icmp eq i64 %26, %110
%117 = icmp ult i32 %15, 7
%118 = and i64 %21, 8589934584
%119 = trunc i64 %118 to i32
%120 = and i64 %59, 1
%121 = icmp eq i64 %57, 0
%122 = and i64 %59, 4611686018427387902
%123 = icmp eq i64 %120, 0
%124 = icmp eq i64 %21, %118
%125 = icmp ult i32 %15, 7
%126 = and i64 %17, 8589934584
%127 = trunc i64 %126 to i32
%128 = and i64 %59, 1
%129 = icmp eq i64 %57, 0
%130 = and i64 %59, 4611686018427387902
%131 = icmp eq i64 %128, 0
%132 = icmp eq i64 %17, %126
%133 = icmp ult i32 %8, 7
%134 = and i64 %12, 8589934584
%135 = trunc i64 %134 to i32
%136 = and i64 %59, 1
%137 = icmp eq i64 %57, 0
%138 = and i64 %59, 4611686018427387902
%139 = icmp eq i64 %136, 0
%140 = icmp eq i64 %12, %134
br label %141
141: ; preds = %5, %1714
%142 = phi i32 [ 0, %5 ], [ %1718, %1714 ]
%143 = phi i32* [ %4, %5 ], [ %1716, %1714 ]
%144 = phi i32* [ %3, %5 ], [ %1715, %1714 ]
br i1 %6, label %145, label %1714
145: ; preds = %141
br i1 %60, label %230, label %146
146: ; preds = %145
%147 = getelementptr i32, i32* %144, i64 %52
%148 = getelementptr i32, i32* %143, i64 %52
%149 = icmp ugt i32* %147, %2
%150 = icmp ult i32* %144, %53
%151 = and i1 %149, %150
%152 = icmp ugt i32* %148, %2
%153 = icmp ult i32* %143, %53
%154 = and i1 %152, %153
%155 = or i1 %151, %154
br i1 %155, label %230, label %156
156: ; preds = %146
%157 = getelementptr i32, i32* %143, i64 %61
%158 = getelementptr i32, i32* %144, i64 %61
br i1 %65, label %206, label %159
159: ; preds = %156, %159
%160 = phi i64 [ %203, %159 ], [ 0, %156 ]
%161 = phi i64 [ %204, %159 ], [ 0, %156 ]
%162 = getelementptr i32, i32* %2, i64 %160
%163 = getelementptr i32, i32* %143, i64 %160
%164 = getelementptr i32, i32* %144, i64 %160
%165 = bitcast i32* %164 to <4 x i32>*
%166 = load <4 x i32>, <4 x i32>* %165
%167 = getelementptr i32, i32* %164, i64 4
%168 = bitcast i32* %167 to <4 x i32>*
%169 = load <4 x i32>, <4 x i32>* %168
%170 = bitcast i32* %163 to <4 x i32>*
%171 = load <4 x i32>, <4 x i32>* %170
%172 = getelementptr i32, i32* %163, i64 4
%173 = bitcast i32* %172 to <4 x i32>*
%174 = load <4 x i32>, <4 x i32>* %173
%175 = shl <4 x i32> %171, <i32 4, i32 4, i32 4, i32 4>
%176 = shl <4 x i32> %174, <i32 4, i32 4, i32 4, i32 4>
%177 = or <4 x i32> %175, %166
%178 = or <4 x i32> %176, %169
%179 = bitcast i32* %162 to <4 x i32>*
store <4 x i32> %177, <4 x i32>* %179
%180 = getelementptr i32, i32* %162, i64 4
%181 = bitcast i32* %180 to <4 x i32>*
store <4 x i32> %178, <4 x i32>* %181
%182 = or i64 %160, 8
%183 = getelementptr i32, i32* %2, i64 %182
%184 = getelementptr i32, i32* %143, i64 %182
%185 = getelementptr i32, i32* %144, i64 %182
%186 = bitcast i32* %185 to <4 x i32>*
%187 = load <4 x i32>, <4 x i32>* %186
%188 = getelementptr i32, i32* %185, i64 4
%189 = bitcast i32* %188 to <4 x i32>*
%190 = load <4 x i32>, <4 x i32>* %189
%191 = bitcast i32* %184 to <4 x i32>*
%192 = load <4 x i32>, <4 x i32>* %191
%193 = getelementptr i32, i32* %184, i64 4
%194 = bitcast i32* %193 to <4 x i32>*
%195 = load <4 x i32>, <4 x i32>* %194
%196 = shl <4 x i32> %192, <i32 4, i32 4, i32 4, i32 4>
%197 = shl <4 x i32> %195, <i32 4, i32 4, i32 4, i32 4>
%198 = or <4 x i32> %196, %187
%199 = or <4 x i32> %197, %190
%200 = bitcast i32* %183 to <4 x i32>*
store <4 x i32> %198, <4 x i32>* %200
%201 = getelementptr i32, i32* %183, i64 4
%202 = bitcast i32* %201 to <4 x i32>*
store <4 x i32> %199, <4 x i32>* %202
%203 = add nuw i64 %160, 16
%204 = add i64 %161, 2
%205 = icmp eq i64 %204, %66
br i1 %205, label %206, label %159
206: ; preds = %159, %156
%207 = phi i64 [ 0, %156 ], [ %203, %159 ]
br i1 %67, label %229, label %208
208: ; preds = %206
%209 = getelementptr i32, i32* %2, i64 %207
%210 = getelementptr i32, i32* %143, i64 %207
%211 = getelementptr i32, i32* %144, i64 %207
%212 = bitcast i32* %211 to <4 x i32>*
%213 = load <4 x i32>, <4 x i32>* %212
%214 = getelementptr i32, i32* %211, i64 4
%215 = bitcast i32* %214 to <4 x i32>*
%216 = load <4 x i32>, <4 x i32>* %215
%217 = bitcast i32* %210 to <4 x i32>*
%218 = load <4 x i32>, <4 x i32>* %217
%219 = getelementptr i32, i32* %210, i64 4
%220 = bitcast i32* %219 to <4 x i32>*
%221 = load <4 x i32>, <4 x i32>* %220
%222 = shl <4 x i32> %218, <i32 4, i32 4, i32 4, i32 4>
%223 = shl <4 x i32> %221, <i32 4, i32 4, i32 4, i32 4>
%224 = or <4 x i32> %222, %213
%225 = or <4 x i32> %223, %216
%226 = bitcast i32* %209 to <4 x i32>*
store <4 x i32> %224, <4 x i32>* %226
%227 = getelementptr i32, i32* %209, i64 4
%228 = bitcast i32* %227 to <4 x i32>*
store <4 x i32> %225, <4 x i32>* %228
br label %229
229: ; preds = %206, %208
br i1 %68, label %266, label %230
230: ; preds = %146, %145, %229
%231 = phi i32 [ 0, %146 ], [ 0, %145 ], [ %62, %229 ]
%232 = phi i32* [ %2, %146 ], [ %2, %145 ], [ %63, %229 ]
%233 = phi i32* [ %143, %146 ], [ %143, %145 ], [ %157, %229 ]
%234 = phi i32* [ %144, %146 ], [ %144, %145 ], [ %158, %229 ]
%235 = sub i32 %1, %231
%236 = xor i32 %231, -1
%237 = add i32 %236, %1
%238 = and i32 %235, 3
%239 = icmp eq i32 %238, 0
br i1 %239, label %256, label %240
240: ; preds = %230, %240
%241 = phi i32 [ %253, %240 ], [ %231, %230 ]
%242 = phi i32* [ %252, %240 ], [ %232, %230 ]
%243 = phi i32* [ %248, %240 ], [ %233, %230 ]
%244 = phi i32* [ %246, %240 ], [ %234, %230 ]
%245 = phi i32 [ %254, %240 ], [ 0, %230 ]
%246 = getelementptr inbounds i32, i32* %244, i64 1
%247 = load i32, i32* %244
%248 = getelementptr inbounds i32, i32* %243, i64 1
%249 = load i32, i32* %243
%250 = shl i32 %249, 4
%251 = or i32 %250, %247
%252 = getelementptr inbounds i32, i32* %242, i64 1
store i32 %251, i32* %242
%253 = add nuw nsw i32 %241, 1
%254 = add i32 %245, 1
%255 = icmp eq i32 %254, %238
br i1 %255, label %256, label %240
256: ; preds = %240, %230
%257 = phi i32* [ undef, %230 ], [ %246, %240 ]
%258 = phi i32* [ undef, %230 ], [ %248, %240 ]
%259 = phi i32* [ undef, %230 ], [ %252, %240 ]
%260 = phi i32 [ %231, %230 ], [ %253, %240 ]
%261 = phi i32* [ %232, %230 ], [ %252, %240 ]
%262 = phi i32* [ %233, %230 ], [ %248, %240 ]
%263 = phi i32* [ %234, %230 ], [ %246, %240 ]
%264 = icmp ult i32 %237, 3
br i1 %264, label %266, label %1720
265: ; preds = %1714
ret void
266: ; preds = %256, %1720, %229
%267 = phi i32* [ %158, %229 ], [ %257, %256 ], [ %1746, %1720 ]
%268 = phi i32* [ %157, %229 ], [ %258, %256 ], [ %1748, %1720 ]
%269 = phi i32* [ %63, %229 ], [ %259, %256 ], [ %1752, %1720 ]
br i1 %6, label %270, label %1714
270: ; preds = %266
br i1 %69, label %357, label %271
271: ; preds = %270
%272 = getelementptr i32, i32* %269, i64 %47
%273 = getelementptr i32, i32* %267, i64 %47
%274 = getelementptr i32, i32* %268, i64 %47
%275 = icmp ult i32* %269, %273
%276 = icmp ult i32* %267, %272
%277 = and i1 %275, %276
%278 = icmp ult i32* %269, %274
%279 = icmp ult i32* %268, %272
%280 = and i1 %278, %279
%281 = or i1 %277, %280
br i1 %281, label %357, label %282
282: ; preds = %271
%283 = getelementptr i32, i32* %269, i64 %70
%284 = getelementptr i32, i32* %268, i64 %70
%285 = getelementptr i32, i32* %267, i64 %70
br i1 %73, label %333, label %286
286: ; preds = %282, %286
%287 = phi i64 [ %330, %286 ], [ 0, %282 ]
%288 = phi i64 [ %331, %286 ], [ 0, %282 ]
%289 = getelementptr i32, i32* %269, i64 %287
%290 = getelementptr i32, i32* %268, i64 %287
%291 = getelementptr i32, i32* %267, i64 %287
%292 = bitcast i32* %291 to <4 x i32>*
%293 = load <4 x i32>, <4 x i32>* %292
%294 = getelementptr i32, i32* %291, i64 4
%295 = bitcast i32* %294 to <4 x i32>*
%296 = load <4 x i32>, <4 x i32>* %295
%297 = bitcast i32* %290 to <4 x i32>*
%298 = load <4 x i32>, <4 x i32>* %297
%299 = getelementptr i32, i32* %290, i64 4
%300 = bitcast i32* %299 to <4 x i32>*
%301 = load <4 x i32>, <4 x i32>* %300
%302 = shl <4 x i32> %298, <i32 4, i32 4, i32 4, i32 4>
%303 = shl <4 x i32> %301, <i32 4, i32 4, i32 4, i32 4>
%304 = or <4 x i32> %302, %293
%305 = or <4 x i32> %303, %296
%306 = bitcast i32* %289 to <4 x i32>*
store <4 x i32> %304, <4 x i32>* %306
%307 = getelementptr i32, i32* %289, i64 4
%308 = bitcast i32* %307 to <4 x i32>*
store <4 x i32> %305, <4 x i32>* %308
%309 = or i64 %287, 8
%310 = getelementptr i32, i32* %269, i64 %309
%311 = getelementptr i32, i32* %268, i64 %309
%312 = getelementptr i32, i32* %267, i64 %309
%313 = bitcast i32* %312 to <4 x i32>*
%314 = load <4 x i32>, <4 x i32>* %313
%315 = getelementptr i32, i32* %312, i64 4
%316 = bitcast i32* %315 to <4 x i32>*
%317 = load <4 x i32>, <4 x i32>* %316
%318 = bitcast i32* %311 to <4 x i32>*
%319 = load <4 x i32>, <4 x i32>* %318
%320 = getelementptr i32, i32* %311, i64 4
%321 = bitcast i32* %320 to <4 x i32>*
%322 = load <4 x i32>, <4 x i32>* %321
%323 = shl <4 x i32> %319, <i32 4, i32 4, i32 4, i32 4>
%324 = shl <4 x i32> %322, <i32 4, i32 4, i32 4, i32 4>
%325 = or <4 x i32> %323, %314
%326 = or <4 x i32> %324, %317
%327 = bitcast i32* %310 to <4 x i32>*
store <4 x i32> %325, <4 x i32>* %327
%328 = getelementptr i32, i32* %310, i64 4
%329 = bitcast i32* %328 to <4 x i32>*
store <4 x i32> %326, <4 x i32>* %329
%330 = add nuw i64 %287, 16
%331 = add i64 %288, 2
%332 = icmp eq i64 %331, %74
br i1 %332, label %333, label %286
333: ; preds = %286, %282
%334 = phi i64 [ 0, %282 ], [ %330, %286 ]
br i1 %75, label %356, label %335
335: ; preds = %333
%336 = getelementptr i32, i32* %269, i64 %334
%337 = getelementptr i32, i32* %268, i64 %334
%338 = getelementptr i32, i32* %267, i64 %334
%339 = bitcast i32* %338 to <4 x i32>*
%340 = load <4 x i32>, <4 x i32>* %339
%341 = getelementptr i32, i32* %338, i64 4
%342 = bitcast i32* %341 to <4 x i32>*
%343 = load <4 x i32>, <4 x i32>* %342
%344 = bitcast i32* %337 to <4 x i32>*
%345 = load <4 x i32>, <4 x i32>* %344
%346 = getelementptr i32, i32* %337, i64 4
%347 = bitcast i32* %346 to <4 x i32>*
%348 = load <4 x i32>, <4 x i32>* %347
%349 = shl <4 x i32> %345, <i32 4, i32 4, i32 4, i32 4>
%350 = shl <4 x i32> %348, <i32 4, i32 4, i32 4, i32 4>
%351 = or <4 x i32> %349, %340
%352 = or <4 x i32> %350, %343
%353 = bitcast i32* %336 to <4 x i32>*
store <4 x i32> %351, <4 x i32>* %353
%354 = getelementptr i32, i32* %336, i64 4
%355 = bitcast i32* %354 to <4 x i32>*
store <4 x i32> %352, <4 x i32>* %355
br label %356
356: ; preds = %333, %335
br i1 %76, label %427, label %357
357: ; preds = %271, %270, %356
%358 = phi i32 [ 0, %271 ], [ 0, %270 ], [ %71, %356 ]
%359 = phi i32* [ %269, %271 ], [ %269, %270 ], [ %283, %356 ]
%360 = phi i32* [ %268, %271 ], [ %268, %270 ], [ %284, %356 ]
%361 = phi i32* [ %267, %271 ], [ %267, %270 ], [ %285, %356 ]
%362 = sub i32 %1, %358
%363 = xor i32 %358, -1
%364 = add i32 %363, %1
%365 = and i32 %362, 3
%366 = icmp eq i32 %365, 0
br i1 %366, label %383, label %367
367: ; preds = %357, %367
%368 = phi i32 [ %380, %367 ], [ %358, %357 ]
%369 = phi i32* [ %379, %367 ], [ %359, %357 ]
%370 = phi i32* [ %375, %367 ], [ %360, %357 ]
%371 = phi i32* [ %373, %367 ], [ %361, %357 ]
%372 = phi i32 [ %381, %367 ], [ 0, %357 ]
%373 = getelementptr inbounds i32, i32* %371, i64 1
%374 = load i32, i32* %371
%375 = getelementptr inbounds i32, i32* %370, i64 1
%376 = load i32, i32* %370
%377 = shl i32 %376, 4
%378 = or i32 %377, %374
%379 = getelementptr inbounds i32, i32* %369, i64 1
store i32 %378, i32* %369
%380 = add nuw nsw i32 %368, 1
%381 = add i32 %372, 1
%382 = icmp eq i32 %381, %365
br i1 %382, label %383, label %367
383: ; preds = %367, %357
%384 = phi i32* [ undef, %357 ], [ %373, %367 ]
%385 = phi i32* [ undef, %357 ], [ %375, %367 ]
%386 = phi i32* [ undef, %357 ], [ %379, %367 ]
%387 = phi i32 [ %358, %357 ], [ %380, %367 ]
%388 = phi i32* [ %359, %357 ], [ %379, %367 ]
%389 = phi i32* [ %360, %357 ], [ %375, %367 ]
%390 = phi i32* [ %361, %357 ], [ %373, %367 ]
%391 = icmp ult i32 %364, 3
br i1 %391, label %427, label %392
392: ; preds = %383, %392
%393 = phi i32 [ %425, %392 ], [ %387, %383 ]
%394 = phi i32* [ %424, %392 ], [ %388, %383 ]
%395 = phi i32* [ %420, %392 ], [ %389, %383 ]
%396 = phi i32* [ %418, %392 ], [ %390, %383 ]
%397 = getelementptr inbounds i32, i32* %396, i64 1
%398 = load i32, i32* %396
%399 = getelementptr inbounds i32, i32* %395, i64 1
%400 = load i32, i32* %395
%401 = shl i32 %400, 4
%402 = or i32 %401, %398
%403 = getelementptr inbounds i32, i32* %394, i64 1
store i32 %402, i32* %394
%404 = getelementptr inbounds i32, i32* %396, i64 2
%405 = load i32, i32* %397
%406 = getelementptr inbounds i32, i32* %395, i64 2
%407 = load i32, i32* %399
%408 = shl i32 %407, 4
%409 = or i32 %408, %405
%410 = getelementptr inbounds i32, i32* %394, i64 2
store i32 %409, i32* %403
%411 = getelementptr inbounds i32, i32* %396, i64 3
%412 = load i32, i32* %404
%413 = getelementptr inbounds i32, i32* %395, i64 3
%414 = load i32, i32* %406
%415 = shl i32 %414, 4
%416 = or i32 %415, %412
%417 = getelementptr inbounds i32, i32* %394, i64 3
store i32 %416, i32* %410
%418 = getelementptr inbounds i32, i32* %396, i64 4
%419 = load i32, i32* %411
%420 = getelementptr inbounds i32, i32* %395, i64 4
%421 = load i32, i32* %413
%422 = shl i32 %421, 4
%423 = or i32 %422, %419
%424 = getelementptr inbounds i32, i32* %394, i64 4
store i32 %423, i32* %417
%425 = add nuw nsw i32 %393, 4
%426 = icmp eq i32 %425, %1
br i1 %426, label %427, label %392
427: ; preds = %383, %392, %356
%428 = phi i32* [ %285, %356 ], [ %384, %383 ], [ %418, %392 ]
%429 = phi i32* [ %284, %356 ], [ %385, %383 ], [ %420, %392 ]
%430 = phi i32* [ %283, %356 ], [ %386, %383 ], [ %424, %392 ]
br i1 %6, label %431, label %1714
431: ; preds = %427
br i1 %77, label %518, label %432
432: ; preds = %431
%433 = getelementptr i32, i32* %430, i64 %42
%434 = getelementptr i32, i32* %428, i64 %42
%435 = getelementptr i32, i32* %429, i64 %42
%436 = icmp ult i32* %430, %434
%437 = icmp ult i32* %428, %433
%438 = and i1 %436, %437
%439 = icmp ult i32* %430, %435
%440 = icmp ult i32* %429, %433
%441 = and i1 %439, %440
%442 = or i1 %438, %441
br i1 %442, label %518, label %443
443: ; preds = %432
%444 = getelementptr i32, i32* %430, i64 %78
%445 = getelementptr i32, i32* %429, i64 %78
%446 = getelementptr i32, i32* %428, i64 %78
br i1 %81, label %494, label %447
447: ; preds = %443, %447
%448 = phi i64 [ %491, %447 ], [ 0, %443 ]
%449 = phi i64 [ %492, %447 ], [ 0, %443 ]
%450 = getelementptr i32, i32* %430, i64 %448
%451 = getelementptr i32, i32* %429, i64 %448
%452 = getelementptr i32, i32* %428, i64 %448
%453 = bitcast i32* %452 to <4 x i32>*
%454 = load <4 x i32>, <4 x i32>* %453
%455 = getelementptr i32, i32* %452, i64 4
%456 = bitcast i32* %455 to <4 x i32>*
%457 = load <4 x i32>, <4 x i32>* %456
%458 = bitcast i32* %451 to <4 x i32>*
%459 = load <4 x i32>, <4 x i32>* %458
%460 = getelementptr i32, i32* %451, i64 4
%461 = bitcast i32* %460 to <4 x i32>*
%462 = load <4 x i32>, <4 x i32>* %461
%463 = shl <4 x i32> %459, <i32 4, i32 4, i32 4, i32 4>
%464 = shl <4 x i32> %462, <i32 4, i32 4, i32 4, i32 4>
%465 = or <4 x i32> %463, %454
%466 = or <4 x i32> %464, %457
%467 = bitcast i32* %450 to <4 x i32>*
store <4 x i32> %465, <4 x i32>* %467
%468 = getelementptr i32, i32* %450, i64 4
%469 = bitcast i32* %468 to <4 x i32>*
store <4 x i32> %466, <4 x i32>* %469
%470 = or i64 %448, 8
%471 = getelementptr i32, i32* %430, i64 %470
%472 = getelementptr i32, i32* %429, i64 %470
%473 = getelementptr i32, i32* %428, i64 %470
%474 = bitcast i32* %473 to <4 x i32>*
%475 = load <4 x i32>, <4 x i32>* %474
%476 = getelementptr i32, i32* %473, i64 4
%477 = bitcast i32* %476 to <4 x i32>*
%478 = load <4 x i32>, <4 x i32>* %477
%479 = bitcast i32* %472 to <4 x i32>*
%480 = load <4 x i32>, <4 x i32>* %479
%481 = getelementptr i32, i32* %472, i64 4
%482 = bitcast i32* %481 to <4 x i32>*
%483 = load <4 x i32>, <4 x i32>* %482
%484 = shl <4 x i32> %480, <i32 4, i32 4, i32 4, i32 4>
%485 = shl <4 x i32> %483, <i32 4, i32 4, i32 4, i32 4>
%486 = or <4 x i32> %484, %475
%487 = or <4 x i32> %485, %478
%488 = bitcast i32* %471 to <4 x i32>*
store <4 x i32> %486, <4 x i32>* %488
%489 = getelementptr i32, i32* %471, i64 4
%490 = bitcast i32* %489 to <4 x i32>*
store <4 x i32> %487, <4 x i32>* %490
%491 = add nuw i64 %448, 16
%492 = add i64 %449, 2
%493 = icmp eq i64 %492, %82
br i1 %493, label %494, label %447
494: ; preds = %447, %443
%495 = phi i64 [ 0, %443 ], [ %491, %447 ]
br i1 %83, label %517, label %496
496: ; preds = %494
%497 = getelementptr i32, i32* %430, i64 %495
%498 = getelementptr i32, i32* %429, i64 %495
%499 = getelementptr i32, i32* %428, i64 %495
%500 = bitcast i32* %499 to <4 x i32>*
%501 = load <4 x i32>, <4 x i32>* %500
%502 = getelementptr i32, i32* %499, i64 4
%503 = bitcast i32* %502 to <4 x i32>*
%504 = load <4 x i32>, <4 x i32>* %503
%505 = bitcast i32* %498 to <4 x i32>*
%506 = load <4 x i32>, <4 x i32>* %505
%507 = getelementptr i32, i32* %498, i64 4
%508 = bitcast i32* %507 to <4 x i32>*
%509 = load <4 x i32>, <4 x i32>* %508
%510 = shl <4 x i32> %506, <i32 4, i32 4, i32 4, i32 4>
%511 = shl <4 x i32> %509, <i32 4, i32 4, i32 4, i32 4>
%512 = or <4 x i32> %510, %501
%513 = or <4 x i32> %511, %504
%514 = bitcast i32* %497 to <4 x i32>*
store <4 x i32> %512, <4 x i32>* %514
%515 = getelementptr i32, i32* %497, i64 4
%516 = bitcast i32* %515 to <4 x i32>*
store <4 x i32> %513, <4 x i32>* %516
br label %517
517: ; preds = %494, %496
br i1 %84, label %588, label %518
518: ; preds = %432, %431, %517
%519 = phi i32 [ 0, %432 ], [ 0, %431 ], [ %79, %517 ]
%520 = phi i32* [ %430, %432 ], [ %430, %431 ], [ %444, %517 ]
%521 = phi i32* [ %429, %432 ], [ %429, %431 ], [ %445, %517 ]
%522 = phi i32* [ %428, %432 ], [ %428, %431 ], [ %446, %517 ]
%523 = sub i32 %1, %519
%524 = xor i32 %519, -1
%525 = add i32 %524, %1
%526 = and i32 %523, 3
%527 = icmp eq i32 %526, 0
br i1 %527, label %544, label %528
528: ; preds = %518, %528
%529 = phi i32 [ %541, %528 ], [ %519, %518 ]
%530 = phi i32* [ %540, %528 ], [ %520, %518 ]
%531 = phi i32* [ %536, %528 ], [ %521, %518 ]
%532 = phi i32* [ %534, %528 ], [ %522, %518 ]
%533 = phi i32 [ %542, %528 ], [ 0, %518 ]
%534 = getelementptr inbounds i32, i32* %532, i64 1
%535 = load i32, i32* %532
%536 = getelementptr inbounds i32, i32* %531, i64 1
%537 = load i32, i32* %531
%538 = shl i32 %537, 4
%539 = or i32 %538, %535
%540 = getelementptr inbounds i32, i32* %530, i64 1
store i32 %539, i32* %530
%541 = add nuw nsw i32 %529, 1
%542 = add i32 %533, 1
%543 = icmp eq i32 %542, %526
br i1 %543, label %544, label %528
544: ; preds = %528, %518
%545 = phi i32* [ undef, %518 ], [ %534, %528 ]
%546 = phi i32* [ undef, %518 ], [ %536, %528 ]
%547 = phi i32* [ undef, %518 ], [ %540, %528 ]
%548 = phi i32 [ %519, %518 ], [ %541, %528 ]
%549 = phi i32* [ %520, %518 ], [ %540, %528 ]
%550 = phi i32* [ %521, %518 ], [ %536, %528 ]
%551 = phi i32* [ %522, %518 ], [ %534, %528 ]
%552 = icmp ult i32 %525, 3
br i1 %552, label %588, label %553
553: ; preds = %544, %553
%554 = phi i32 [ %586, %553 ], [ %548, %544 ]
%555 = phi i32* [ %585, %553 ], [ %549, %544 ]
%556 = phi i32* [ %581, %553 ], [ %550, %544 ]
%557 = phi i32* [ %579, %553 ], [ %551, %544 ]
%558 = getelementptr inbounds i32, i32* %557, i64 1
%559 = load i32, i32* %557
%560 = getelementptr inbounds i32, i32* %556, i64 1
%561 = load i32, i32* %556
%562 = shl i32 %561, 4
%563 = or i32 %562, %559
%564 = getelementptr inbounds i32, i32* %555, i64 1
store i32 %563, i32* %555
%565 = getelementptr inbounds i32, i32* %557, i64 2
%566 = load i32, i32* %558
%567 = getelementptr inbounds i32, i32* %556, i64 2
%568 = load i32, i32* %560
%569 = shl i32 %568, 4
%570 = or i32 %569, %566
%571 = getelementptr inbounds i32, i32* %555, i64 2
store i32 %570, i32* %564
%572 = getelementptr inbounds i32, i32* %557, i64 3
%573 = load i32, i32* %565
%574 = getelementptr inbounds i32, i32* %556, i64 3
%575 = load i32, i32* %567
%576 = shl i32 %575, 4
%577 = or i32 %576, %573
%578 = getelementptr inbounds i32, i32* %555, i64 3
store i32 %577, i32* %571
%579 = getelementptr inbounds i32, i32* %557, i64 4
%580 = load i32, i32* %572
%581 = getelementptr inbounds i32, i32* %556, i64 4
%582 = load i32, i32* %574
%583 = shl i32 %582, 4
%584 = or i32 %583, %580
%585 = getelementptr inbounds i32, i32* %555, i64 4
store i32 %584, i32* %578
%586 = add nuw nsw i32 %554, 4
%587 = icmp eq i32 %586, %1
br i1 %587, label %588, label %553
588: ; preds = %544, %553, %517
%589 = phi i32* [ %446, %517 ], [ %545, %544 ], [ %579, %553 ]
%590 = phi i32* [ %445, %517 ], [ %546, %544 ], [ %581, %553 ]
%591 = phi i32* [ %444, %517 ], [ %547, %544 ], [ %585, %553 ]
br i1 %6, label %592, label %1714
592: ; preds = %588
br i1 %85, label %679, label %593
593: ; preds = %592
%594 = getelementptr i32, i32* %591, i64 %38
%595 = getelementptr i32, i32* %589, i64 %38
%596 = getelementptr i32, i32* %590, i64 %38
%597 = icmp ult i32* %591, %595
%598 = icmp ult i32* %589, %594
%599 = and i1 %597, %598
%600 = icmp ult i32* %591, %596
%601 = icmp ult i32* %590, %594
%602 = and i1 %600, %601
%603 = or i1 %599, %602
br i1 %603, label %679, label %604
604: ; preds = %593
%605 = getelementptr i32, i32* %591, i64 %86
%606 = getelementptr i32, i32* %590, i64 %86
%607 = getelementptr i32, i32* %589, i64 %86
br i1 %89, label %655, label %608
608: ; preds = %604, %608
%609 = phi i64 [ %652, %608 ], [ 0, %604 ]
%610 = phi i64 [ %653, %608 ], [ 0, %604 ]
%611 = getelementptr i32, i32* %591, i64 %609
%612 = getelementptr i32, i32* %590, i64 %609
%613 = getelementptr i32, i32* %589, i64 %609
%614 = bitcast i32* %613 to <4 x i32>*
%615 = load <4 x i32>, <4 x i32>* %614
%616 = getelementptr i32, i32* %613, i64 4
%617 = bitcast i32* %616 to <4 x i32>*
%618 = load <4 x i32>, <4 x i32>* %617
%619 = bitcast i32* %612 to <4 x i32>*
%620 = load <4 x i32>, <4 x i32>* %619
%621 = getelementptr i32, i32* %612, i64 4
%622 = bitcast i32* %621 to <4 x i32>*
%623 = load <4 x i32>, <4 x i32>* %622
%624 = shl <4 x i32> %620, <i32 4, i32 4, i32 4, i32 4>
%625 = shl <4 x i32> %623, <i32 4, i32 4, i32 4, i32 4>
%626 = or <4 x i32> %624, %615
%627 = or <4 x i32> %625, %618
%628 = bitcast i32* %611 to <4 x i32>*
store <4 x i32> %626, <4 x i32>* %628
%629 = getelementptr i32, i32* %611, i64 4
%630 = bitcast i32* %629 to <4 x i32>*
store <4 x i32> %627, <4 x i32>* %630
%631 = or i64 %609, 8
%632 = getelementptr i32, i32* %591, i64 %631
%633 = getelementptr i32, i32* %590, i64 %631
%634 = getelementptr i32, i32* %589, i64 %631
%635 = bitcast i32* %634 to <4 x i32>*
%636 = load <4 x i32>, <4 x i32>* %635
%637 = getelementptr i32, i32* %634, i64 4
%638 = bitcast i32* %637 to <4 x i32>*
%639 = load <4 x i32>, <4 x i32>* %638
%640 = bitcast i32* %633 to <4 x i32>*
%641 = load <4 x i32>, <4 x i32>* %640
%642 = getelementptr i32, i32* %633, i64 4
%643 = bitcast i32* %642 to <4 x i32>*
%644 = load <4 x i32>, <4 x i32>* %643
%645 = shl <4 x i32> %641, <i32 4, i32 4, i32 4, i32 4>
%646 = shl <4 x i32> %644, <i32 4, i32 4, i32 4, i32 4>
%647 = or <4 x i32> %645, %636
%648 = or <4 x i32> %646, %639
%649 = bitcast i32* %632 to <4 x i32>*
store <4 x i32> %647, <4 x i32>* %649
%650 = getelementptr i32, i32* %632, i64 4
%651 = bitcast i32* %650 to <4 x i32>*
store <4 x i32> %648, <4 x i32>* %651
%652 = add nuw i64 %609, 16
%653 = add i64 %610, 2
%654 = icmp eq i64 %653, %90
br i1 %654, label %655, label %608
655: ; preds = %608, %604
%656 = phi i64 [ 0, %604 ], [ %652, %608 ]
br i1 %91, label %678, label %657
657: ; preds = %655
%658 = getelementptr i32, i32* %591, i64 %656
%659 = getelementptr i32, i32* %590, i64 %656
%660 = getelementptr i32, i32* %589, i64 %656
%661 = bitcast i32* %660 to <4 x i32>*
%662 = load <4 x i32>, <4 x i32>* %661
%663 = getelementptr i32, i32* %660, i64 4
%664 = bitcast i32* %663 to <4 x i32>*
%665 = load <4 x i32>, <4 x i32>* %664
%666 = bitcast i32* %659 to <4 x i32>*
%667 = load <4 x i32>, <4 x i32>* %666
%668 = getelementptr i32, i32* %659, i64 4
%669 = bitcast i32* %668 to <4 x i32>*
%670 = load <4 x i32>, <4 x i32>* %669
%671 = shl <4 x i32> %667, <i32 4, i32 4, i32 4, i32 4>
%672 = shl <4 x i32> %670, <i32 4, i32 4, i32 4, i32 4>
%673 = or <4 x i32> %671, %662
%674 = or <4 x i32> %672, %665
%675 = bitcast i32* %658 to <4 x i32>*
store <4 x i32> %673, <4 x i32>* %675
%676 = getelementptr i32, i32* %658, i64 4
%677 = bitcast i32* %676 to <4 x i32>*
store <4 x i32> %674, <4 x i32>* %677
br label %678
678: ; preds = %655, %657
br i1 %92, label %749, label %679
679: ; preds = %593, %592, %678
%680 = phi i32 [ 0, %593 ], [ 0, %592 ], [ %87, %678 ]
%681 = phi i32* [ %591, %593 ], [ %591, %592 ], [ %605, %678 ]
%682 = phi i32* [ %590, %593 ], [ %590, %592 ], [ %606, %678 ]
%683 = phi i32* [ %589, %593 ], [ %589, %592 ], [ %607, %678 ]
%684 = sub i32 %1, %680
%685 = xor i32 %680, -1
%686 = add i32 %685, %1
%687 = and i32 %684, 3
%688 = icmp eq i32 %687, 0
br i1 %688, label %705, label %689
689: ; preds = %679, %689
%690 = phi i32 [ %702, %689 ], [ %680, %679 ]
%691 = phi i32* [ %701, %689 ], [ %681, %679 ]
%692 = phi i32* [ %697, %689 ], [ %682, %679 ]
%693 = phi i32* [ %695, %689 ], [ %683, %679 ]
%694 = phi i32 [ %703, %689 ], [ 0, %679 ]
%695 = getelementptr inbounds i32, i32* %693, i64 1
%696 = load i32, i32* %693
%697 = getelementptr inbounds i32, i32* %692, i64 1
%698 = load i32, i32* %692
%699 = shl i32 %698, 4
%700 = or i32 %699, %696
%701 = getelementptr inbounds i32, i32* %691, i64 1
store i32 %700, i32* %691
%702 = add nuw nsw i32 %690, 1
%703 = add i32 %694, 1
%704 = icmp eq i32 %703, %687
br i1 %704, label %705, label %689
705: ; preds = %689, %679
%706 = phi i32* [ undef, %679 ], [ %695, %689 ]
%707 = phi i32* [ undef, %679 ], [ %697, %689 ]
%708 = phi i32* [ undef, %679 ], [ %701, %689 ]
%709 = phi i32 [ %680, %679 ], [ %702, %689 ]
%710 = phi i32* [ %681, %679 ], [ %701, %689 ]
%711 = phi i32* [ %682, %679 ], [ %697, %689 ]
%712 = phi i32* [ %683, %679 ], [ %695, %689 ]
%713 = icmp ult i32 %686, 3
br i1 %713, label %749, label %714
714: ; preds = %705, %714
%715 = phi i32 [ %747, %714 ], [ %709, %705 ]
%716 = phi i32* [ %746, %714 ], [ %710, %705 ]
%717 = phi i32* [ %742, %714 ], [ %711, %705 ]
%718 = phi i32* [ %740, %714 ], [ %712, %705 ]
%719 = getelementptr inbounds i32, i32* %718, i64 1
%720 = load i32, i32* %718
%721 = getelementptr inbounds i32, i32* %717, i64 1
%722 = load i32, i32* %717
%723 = shl i32 %722, 4
%724 = or i32 %723, %720
%725 = getelementptr inbounds i32, i32* %716, i64 1
store i32 %724, i32* %716
%726 = getelementptr inbounds i32, i32* %718, i64 2
%727 = load i32, i32* %719
%728 = getelementptr inbounds i32, i32* %717, i64 2
%729 = load i32, i32* %721
%730 = shl i32 %729, 4
%731 = or i32 %730, %727
%732 = getelementptr inbounds i32, i32* %716, i64 2
store i32 %731, i32* %725
%733 = getelementptr inbounds i32, i32* %718, i64 3
%734 = load i32, i32* %726
%735 = getelementptr inbounds i32, i32* %717, i64 3
%736 = load i32, i32* %728
%737 = shl i32 %736, 4
%738 = or i32 %737, %734
%739 = getelementptr inbounds i32, i32* %716, i64 3
store i32 %738, i32* %732
%740 = getelementptr inbounds i32, i32* %718, i64 4
%741 = load i32, i32* %733
%742 = getelementptr inbounds i32, i32* %717, i64 4
%743 = load i32, i32* %735
%744 = shl i32 %743, 4
%745 = or i32 %744, %741
%746 = getelementptr inbounds i32, i32* %716, i64 4
store i32 %745, i32* %739
%747 = add nuw nsw i32 %715, 4
%748 = icmp eq i32 %747, %1
br i1 %748, label %749, label %714
749: ; preds = %705, %714, %678
%750 = phi i32* [ %607, %678 ], [ %706, %705 ], [ %740, %714 ]
%751 = phi i32* [ %606, %678 ], [ %707, %705 ], [ %742, %714 ]
%752 = phi i32* [ %605, %678 ], [ %708, %705 ], [ %746, %714 ]
br i1 %6, label %753, label %1714
753: ; preds = %749
br i1 %93, label %840, label %754
754: ; preds = %753
%755 = getelementptr i32, i32* %752, i64 %33
%756 = getelementptr i32, i32* %750, i64 %33
%757 = getelementptr i32, i32* %751, i64 %33
%758 = icmp ult i32* %752, %756
%759 = icmp ult i32* %750, %755
%760 = and i1 %758, %759
%761 = icmp ult i32* %752, %757
%762 = icmp ult i32* %751, %755
%763 = and i1 %761, %762
%764 = or i1 %760, %763
br i1 %764, label %840, label %765
765: ; preds = %754
%766 = getelementptr i32, i32* %752, i64 %94
%767 = getelementptr i32, i32* %751, i64 %94
%768 = getelementptr i32, i32* %750, i64 %94
br i1 %97, label %816, label %769
769: ; preds = %765, %769
%770 = phi i64 [ %813, %769 ], [ 0, %765 ]
%771 = phi i64 [ %814, %769 ], [ 0, %765 ]
%772 = getelementptr i32, i32* %752, i64 %770
%773 = getelementptr i32, i32* %751, i64 %770
%774 = getelementptr i32, i32* %750, i64 %770
%775 = bitcast i32* %774 to <4 x i32>*
%776 = load <4 x i32>, <4 x i32>* %775
%777 = getelementptr i32, i32* %774, i64 4
%778 = bitcast i32* %777 to <4 x i32>*
%779 = load <4 x i32>, <4 x i32>* %778
%780 = bitcast i32* %773 to <4 x i32>*
%781 = load <4 x i32>, <4 x i32>* %780
%782 = getelementptr i32, i32* %773, i64 4
%783 = bitcast i32* %782 to <4 x i32>*
%784 = load <4 x i32>, <4 x i32>* %783
%785 = shl <4 x i32> %781, <i32 4, i32 4, i32 4, i32 4>
%786 = shl <4 x i32> %784, <i32 4, i32 4, i32 4, i32 4>
%787 = or <4 x i32> %785, %776
%788 = or <4 x i32> %786, %779
%789 = bitcast i32* %772 to <4 x i32>*
store <4 x i32> %787, <4 x i32>* %789
%790 = getelementptr i32, i32* %772, i64 4
%791 = bitcast i32* %790 to <4 x i32>*
store <4 x i32> %788, <4 x i32>* %791
%792 = or i64 %770, 8
%793 = getelementptr i32, i32* %752, i64 %792
%794 = getelementptr i32, i32* %751, i64 %792
%795 = getelementptr i32, i32* %750, i64 %792
%796 = bitcast i32* %795 to <4 x i32>*
%797 = load <4 x i32>, <4 x i32>* %796
%798 = getelementptr i32, i32* %795, i64 4
%799 = bitcast i32* %798 to <4 x i32>*
%800 = load <4 x i32>, <4 x i32>* %799
%801 = bitcast i32* %794 to <4 x i32>*
%802 = load <4 x i32>, <4 x i32>* %801
%803 = getelementptr i32, i32* %794, i64 4
%804 = bitcast i32* %803 to <4 x i32>*
%805 = load <4 x i32>, <4 x i32>* %804
%806 = shl <4 x i32> %802, <i32 4, i32 4, i32 4, i32 4>
%807 = shl <4 x i32> %805, <i32 4, i32 4, i32 4, i32 4>
%808 = or <4 x i32> %806, %797
%809 = or <4 x i32> %807, %800
%810 = bitcast i32* %793 to <4 x i32>*
store <4 x i32> %808, <4 x i32>* %810
%811 = getelementptr i32, i32* %793, i64 4
%812 = bitcast i32* %811 to <4 x i32>*
store <4 x i32> %809, <4 x i32>* %812
%813 = add nuw i64 %770, 16
%814 = add i64 %771, 2
%815 = icmp eq i64 %814, %98
br i1 %815, label %816, label %769
816: ; preds = %769, %765
%817 = phi i64 [ 0, %765 ], [ %813, %769 ]
br i1 %99, label %839, label %818
818: ; preds = %816
%819 = getelementptr i32, i32* %752, i64 %817
%820 = getelementptr i32, i32* %751, i64 %817
%821 = getelementptr i32, i32* %750, i64 %817
%822 = bitcast i32* %821 to <4 x i32>*
%823 = load <4 x i32>, <4 x i32>* %822
%824 = getelementptr i32, i32* %821, i64 4
%825 = bitcast i32* %824 to <4 x i32>*
%826 = load <4 x i32>, <4 x i32>* %825
%827 = bitcast i32* %820 to <4 x i32>*
%828 = load <4 x i32>, <4 x i32>* %827
%829 = getelementptr i32, i32* %820, i64 4
%830 = bitcast i32* %829 to <4 x i32>*
%831 = load <4 x i32>, <4 x i32>* %830
%832 = shl <4 x i32> %828, <i32 4, i32 4, i32 4, i32 4>
%833 = shl <4 x i32> %831, <i32 4, i32 4, i32 4, i32 4>
%834 = or <4 x i32> %832, %823
%835 = or <4 x i32> %833, %826
%836 = bitcast i32* %819 to <4 x i32>*
store <4 x i32> %834, <4 x i32>* %836
%837 = getelementptr i32, i32* %819, i64 4
%838 = bitcast i32* %837 to <4 x i32>*
store <4 x i32> %835, <4 x i32>* %838
br label %839
839: ; preds = %816, %818
br i1 %100, label %910, label %840
840: ; preds = %754, %753, %839
%841 = phi i32 [ 0, %754 ], [ 0, %753 ], [ %95, %839 ]
%842 = phi i32* [ %752, %754 ], [ %752, %753 ], [ %766, %839 ]
%843 = phi i32* [ %751, %754 ], [ %751, %753 ], [ %767, %839 ]
%844 = phi i32* [ %750, %754 ], [ %750, %753 ], [ %768, %839 ]
%845 = sub i32 %1, %841
%846 = xor i32 %841, -1
%847 = add i32 %846, %1
%848 = and i32 %845, 3
%849 = icmp eq i32 %848, 0
br i1 %849, label %866, label %850
850: ; preds = %840, %850
%851 = phi i32 [ %863, %850 ], [ %841, %840 ]
%852 = phi i32* [ %862, %850 ], [ %842, %840 ]
%853 = phi i32* [ %858, %850 ], [ %843, %840 ]
%854 = phi i32* [ %856, %850 ], [ %844, %840 ]
%855 = phi i32 [ %864, %850 ], [ 0, %840 ]
%856 = getelementptr inbounds i32, i32* %854, i64 1
%857 = load i32, i32* %854
%858 = getelementptr inbounds i32, i32* %853, i64 1
%859 = load i32, i32* %853
%860 = shl i32 %859, 4
%861 = or i32 %860, %857
%862 = getelementptr inbounds i32, i32* %852, i64 1
store i32 %861, i32* %852
%863 = add nuw nsw i32 %851, 1
%864 = add i32 %855, 1
%865 = icmp eq i32 %864, %848
br i1 %865, label %866, label %850
866: ; preds = %850, %840
%867 = phi i32* [ undef, %840 ], [ %856, %850 ]
%868 = phi i32* [ undef, %840 ], [ %858, %850 ]
%869 = phi i32* [ undef, %840 ], [ %862, %850 ]
%870 = phi i32 [ %841, %840 ], [ %863, %850 ]
%871 = phi i32* [ %842, %840 ], [ %862, %850 ]
%872 = phi i32* [ %843, %840 ], [ %858, %850 ]
%873 = phi i32* [ %844, %840 ], [ %856, %850 ]
%874 = icmp ult i32 %847, 3
br i1 %874, label %910, label %875
875: ; preds = %866, %875
%876 = phi i32 [ %908, %875 ], [ %870, %866 ]
%877 = phi i32* [ %907, %875 ], [ %871, %866 ]
%878 = phi i32* [ %903, %875 ], [ %872, %866 ]
%879 = phi i32* [ %901, %875 ], [ %873, %866 ]
%880 = getelementptr inbounds i32, i32* %879, i64 1
%881 = load i32, i32* %879
%882 = getelementptr inbounds i32, i32* %878, i64 1
%883 = load i32, i32* %878
%884 = shl i32 %883, 4
%885 = or i32 %884, %881
%886 = getelementptr inbounds i32, i32* %877, i64 1
store i32 %885, i32* %877
%887 = getelementptr inbounds i32, i32* %879, i64 2
%888 = load i32, i32* %880
%889 = getelementptr inbounds i32, i32* %878, i64 2
%890 = load i32, i32* %882
%891 = shl i32 %890, 4
%892 = or i32 %891, %888
%893 = getelementptr inbounds i32, i32* %877, i64 2
store i32 %892, i32* %886
%894 = getelementptr inbounds i32, i32* %879, i64 3
%895 = load i32, i32* %887
%896 = getelementptr inbounds i32, i32* %878, i64 3
%897 = load i32, i32* %889
%898 = shl i32 %897, 4
%899 = or i32 %898, %895
%900 = getelementptr inbounds i32, i32* %877, i64 3
store i32 %899, i32* %893
%901 = getelementptr inbounds i32, i32* %879, i64 4
%902 = load i32, i32* %894
%903 = getelementptr inbounds i32, i32* %878, i64 4
%904 = load i32, i32* %896
%905 = shl i32 %904, 4
%906 = or i32 %905, %902
%907 = getelementptr inbounds i32, i32* %877, i64 4
store i32 %906, i32* %900
%908 = add nuw nsw i32 %876, 4
%909 = icmp eq i32 %908, %1
br i1 %909, label %910, label %875
910: ; preds = %866, %875, %839
%911 = phi i32* [ %768, %839 ], [ %867, %866 ], [ %901, %875 ]
%912 = phi i32* [ %767, %839 ], [ %868, %866 ], [ %903, %875 ]
%913 = phi i32* [ %766, %839 ], [ %869, %866 ], [ %907, %875 ]
br i1 %6, label %914, label %1714
914: ; preds = %910
br i1 %101, label %1001, label %915
915: ; preds = %914
%916 = getelementptr i32, i32* %913, i64 %28
%917 = getelementptr i32, i32* %911, i64 %28
%918 = getelementptr i32, i32* %912, i64 %28
%919 = icmp ult i32* %913, %917
%920 = icmp ult i32* %911, %916
%921 = and i1 %919, %920
%922 = icmp ult i32* %913, %918
%923 = icmp ult i32* %912, %916
%924 = and i1 %922, %923
%925 = or i1 %921, %924
br i1 %925, label %1001, label %926
926: ; preds = %915
%927 = getelementptr i32, i32* %913, i64 %102
%928 = getelementptr i32, i32* %912, i64 %102
%929 = getelementptr i32, i32* %911, i64 %102
br i1 %105, label %977, label %930
930: ; preds = %926, %930
%931 = phi i64 [ %974, %930 ], [ 0, %926 ]
%932 = phi i64 [ %975, %930 ], [ 0, %926 ]
%933 = getelementptr i32, i32* %913, i64 %931
%934 = getelementptr i32, i32* %912, i64 %931
%935 = getelementptr i32, i32* %911, i64 %931
%936 = bitcast i32* %935 to <4 x i32>*
%937 = load <4 x i32>, <4 x i32>* %936
%938 = getelementptr i32, i32* %935, i64 4
%939 = bitcast i32* %938 to <4 x i32>*
%940 = load <4 x i32>, <4 x i32>* %939
%941 = bitcast i32* %934 to <4 x i32>*
%942 = load <4 x i32>, <4 x i32>* %941
%943 = getelementptr i32, i32* %934, i64 4
%944 = bitcast i32* %943 to <4 x i32>*
%945 = load <4 x i32>, <4 x i32>* %944
%946 = shl <4 x i32> %942, <i32 4, i32 4, i32 4, i32 4>
%947 = shl <4 x i32> %945, <i32 4, i32 4, i32 4, i32 4>
%948 = or <4 x i32> %946, %937
%949 = or <4 x i32> %947, %940
%950 = bitcast i32* %933 to <4 x i32>*
store <4 x i32> %948, <4 x i32>* %950
%951 = getelementptr i32, i32* %933, i64 4
%952 = bitcast i32* %951 to <4 x i32>*
store <4 x i32> %949, <4 x i32>* %952
%953 = or i64 %931, 8
%954 = getelementptr i32, i32* %913, i64 %953
%955 = getelementptr i32, i32* %912, i64 %953
%956 = getelementptr i32, i32* %911, i64 %953
%957 = bitcast i32* %956 to <4 x i32>*
%958 = load <4 x i32>, <4 x i32>* %957
%959 = getelementptr i32, i32* %956, i64 4
%960 = bitcast i32* %959 to <4 x i32>*
%961 = load <4 x i32>, <4 x i32>* %960
%962 = bitcast i32* %955 to <4 x i32>*
%963 = load <4 x i32>, <4 x i32>* %962
%964 = getelementptr i32, i32* %955, i64 4
%965 = bitcast i32* %964 to <4 x i32>*
%966 = load <4 x i32>, <4 x i32>* %965
%967 = shl <4 x i32> %963, <i32 4, i32 4, i32 4, i32 4>
%968 = shl <4 x i32> %966, <i32 4, i32 4, i32 4, i32 4>
%969 = or <4 x i32> %967, %958
%970 = or <4 x i32> %968, %961
%971 = bitcast i32* %954 to <4 x i32>*
store <4 x i32> %969, <4 x i32>* %971
%972 = getelementptr i32, i32* %954, i64 4
%973 = bitcast i32* %972 to <4 x i32>*
store <4 x i32> %970, <4 x i32>* %973
%974 = add nuw i64 %931, 16
%975 = add i64 %932, 2
%976 = icmp eq i64 %975, %106
br i1 %976, label %977, label %930
977: ; preds = %930, %926
%978 = phi i64 [ 0, %926 ], [ %974, %930 ]
br i1 %107, label %1000, label %979
979: ; preds = %977
%980 = getelementptr i32, i32* %913, i64 %978
%981 = getelementptr i32, i32* %912, i64 %978
%982 = getelementptr i32, i32* %911, i64 %978
%983 = bitcast i32* %982 to <4 x i32>*
%984 = load <4 x i32>, <4 x i32>* %983
%985 = getelementptr i32, i32* %982, i64 4
%986 = bitcast i32* %985 to <4 x i32>*
%987 = load <4 x i32>, <4 x i32>* %986
%988 = bitcast i32* %981 to <4 x i32>*
%989 = load <4 x i32>, <4 x i32>* %988
%990 = getelementptr i32, i32* %981, i64 4
%991 = bitcast i32* %990 to <4 x i32>*
%992 = load <4 x i32>, <4 x i32>* %991
%993 = shl <4 x i32> %989, <i32 4, i32 4, i32 4, i32 4>
%994 = shl <4 x i32> %992, <i32 4, i32 4, i32 4, i32 4>
%995 = or <4 x i32> %993, %984
%996 = or <4 x i32> %994, %987
%997 = bitcast i32* %980 to <4 x i32>*
store <4 x i32> %995, <4 x i32>* %997
%998 = getelementptr i32, i32* %980, i64 4
%999 = bitcast i32* %998 to <4 x i32>*
store <4 x i32> %996, <4 x i32>* %999
br label %1000
1000: ; preds = %977, %979
br i1 %108, label %1071, label %1001
1001: ; preds = %915, %914, %1000
%1002 = phi i32 [ 0, %915 ], [ 0, %914 ], [ %103, %1000 ]
%1003 = phi i32* [ %913, %915 ], [ %913, %914 ], [ %927, %1000 ]
%1004 = phi i32* [ %912, %915 ], [ %912, %914 ], [ %928, %1000 ]
%1005 = phi i32* [ %911, %915 ], [ %911, %914 ], [ %929, %1000 ]
%1006 = sub i32 %1, %1002
%1007 = xor i32 %1002, -1
%1008 = add i32 %1007, %1
%1009 = and i32 %1006, 3
%1010 = icmp eq i32 %1009, 0
br i1 %1010, label %1027, label %1011
1011: ; preds = %1001, %1011
%1012 = phi i32 [ %1024, %1011 ], [ %1002, %1001 ]
%1013 = phi i32* [ %1023, %1011 ], [ %1003, %1001 ]
%1014 = phi i32* [ %1019, %1011 ], [ %1004, %1001 ]
%1015 = phi i32* [ %1017, %1011 ], [ %1005, %1001 ]
%1016 = phi i32 [ %1025, %1011 ], [ 0, %1001 ]
%1017 = getelementptr inbounds i32, i32* %1015, i64 1
%1018 = load i32, i32* %1015
%1019 = getelementptr inbounds i32, i32* %1014, i64 1
%1020 = load i32, i32* %1014
%1021 = shl i32 %1020, 4
%1022 = or i32 %1021, %1018
%1023 = getelementptr inbounds i32, i32* %1013, i64 1
store i32 %1022, i32* %1013
%1024 = add nuw nsw i32 %1012, 1
%1025 = add i32 %1016, 1
%1026 = icmp eq i32 %1025, %1009
br i1 %1026, label %1027, label %1011
1027: ; preds = %1011, %1001
%1028 = phi i32* [ undef, %1001 ], [ %1017, %1011 ]
%1029 = phi i32* [ undef, %1001 ], [ %1019, %1011 ]
%1030 = phi i32* [ undef, %1001 ], [ %1023, %1011 ]
%1031 = phi i32 [ %1002, %1001 ], [ %1024, %1011 ]
%1032 = phi i32* [ %1003, %1001 ], [ %1023, %1011 ]
%1033 = phi i32* [ %1004, %1001 ], [ %1019, %1011 ]
%1034 = phi i32* [ %1005, %1001 ], [ %1017, %1011 ]
%1035 = icmp ult i32 %1008, 3
br i1 %1035, label %1071, label %1036
1036: ; preds = %1027, %1036
%1037 = phi i32 [ %1069, %1036 ], [ %1031, %1027 ]
%1038 = phi i32* [ %1068, %1036 ], [ %1032, %1027 ]
%1039 = phi i32* [ %1064, %1036 ], [ %1033, %1027 ]
%1040 = phi i32* [ %1062, %1036 ], [ %1034, %1027 ]
%1041 = getelementptr inbounds i32, i32* %1040, i64 1
%1042 = load i32, i32* %1040
%1043 = getelementptr inbounds i32, i32* %1039, i64 1
%1044 = load i32, i32* %1039
%1045 = shl i32 %1044, 4
%1046 = or i32 %1045, %1042
%1047 = getelementptr inbounds i32, i32* %1038, i64 1
store i32 %1046, i32* %1038
%1048 = getelementptr inbounds i32, i32* %1040, i64 2
%1049 = load i32, i32* %1041
%1050 = getelementptr inbounds i32, i32* %1039, i64 2
%1051 = load i32, i32* %1043
%1052 = shl i32 %1051, 4
%1053 = or i32 %1052, %1049
%1054 = getelementptr inbounds i32, i32* %1038, i64 2
store i32 %1053, i32* %1047
%1055 = getelementptr inbounds i32, i32* %1040, i64 3
%1056 = load i32, i32* %1048
%1057 = getelementptr inbounds i32, i32* %1039, i64 3
%1058 = load i32, i32* %1050
%1059 = shl i32 %1058, 4
%1060 = or i32 %1059, %1056
%1061 = getelementptr inbounds i32, i32* %1038, i64 3
store i32 %1060, i32* %1054
%1062 = getelementptr inbounds i32, i32* %1040, i64 4
%1063 = load i32, i32* %1055
%1064 = getelementptr inbounds i32, i32* %1039, i64 4
%1065 = load i32, i32* %1057
%1066 = shl i32 %1065, 4
%1067 = or i32 %1066, %1063
%1068 = getelementptr inbounds i32, i32* %1038, i64 4
store i32 %1067, i32* %1061
%1069 = add nuw nsw i32 %1037, 4
%1070 = icmp eq i32 %1069, %1
br i1 %1070, label %1071, label %1036
1071: ; preds = %1027, %1036, %1000
%1072 = phi i32* [ %929, %1000 ], [ %1028, %1027 ], [ %1062, %1036 ]
%1073 = phi i32* [ %928, %1000 ], [ %1029, %1027 ], [ %1064, %1036 ]
%1074 = phi i32* [ %927, %1000 ], [ %1030, %1027 ], [ %1068, %1036 ]
br i1 %6, label %1075, label %1714
1075: ; preds = %1071
br i1 %109, label %1162, label %1076
1076: ; preds = %1075
%1077 = getelementptr i32, i32* %1074, i64 %24
%1078 = getelementptr i32, i32* %1072, i64 %24
%1079 = getelementptr i32, i32* %1073, i64 %24
%1080 = icmp ult i32* %1074, %1078
%1081 = icmp ult i32* %1072, %1077
%1082 = and i1 %1080, %1081
%1083 = icmp ult i32* %1074, %1079
%1084 = icmp ult i32* %1073, %1077
%1085 = and i1 %1083, %1084
%1086 = or i1 %1082, %1085
br i1 %1086, label %1162, label %1087
1087: ; preds = %1076
%1088 = getelementptr i32, i32* %1074, i64 %110
%1089 = getelementptr i32, i32* %1073, i64 %110
%1090 = getelementptr i32, i32* %1072, i64 %110
br i1 %113, label %1138, label %1091
1091: ; preds = %1087, %1091
%1092 = phi i64 [ %1135, %1091 ], [ 0, %1087 ]
%1093 = phi i64 [ %1136, %1091 ], [ 0, %1087 ]
%1094 = getelementptr i32, i32* %1074, i64 %1092
%1095 = getelementptr i32, i32* %1073, i64 %1092
%1096 = getelementptr i32, i32* %1072, i64 %1092
%1097 = bitcast i32* %1096 to <4 x i32>*
%1098 = load <4 x i32>, <4 x i32>* %1097
%1099 = getelementptr i32, i32* %1096, i64 4
%1100 = bitcast i32* %1099 to <4 x i32>*
%1101 = load <4 x i32>, <4 x i32>* %1100
%1102 = bitcast i32* %1095 to <4 x i32>*
%1103 = load <4 x i32>, <4 x i32>* %1102
%1104 = getelementptr i32, i32* %1095, i64 4
%1105 = bitcast i32* %1104 to <4 x i32>*
%1106 = load <4 x i32>, <4 x i32>* %1105
%1107 = shl <4 x i32> %1103, <i32 4, i32 4, i32 4, i32 4>
%1108 = shl <4 x i32> %1106, <i32 4, i32 4, i32 4, i32 4>
%1109 = or <4 x i32> %1107, %1098
%1110 = or <4 x i32> %1108, %1101
%1111 = bitcast i32* %1094 to <4 x i32>*
store <4 x i32> %1109, <4 x i32>* %1111
%1112 = getelementptr i32, i32* %1094, i64 4
%1113 = bitcast i32* %1112 to <4 x i32>*
store <4 x i32> %1110, <4 x i32>* %1113
%1114 = or i64 %1092, 8
%1115 = getelementptr i32, i32* %1074, i64 %1114
%1116 = getelementptr i32, i32* %1073, i64 %1114
%1117 = getelementptr i32, i32* %1072, i64 %1114
%1118 = bitcast i32* %1117 to <4 x i32>*
%1119 = load <4 x i32>, <4 x i32>* %1118
%1120 = getelementptr i32, i32* %1117, i64 4
%1121 = bitcast i32* %1120 to <4 x i32>*
%1122 = load <4 x i32>, <4 x i32>* %1121
%1123 = bitcast i32* %1116 to <4 x i32>*
%1124 = load <4 x i32>, <4 x i32>* %1123
%1125 = getelementptr i32, i32* %1116, i64 4
%1126 = bitcast i32* %1125 to <4 x i32>*
%1127 = load <4 x i32>, <4 x i32>* %1126
%1128 = shl <4 x i32> %1124, <i32 4, i32 4, i32 4, i32 4>
%1129 = shl <4 x i32> %1127, <i32 4, i32 4, i32 4, i32 4>
%1130 = or <4 x i32> %1128, %1119
%1131 = or <4 x i32> %1129, %1122
%1132 = bitcast i32* %1115 to <4 x i32>*
store <4 x i32> %1130, <4 x i32>* %1132
%1133 = getelementptr i32, i32* %1115, i64 4
%1134 = bitcast i32* %1133 to <4 x i32>*
store <4 x i32> %1131, <4 x i32>* %1134
%1135 = add nuw i64 %1092, 16
%1136 = add i64 %1093, 2
%1137 = icmp eq i64 %1136, %114
br i1 %1137, label %1138, label %1091
1138: ; preds = %1091, %1087
%1139 = phi i64 [ 0, %1087 ], [ %1135, %1091 ]
br i1 %115, label %1161, label %1140
1140: ; preds = %1138
%1141 = getelementptr i32, i32* %1074, i64 %1139
%1142 = getelementptr i32, i32* %1073, i64 %1139
%1143 = getelementptr i32, i32* %1072, i64 %1139
%1144 = bitcast i32* %1143 to <4 x i32>*
%1145 = load <4 x i32>, <4 x i32>* %1144
%1146 = getelementptr i32, i32* %1143, i64 4
%1147 = bitcast i32* %1146 to <4 x i32>*
%1148 = load <4 x i32>, <4 x i32>* %1147
%1149 = bitcast i32* %1142 to <4 x i32>*
%1150 = load <4 x i32>, <4 x i32>* %1149
%1151 = getelementptr i32, i32* %1142, i64 4
%1152 = bitcast i32* %1151 to <4 x i32>*
%1153 = load <4 x i32>, <4 x i32>* %1152
%1154 = shl <4 x i32> %1150, <i32 4, i32 4, i32 4, i32 4>
%1155 = shl <4 x i32> %1153, <i32 4, i32 4, i32 4, i32 4>
%1156 = or <4 x i32> %1154, %1145
%1157 = or <4 x i32> %1155, %1148
%1158 = bitcast i32* %1141 to <4 x i32>*
store <4 x i32> %1156, <4 x i32>* %1158
%1159 = getelementptr i32, i32* %1141, i64 4
%1160 = bitcast i32* %1159 to <4 x i32>*
store <4 x i32> %1157, <4 x i32>* %1160
br label %1161
1161: ; preds = %1138, %1140
br i1 %116, label %1232, label %1162
1162: ; preds = %1076, %1075, %1161
%1163 = phi i32 [ 0, %1076 ], [ 0, %1075 ], [ %111, %1161 ]
%1164 = phi i32* [ %1074, %1076 ], [ %1074, %1075 ], [ %1088, %1161 ]
%1165 = phi i32* [ %1073, %1076 ], [ %1073, %1075 ], [ %1089, %1161 ]
%1166 = phi i32* [ %1072, %1076 ], [ %1072, %1075 ], [ %1090, %1161 ]
%1167 = sub i32 %1, %1163
%1168 = xor i32 %1163, -1
%1169 = add i32 %1168, %1
%1170 = and i32 %1167, 3
%1171 = icmp eq i32 %1170, 0
br i1 %1171, label %1188, label %1172
1172: ; preds = %1162, %1172
%1173 = phi i32 [ %1185, %1172 ], [ %1163, %1162 ]
%1174 = phi i32* [ %1184, %1172 ], [ %1164, %1162 ]
%1175 = phi i32* [ %1180, %1172 ], [ %1165, %1162 ]
%1176 = phi i32* [ %1178, %1172 ], [ %1166, %1162 ]
%1177 = phi i32 [ %1186, %1172 ], [ 0, %1162 ]
%1178 = getelementptr inbounds i32, i32* %1176, i64 1
%1179 = load i32, i32* %1176
%1180 = getelementptr inbounds i32, i32* %1175, i64 1
%1181 = load i32, i32* %1175
%1182 = shl i32 %1181, 4
%1183 = or i32 %1182, %1179
%1184 = getelementptr inbounds i32, i32* %1174, i64 1
store i32 %1183, i32* %1174
%1185 = add nuw nsw i32 %1173, 1
%1186 = add i32 %1177, 1
%1187 = icmp eq i32 %1186, %1170
br i1 %1187, label %1188, label %1172
1188: ; preds = %1172, %1162
%1189 = phi i32* [ undef, %1162 ], [ %1178, %1172 ]
%1190 = phi i32* [ undef, %1162 ], [ %1180, %1172 ]
%1191 = phi i32* [ undef, %1162 ], [ %1184, %1172 ]
%1192 = phi i32 [ %1163, %1162 ], [ %1185, %1172 ]
%1193 = phi i32* [ %1164, %1162 ], [ %1184, %1172 ]
%1194 = phi i32* [ %1165, %1162 ], [ %1180, %1172 ]
%1195 = phi i32* [ %1166, %1162 ], [ %1178, %1172 ]
%1196 = icmp ult i32 %1169, 3
br i1 %1196, label %1232, label %1197
1197: ; preds = %1188, %1197
%1198 = phi i32 [ %1230, %1197 ], [ %1192, %1188 ]
%1199 = phi i32* [ %1229, %1197 ], [ %1193, %1188 ]
%1200 = phi i32* [ %1225, %1197 ], [ %1194, %1188 ]
%1201 = phi i32* [ %1223, %1197 ], [ %1195, %1188 ]
%1202 = getelementptr inbounds i32, i32* %1201, i64 1
%1203 = load i32, i32* %1201
%1204 = getelementptr inbounds i32, i32* %1200, i64 1
%1205 = load i32, i32* %1200
%1206 = shl i32 %1205, 4
%1207 = or i32 %1206, %1203
%1208 = getelementptr inbounds i32, i32* %1199, i64 1
store i32 %1207, i32* %1199
%1209 = getelementptr inbounds i32, i32* %1201, i64 2
%1210 = load i32, i32* %1202
%1211 = getelementptr inbounds i32, i32* %1200, i64 2
%1212 = load i32, i32* %1204
%1213 = shl i32 %1212, 4
%1214 = or i32 %1213, %1210
%1215 = getelementptr inbounds i32, i32* %1199, i64 2
store i32 %1214, i32* %1208
%1216 = getelementptr inbounds i32, i32* %1201, i64 3
%1217 = load i32, i32* %1209
%1218 = getelementptr inbounds i32, i32* %1200, i64 3
%1219 = load i32, i32* %1211
%1220 = shl i32 %1219, 4
%1221 = or i32 %1220, %1217
%1222 = getelementptr inbounds i32, i32* %1199, i64 3
store i32 %1221, i32* %1215
%1223 = getelementptr inbounds i32, i32* %1201, i64 4
%1224 = load i32, i32* %1216
%1225 = getelementptr inbounds i32, i32* %1200, i64 4
%1226 = load i32, i32* %1218
%1227 = shl i32 %1226, 4
%1228 = or i32 %1227, %1224
%1229 = getelementptr inbounds i32, i32* %1199, i64 4
store i32 %1228, i32* %1222
%1230 = add nuw nsw i32 %1198, 4
%1231 = icmp eq i32 %1230, %1
br i1 %1231, label %1232, label %1197
1232: ; preds = %1188, %1197, %1161
%1233 = phi i32* [ %1090, %1161 ], [ %1189, %1188 ], [ %1223, %1197 ]
%1234 = phi i32* [ %1089, %1161 ], [ %1190, %1188 ], [ %1225, %1197 ]
%1235 = phi i32* [ %1088, %1161 ], [ %1191, %1188 ], [ %1229, %1197 ]
br i1 %6, label %1236, label %1714
1236: ; preds = %1232
br i1 %117, label %1323, label %1237
1237: ; preds = %1236
%1238 = getelementptr i32, i32* %1235, i64 %19
%1239 = getelementptr i32, i32* %1233, i64 %19
%1240 = getelementptr i32, i32* %1234, i64 %19
%1241 = icmp ult i32* %1235, %1239
%1242 = icmp ult i32* %1233, %1238
%1243 = and i1 %1241, %1242
%1244 = icmp ult i32* %1235, %1240
%1245 = icmp ult i32* %1234, %1238
%1246 = and i1 %1244, %1245
%1247 = or i1 %1243, %1246
br i1 %1247, label %1323, label %1248
1248: ; preds = %1237
%1249 = getelementptr i32, i32* %1235, i64 %118
%1250 = getelementptr i32, i32* %1234, i64 %118
%1251 = getelementptr i32, i32* %1233, i64 %118
br i1 %121, label %1299, label %1252
1252: ; preds = %1248, %1252
%1253 = phi i64 [ %1296, %1252 ], [ 0, %1248 ]
%1254 = phi i64 [ %1297, %1252 ], [ 0, %1248 ]
%1255 = getelementptr i32, i32* %1235, i64 %1253
%1256 = getelementptr i32, i32* %1234, i64 %1253
%1257 = getelementptr i32, i32* %1233, i64 %1253
%1258 = bitcast i32* %1257 to <4 x i32>*
%1259 = load <4 x i32>, <4 x i32>* %1258
%1260 = getelementptr i32, i32* %1257, i64 4
%1261 = bitcast i32* %1260 to <4 x i32>*
%1262 = load <4 x i32>, <4 x i32>* %1261
%1263 = bitcast i32* %1256 to <4 x i32>*
%1264 = load <4 x i32>, <4 x i32>* %1263
%1265 = getelementptr i32, i32* %1256, i64 4
%1266 = bitcast i32* %1265 to <4 x i32>*
%1267 = load <4 x i32>, <4 x i32>* %1266
%1268 = shl <4 x i32> %1264, <i32 4, i32 4, i32 4, i32 4>
%1269 = shl <4 x i32> %1267, <i32 4, i32 4, i32 4, i32 4>
%1270 = or <4 x i32> %1268, %1259
%1271 = or <4 x i32> %1269, %1262
%1272 = bitcast i32* %1255 to <4 x i32>*
store <4 x i32> %1270, <4 x i32>* %1272
%1273 = getelementptr i32, i32* %1255, i64 4
%1274 = bitcast i32* %1273 to <4 x i32>*
store <4 x i32> %1271, <4 x i32>* %1274
%1275 = or i64 %1253, 8
%1276 = getelementptr i32, i32* %1235, i64 %1275
%1277 = getelementptr i32, i32* %1234, i64 %1275
%1278 = getelementptr i32, i32* %1233, i64 %1275
%1279 = bitcast i32* %1278 to <4 x i32>*
%1280 = load <4 x i32>, <4 x i32>* %1279
%1281 = getelementptr i32, i32* %1278, i64 4
%1282 = bitcast i32* %1281 to <4 x i32>*
%1283 = load <4 x i32>, <4 x i32>* %1282
%1284 = bitcast i32* %1277 to <4 x i32>*
%1285 = load <4 x i32>, <4 x i32>* %1284
%1286 = getelementptr i32, i32* %1277, i64 4
%1287 = bitcast i32* %1286 to <4 x i32>*
%1288 = load <4 x i32>, <4 x i32>* %1287
%1289 = shl <4 x i32> %1285, <i32 4, i32 4, i32 4, i32 4>
%1290 = shl <4 x i32> %1288, <i32 4, i32 4, i32 4, i32 4>
%1291 = or <4 x i32> %1289, %1280
%1292 = or <4 x i32> %1290, %1283
%1293 = bitcast i32* %1276 to <4 x i32>*
store <4 x i32> %1291, <4 x i32>* %1293
%1294 = getelementptr i32, i32* %1276, i64 4
%1295 = bitcast i32* %1294 to <4 x i32>*
store <4 x i32> %1292, <4 x i32>* %1295
%1296 = add nuw i64 %1253, 16
%1297 = add i64 %1254, 2
%1298 = icmp eq i64 %1297, %122
br i1 %1298, label %1299, label %1252
1299: ; preds = %1252, %1248
%1300 = phi i64 [ 0, %1248 ], [ %1296, %1252 ]
br i1 %123, label %1322, label %1301
1301: ; preds = %1299
%1302 = getelementptr i32, i32* %1235, i64 %1300
%1303 = getelementptr i32, i32* %1234, i64 %1300
%1304 = getelementptr i32, i32* %1233, i64 %1300
%1305 = bitcast i32* %1304 to <4 x i32>*
%1306 = load <4 x i32>, <4 x i32>* %1305
%1307 = getelementptr i32, i32* %1304, i64 4
%1308 = bitcast i32* %1307 to <4 x i32>*
%1309 = load <4 x i32>, <4 x i32>* %1308
%1310 = bitcast i32* %1303 to <4 x i32>*
%1311 = load <4 x i32>, <4 x i32>* %1310
%1312 = getelementptr i32, i32* %1303, i64 4
%1313 = bitcast i32* %1312 to <4 x i32>*
%1314 = load <4 x i32>, <4 x i32>* %1313
%1315 = shl <4 x i32> %1311, <i32 4, i32 4, i32 4, i32 4>
%1316 = shl <4 x i32> %1314, <i32 4, i32 4, i32 4, i32 4>
%1317 = or <4 x i32> %1315, %1306
%1318 = or <4 x i32> %1316, %1309
%1319 = bitcast i32* %1302 to <4 x i32>*
store <4 x i32> %1317, <4 x i32>* %1319
%1320 = getelementptr i32, i32* %1302, i64 4
%1321 = bitcast i32* %1320 to <4 x i32>*
store <4 x i32> %1318, <4 x i32>* %1321
br label %1322
1322: ; preds = %1299, %1301
br i1 %124, label %1393, label %1323
1323: ; preds = %1237, %1236, %1322
%1324 = phi i32 [ 0, %1237 ], [ 0, %1236 ], [ %119, %1322 ]
%1325 = phi i32* [ %1235, %1237 ], [ %1235, %1236 ], [ %1249, %1322 ]
%1326 = phi i32* [ %1234, %1237 ], [ %1234, %1236 ], [ %1250, %1322 ]
%1327 = phi i32* [ %1233, %1237 ], [ %1233, %1236 ], [ %1251, %1322 ]
%1328 = sub i32 %1, %1324
%1329 = xor i32 %1324, -1
%1330 = add i32 %1329, %1
%1331 = and i32 %1328, 3
%1332 = icmp eq i32 %1331, 0
br i1 %1332, label %1349, label %1333
1333: ; preds = %1323, %1333
%1334 = phi i32 [ %1346, %1333 ], [ %1324, %1323 ]
%1335 = phi i32* [ %1345, %1333 ], [ %1325, %1323 ]
%1336 = phi i32* [ %1341, %1333 ], [ %1326, %1323 ]
%1337 = phi i32* [ %1339, %1333 ], [ %1327, %1323 ]
%1338 = phi i32 [ %1347, %1333 ], [ 0, %1323 ]
%1339 = getelementptr inbounds i32, i32* %1337, i64 1
%1340 = load i32, i32* %1337
%1341 = getelementptr inbounds i32, i32* %1336, i64 1
%1342 = load i32, i32* %1336
%1343 = shl i32 %1342, 4
%1344 = or i32 %1343, %1340
%1345 = getelementptr inbounds i32, i32* %1335, i64 1
store i32 %1344, i32* %1335
%1346 = add nuw nsw i32 %1334, 1
%1347 = add i32 %1338, 1
%1348 = icmp eq i32 %1347, %1331
br i1 %1348, label %1349, label %1333
1349: ; preds = %1333, %1323
%1350 = phi i32* [ undef, %1323 ], [ %1339, %1333 ]
%1351 = phi i32* [ undef, %1323 ], [ %1341, %1333 ]
%1352 = phi i32* [ undef, %1323 ], [ %1345, %1333 ]
%1353 = phi i32 [ %1324, %1323 ], [ %1346, %1333 ]
%1354 = phi i32* [ %1325, %1323 ], [ %1345, %1333 ]
%1355 = phi i32* [ %1326, %1323 ], [ %1341, %1333 ]
%1356 = phi i32* [ %1327, %1323 ], [ %1339, %1333 ]
%1357 = icmp ult i32 %1330, 3
br i1 %1357, label %1393, label %1358
1358: ; preds = %1349, %1358
%1359 = phi i32 [ %1391, %1358 ], [ %1353, %1349 ]
%1360 = phi i32* [ %1390, %1358 ], [ %1354, %1349 ]
%1361 = phi i32* [ %1386, %1358 ], [ %1355, %1349 ]
%1362 = phi i32* [ %1384, %1358 ], [ %1356, %1349 ]
%1363 = getelementptr inbounds i32, i32* %1362, i64 1
%1364 = load i32, i32* %1362
%1365 = getelementptr inbounds i32, i32* %1361, i64 1
%1366 = load i32, i32* %1361
%1367 = shl i32 %1366, 4
%1368 = or i32 %1367, %1364
%1369 = getelementptr inbounds i32, i32* %1360, i64 1
store i32 %1368, i32* %1360
%1370 = getelementptr inbounds i32, i32* %1362, i64 2
%1371 = load i32, i32* %1363
%1372 = getelementptr inbounds i32, i32* %1361, i64 2
%1373 = load i32, i32* %1365
%1374 = shl i32 %1373, 4
%1375 = or i32 %1374, %1371
%1376 = getelementptr inbounds i32, i32* %1360, i64 2
store i32 %1375, i32* %1369
%1377 = getelementptr inbounds i32, i32* %1362, i64 3
%1378 = load i32, i32* %1370
%1379 = getelementptr inbounds i32, i32* %1361, i64 3
%1380 = load i32, i32* %1372
%1381 = shl i32 %1380, 4
%1382 = or i32 %1381, %1378
%1383 = getelementptr inbounds i32, i32* %1360, i64 3
store i32 %1382, i32* %1376
%1384 = getelementptr inbounds i32, i32* %1362, i64 4
%1385 = load i32, i32* %1377
%1386 = getelementptr inbounds i32, i32* %1361, i64 4
%1387 = load i32, i32* %1379
%1388 = shl i32 %1387, 4
%1389 = or i32 %1388, %1385
%1390 = getelementptr inbounds i32, i32* %1360, i64 4
store i32 %1389, i32* %1383
%1391 = add nuw nsw i32 %1359, 4
%1392 = icmp eq i32 %1391, %1
br i1 %1392, label %1393, label %1358
1393: ; preds = %1349, %1358, %1322
%1394 = phi i32* [ %1251, %1322 ], [ %1350, %1349 ], [ %1384, %1358 ]
%1395 = phi i32* [ %1250, %1322 ], [ %1351, %1349 ], [ %1386, %1358 ]
%1396 = phi i32* [ %1249, %1322 ], [ %1352, %1349 ], [ %1390, %1358 ]
br i1 %6, label %1397, label %1714
1397: ; preds = %1393
br i1 %125, label %1484, label %1398
1398: ; preds = %1397
%1399 = getelementptr i32, i32* %1396, i64 %14
%1400 = getelementptr i32, i32* %1394, i64 %14
%1401 = getelementptr i32, i32* %1395, i64 %14
%1402 = icmp ult i32* %1396, %1400
%1403 = icmp ult i32* %1394, %1399
%1404 = and i1 %1402, %1403
%1405 = icmp ult i32* %1396, %1401
%1406 = icmp ult i32* %1395, %1399
%1407 = and i1 %1405, %1406
%1408 = or i1 %1404, %1407
br i1 %1408, label %1484, label %1409
1409: ; preds = %1398
%1410 = getelementptr i32, i32* %1396, i64 %126
%1411 = getelementptr i32, i32* %1395, i64 %126
%1412 = getelementptr i32, i32* %1394, i64 %126
br i1 %129, label %1460, label %1413
1413: ; preds = %1409, %1413
%1414 = phi i64 [ %1457, %1413 ], [ 0, %1409 ]
%1415 = phi i64 [ %1458, %1413 ], [ 0, %1409 ]
%1416 = getelementptr i32, i32* %1396, i64 %1414
%1417 = getelementptr i32, i32* %1395, i64 %1414
%1418 = getelementptr i32, i32* %1394, i64 %1414
%1419 = bitcast i32* %1418 to <4 x i32>*
%1420 = load <4 x i32>, <4 x i32>* %1419
%1421 = getelementptr i32, i32* %1418, i64 4
%1422 = bitcast i32* %1421 to <4 x i32>*
%1423 = load <4 x i32>, <4 x i32>* %1422
%1424 = bitcast i32* %1417 to <4 x i32>*
%1425 = load <4 x i32>, <4 x i32>* %1424
%1426 = getelementptr i32, i32* %1417, i64 4
%1427 = bitcast i32* %1426 to <4 x i32>*
%1428 = load <4 x i32>, <4 x i32>* %1427
%1429 = shl <4 x i32> %1425, <i32 4, i32 4, i32 4, i32 4>
%1430 = shl <4 x i32> %1428, <i32 4, i32 4, i32 4, i32 4>
%1431 = or <4 x i32> %1429, %1420
%1432 = or <4 x i32> %1430, %1423
%1433 = bitcast i32* %1416 to <4 x i32>*
store <4 x i32> %1431, <4 x i32>* %1433
%1434 = getelementptr i32, i32* %1416, i64 4
%1435 = bitcast i32* %1434 to <4 x i32>*
store <4 x i32> %1432, <4 x i32>* %1435
%1436 = or i64 %1414, 8
%1437 = getelementptr i32, i32* %1396, i64 %1436
%1438 = getelementptr i32, i32* %1395, i64 %1436
%1439 = getelementptr i32, i32* %1394, i64 %1436
%1440 = bitcast i32* %1439 to <4 x i32>*
%1441 = load <4 x i32>, <4 x i32>* %1440
%1442 = getelementptr i32, i32* %1439, i64 4
%1443 = bitcast i32* %1442 to <4 x i32>*
%1444 = load <4 x i32>, <4 x i32>* %1443
%1445 = bitcast i32* %1438 to <4 x i32>*
%1446 = load <4 x i32>, <4 x i32>* %1445
%1447 = getelementptr i32, i32* %1438, i64 4
%1448 = bitcast i32* %1447 to <4 x i32>*
%1449 = load <4 x i32>, <4 x i32>* %1448
%1450 = shl <4 x i32> %1446, <i32 4, i32 4, i32 4, i32 4>
%1451 = shl <4 x i32> %1449, <i32 4, i32 4, i32 4, i32 4>
%1452 = or <4 x i32> %1450, %1441
%1453 = or <4 x i32> %1451, %1444
%1454 = bitcast i32* %1437 to <4 x i32>*
store <4 x i32> %1452, <4 x i32>* %1454
%1455 = getelementptr i32, i32* %1437, i64 4
%1456 = bitcast i32* %1455 to <4 x i32>*
store <4 x i32> %1453, <4 x i32>* %1456
%1457 = add nuw i64 %1414, 16
%1458 = add i64 %1415, 2
%1459 = icmp eq i64 %1458, %130
br i1 %1459, label %1460, label %1413
1460: ; preds = %1413, %1409
%1461 = phi i64 [ 0, %1409 ], [ %1457, %1413 ]
br i1 %131, label %1483, label %1462
1462: ; preds = %1460
%1463 = getelementptr i32, i32* %1396, i64 %1461
%1464 = getelementptr i32, i32* %1395, i64 %1461
%1465 = getelementptr i32, i32* %1394, i64 %1461
%1466 = bitcast i32* %1465 to <4 x i32>*
%1467 = load <4 x i32>, <4 x i32>* %1466
%1468 = getelementptr i32, i32* %1465, i64 4
%1469 = bitcast i32* %1468 to <4 x i32>*
%1470 = load <4 x i32>, <4 x i32>* %1469
%1471 = bitcast i32* %1464 to <4 x i32>*
%1472 = load <4 x i32>, <4 x i32>* %1471
%1473 = getelementptr i32, i32* %1464, i64 4
%1474 = bitcast i32* %1473 to <4 x i32>*
%1475 = load <4 x i32>, <4 x i32>* %1474
%1476 = shl <4 x i32> %1472, <i32 4, i32 4, i32 4, i32 4>
%1477 = shl <4 x i32> %1475, <i32 4, i32 4, i32 4, i32 4>
%1478 = or <4 x i32> %1476, %1467
%1479 = or <4 x i32> %1477, %1470
%1480 = bitcast i32* %1463 to <4 x i32>*
store <4 x i32> %1478, <4 x i32>* %1480
%1481 = getelementptr i32, i32* %1463, i64 4
%1482 = bitcast i32* %1481 to <4 x i32>*
store <4 x i32> %1479, <4 x i32>* %1482
br label %1483
1483: ; preds = %1460, %1462
br i1 %132, label %1554, label %1484
1484: ; preds = %1398, %1397, %1483
%1485 = phi i32 [ 0, %1398 ], [ 0, %1397 ], [ %127, %1483 ]
%1486 = phi i32* [ %1396, %1398 ], [ %1396, %1397 ], [ %1410, %1483 ]
%1487 = phi i32* [ %1395, %1398 ], [ %1395, %1397 ], [ %1411, %1483 ]
%1488 = phi i32* [ %1394, %1398 ], [ %1394, %1397 ], [ %1412, %1483 ]
%1489 = sub i32 %1, %1485
%1490 = xor i32 %1485, -1
%1491 = add i32 %1490, %1
%1492 = and i32 %1489, 3
%1493 = icmp eq i32 %1492, 0
br i1 %1493, label %1510, label %1494
1494: ; preds = %1484, %1494
%1495 = phi i32 [ %1507, %1494 ], [ %1485, %1484 ]
%1496 = phi i32* [ %1506, %1494 ], [ %1486, %1484 ]
%1497 = phi i32* [ %1502, %1494 ], [ %1487, %1484 ]
%1498 = phi i32* [ %1500, %1494 ], [ %1488, %1484 ]
%1499 = phi i32 [ %1508, %1494 ], [ 0, %1484 ]
%1500 = getelementptr inbounds i32, i32* %1498, i64 1
%1501 = load i32, i32* %1498
%1502 = getelementptr inbounds i32, i32* %1497, i64 1
%1503 = load i32, i32* %1497
%1504 = shl i32 %1503, 4
%1505 = or i32 %1504, %1501
%1506 = getelementptr inbounds i32, i32* %1496, i64 1
store i32 %1505, i32* %1496
%1507 = add nuw nsw i32 %1495, 1
%1508 = add i32 %1499, 1
%1509 = icmp eq i32 %1508, %1492
br i1 %1509, label %1510, label %1494
1510: ; preds = %1494, %1484
%1511 = phi i32* [ undef, %1484 ], [ %1500, %1494 ]
%1512 = phi i32* [ undef, %1484 ], [ %1502, %1494 ]
%1513 = phi i32* [ undef, %1484 ], [ %1506, %1494 ]
%1514 = phi i32 [ %1485, %1484 ], [ %1507, %1494 ]
%1515 = phi i32* [ %1486, %1484 ], [ %1506, %1494 ]
%1516 = phi i32* [ %1487, %1484 ], [ %1502, %1494 ]
%1517 = phi i32* [ %1488, %1484 ], [ %1500, %1494 ]
%1518 = icmp ult i32 %1491, 3
br i1 %1518, label %1554, label %1519
1519: ; preds = %1510, %1519
%1520 = phi i32 [ %1552, %1519 ], [ %1514, %1510 ]
%1521 = phi i32* [ %1551, %1519 ], [ %1515, %1510 ]
%1522 = phi i32* [ %1547, %1519 ], [ %1516, %1510 ]
%1523 = phi i32* [ %1545, %1519 ], [ %1517, %1510 ]
%1524 = getelementptr inbounds i32, i32* %1523, i64 1
%1525 = load i32, i32* %1523
%1526 = getelementptr inbounds i32, i32* %1522, i64 1
%1527 = load i32, i32* %1522
%1528 = shl i32 %1527, 4
%1529 = or i32 %1528, %1525
%1530 = getelementptr inbounds i32, i32* %1521, i64 1
store i32 %1529, i32* %1521
%1531 = getelementptr inbounds i32, i32* %1523, i64 2
%1532 = load i32, i32* %1524
%1533 = getelementptr inbounds i32, i32* %1522, i64 2
%1534 = load i32, i32* %1526
%1535 = shl i32 %1534, 4
%1536 = or i32 %1535, %1532
%1537 = getelementptr inbounds i32, i32* %1521, i64 2
store i32 %1536, i32* %1530
%1538 = getelementptr inbounds i32, i32* %1523, i64 3
%1539 = load i32, i32* %1531
%1540 = getelementptr inbounds i32, i32* %1522, i64 3
%1541 = load i32, i32* %1533
%1542 = shl i32 %1541, 4
%1543 = or i32 %1542, %1539
%1544 = getelementptr inbounds i32, i32* %1521, i64 3
store i32 %1543, i32* %1537
%1545 = getelementptr inbounds i32, i32* %1523, i64 4
%1546 = load i32, i32* %1538
%1547 = getelementptr inbounds i32, i32* %1522, i64 4
%1548 = load i32, i32* %1540
%1549 = shl i32 %1548, 4
%1550 = or i32 %1549, %1546
%1551 = getelementptr inbounds i32, i32* %1521, i64 4
store i32 %1550, i32* %1544
%1552 = add nuw nsw i32 %1520, 4
%1553 = icmp eq i32 %1552, %1
br i1 %1553, label %1554, label %1519
1554: ; preds = %1510, %1519, %1483
%1555 = phi i32* [ %1412, %1483 ], [ %1511, %1510 ], [ %1545, %1519 ]
%1556 = phi i32* [ %1411, %1483 ], [ %1512, %1510 ], [ %1547, %1519 ]
%1557 = phi i32* [ %1410, %1483 ], [ %1513, %1510 ], [ %1551, %1519 ]
br i1 %6, label %1558, label %1714
1558: ; preds = %1554
br i1 %133, label %1645, label %1559
1559: ; preds = %1558
%1560 = getelementptr i32, i32* %1557, i64 %10
%1561 = getelementptr i32, i32* %1555, i64 %10
%1562 = getelementptr i32, i32* %1556, i64 %10
%1563 = icmp ult i32* %1557, %1561
%1564 = icmp ult i32* %1555, %1560
%1565 = and i1 %1563, %1564
%1566 = icmp ult i32* %1557, %1562
%1567 = icmp ult i32* %1556, %1560
%1568 = and i1 %1566, %1567
%1569 = or i1 %1565, %1568
br i1 %1569, label %1645, label %1570
1570: ; preds = %1559
%1571 = getelementptr i32, i32* %1557, i64 %134
%1572 = getelementptr i32, i32* %1556, i64 %134
%1573 = getelementptr i32, i32* %1555, i64 %134
br i1 %137, label %1621, label %1574
1574: ; preds = %1570, %1574
%1575 = phi i64 [ %1618, %1574 ], [ 0, %1570 ]
%1576 = phi i64 [ %1619, %1574 ], [ 0, %1570 ]
%1577 = getelementptr i32, i32* %1557, i64 %1575
%1578 = getelementptr i32, i32* %1556, i64 %1575
%1579 = getelementptr i32, i32* %1555, i64 %1575
%1580 = bitcast i32* %1579 to <4 x i32>*
%1581 = load <4 x i32>, <4 x i32>* %1580
%1582 = getelementptr i32, i32* %1579, i64 4
%1583 = bitcast i32* %1582 to <4 x i32>*
%1584 = load <4 x i32>, <4 x i32>* %1583
%1585 = bitcast i32* %1578 to <4 x i32>*
%1586 = load <4 x i32>, <4 x i32>* %1585
%1587 = getelementptr i32, i32* %1578, i64 4
%1588 = bitcast i32* %1587 to <4 x i32>*
%1589 = load <4 x i32>, <4 x i32>* %1588
%1590 = shl <4 x i32> %1586, <i32 4, i32 4, i32 4, i32 4>
%1591 = shl <4 x i32> %1589, <i32 4, i32 4, i32 4, i32 4>
%1592 = or <4 x i32> %1590, %1581
%1593 = or <4 x i32> %1591, %1584
%1594 = bitcast i32* %1577 to <4 x i32>*
store <4 x i32> %1592, <4 x i32>* %1594
%1595 = getelementptr i32, i32* %1577, i64 4
%1596 = bitcast i32* %1595 to <4 x i32>*
store <4 x i32> %1593, <4 x i32>* %1596
%1597 = or i64 %1575, 8
%1598 = getelementptr i32, i32* %1557, i64 %1597
%1599 = getelementptr i32, i32* %1556, i64 %1597
%1600 = getelementptr i32, i32* %1555, i64 %1597
%1601 = bitcast i32* %1600 to <4 x i32>*
%1602 = load <4 x i32>, <4 x i32>* %1601
%1603 = getelementptr i32, i32* %1600, i64 4
%1604 = bitcast i32* %1603 to <4 x i32>*
%1605 = load <4 x i32>, <4 x i32>* %1604
%1606 = bitcast i32* %1599 to <4 x i32>*
%1607 = load <4 x i32>, <4 x i32>* %1606
%1608 = getelementptr i32, i32* %1599, i64 4
%1609 = bitcast i32* %1608 to <4 x i32>*
%1610 = load <4 x i32>, <4 x i32>* %1609
%1611 = shl <4 x i32> %1607, <i32 4, i32 4, i32 4, i32 4>
%1612 = shl <4 x i32> %1610, <i32 4, i32 4, i32 4, i32 4>
%1613 = or <4 x i32> %1611, %1602
%1614 = or <4 x i32> %1612, %1605
%1615 = bitcast i32* %1598 to <4 x i32>*
store <4 x i32> %1613, <4 x i32>* %1615
%1616 = getelementptr i32, i32* %1598, i64 4
%1617 = bitcast i32* %1616 to <4 x i32>*
store <4 x i32> %1614, <4 x i32>* %1617
%1618 = add nuw i64 %1575, 16
%1619 = add i64 %1576, 2
%1620 = icmp eq i64 %1619, %138
br i1 %1620, label %1621, label %1574
1621: ; preds = %1574, %1570
%1622 = phi i64 [ 0, %1570 ], [ %1618, %1574 ]
br i1 %139, label %1644, label %1623
1623: ; preds = %1621
%1624 = getelementptr i32, i32* %1557, i64 %1622
%1625 = getelementptr i32, i32* %1556, i64 %1622
%1626 = getelementptr i32, i32* %1555, i64 %1622
%1627 = bitcast i32* %1626 to <4 x i32>*
%1628 = load <4 x i32>, <4 x i32>* %1627
%1629 = getelementptr i32, i32* %1626, i64 4
%1630 = bitcast i32* %1629 to <4 x i32>*
%1631 = load <4 x i32>, <4 x i32>* %1630
%1632 = bitcast i32* %1625 to <4 x i32>*
%1633 = load <4 x i32>, <4 x i32>* %1632
%1634 = getelementptr i32, i32* %1625, i64 4
%1635 = bitcast i32* %1634 to <4 x i32>*
%1636 = load <4 x i32>, <4 x i32>* %1635
%1637 = shl <4 x i32> %1633, <i32 4, i32 4, i32 4, i32 4>
%1638 = shl <4 x i32> %1636, <i32 4, i32 4, i32 4, i32 4>
%1639 = or <4 x i32> %1637, %1628
%1640 = or <4 x i32> %1638, %1631
%1641 = bitcast i32* %1624 to <4 x i32>*
store <4 x i32> %1639, <4 x i32>* %1641
%1642 = getelementptr i32, i32* %1624, i64 4
%1643 = bitcast i32* %1642 to <4 x i32>*
store <4 x i32> %1640, <4 x i32>* %1643
br label %1644
1644: ; preds = %1621, %1623
br i1 %140, label %1714, label %1645
1645: ; preds = %1559, %1558, %1644
%1646 = phi i32 [ 0, %1559 ], [ 0, %1558 ], [ %135, %1644 ]
%1647 = phi i32* [ %1557, %1559 ], [ %1557, %1558 ], [ %1571, %1644 ]
%1648 = phi i32* [ %1556, %1559 ], [ %1556, %1558 ], [ %1572, %1644 ]
%1649 = phi i32* [ %1555, %1559 ], [ %1555, %1558 ], [ %1573, %1644 ]
%1650 = sub i32 %1, %1646
%1651 = xor i32 %1646, -1
%1652 = add i32 %1651, %1
%1653 = and i32 %1650, 3
%1654 = icmp eq i32 %1653, 0
br i1 %1654, label %1671, label %1655
1655: ; preds = %1645, %1655
%1656 = phi i32 [ %1668, %1655 ], [ %1646, %1645 ]
%1657 = phi i32* [ %1667, %1655 ], [ %1647, %1645 ]
%1658 = phi i32* [ %1663, %1655 ], [ %1648, %1645 ]
%1659 = phi i32* [ %1661, %1655 ], [ %1649, %1645 ]
%1660 = phi i32 [ %1669, %1655 ], [ 0, %1645 ]
%1661 = getelementptr inbounds i32, i32* %1659, i64 1
%1662 = load i32, i32* %1659
%1663 = getelementptr inbounds i32, i32* %1658, i64 1
%1664 = load i32, i32* %1658
%1665 = shl i32 %1664, 4
%1666 = or i32 %1665, %1662
%1667 = getelementptr inbounds i32, i32* %1657, i64 1
store i32 %1666, i32* %1657
%1668 = add nuw nsw i32 %1656, 1
%1669 = add i32 %1660, 1
%1670 = icmp eq i32 %1669, %1653
br i1 %1670, label %1671, label %1655
1671: ; preds = %1655, %1645
%1672 = phi i32* [ undef, %1645 ], [ %1661, %1655 ]
%1673 = phi i32* [ undef, %1645 ], [ %1663, %1655 ]
%1674 = phi i32 [ %1646, %1645 ], [ %1668, %1655 ]
%1675 = phi i32* [ %1647, %1645 ], [ %1667, %1655 ]
%1676 = phi i32* [ %1648, %1645 ], [ %1663, %1655 ]
%1677 = phi i32* [ %1649, %1645 ], [ %1661, %1655 ]
%1678 = icmp ult i32 %1652, 3
br i1 %1678, label %1714, label %1679
1679: ; preds = %1671, %1679
%1680 = phi i32 [ %1712, %1679 ], [ %1674, %1671 ]
%1681 = phi i32* [ %1711, %1679 ], [ %1675, %1671 ]
%1682 = phi i32* [ %1707, %1679 ], [ %1676, %1671 ]
%1683 = phi i32* [ %1705, %1679 ], [ %1677, %1671 ]
%1684 = getelementptr inbounds i32, i32* %1683, i64 1
%1685 = load i32, i32* %1683
%1686 = getelementptr inbounds i32, i32* %1682, i64 1
%1687 = load i32, i32* %1682
%1688 = shl i32 %1687, 4
%1689 = or i32 %1688, %1685
%1690 = getelementptr inbounds i32, i32* %1681, i64 1
store i32 %1689, i32* %1681
%1691 = getelementptr inbounds i32, i32* %1683, i64 2
%1692 = load i32, i32* %1684
%1693 = getelementptr inbounds i32, i32* %1682, i64 2
%1694 = load i32, i32* %1686
%1695 = shl i32 %1694, 4
%1696 = or i32 %1695, %1692
%1697 = getelementptr inbounds i32, i32* %1681, i64 2
store i32 %1696, i32* %1690
%1698 = getelementptr inbounds i32, i32* %1683, i64 3
%1699 = load i32, i32* %1691
%1700 = getelementptr inbounds i32, i32* %1682, i64 3
%1701 = load i32, i32* %1693
%1702 = shl i32 %1701, 4
%1703 = or i32 %1702, %1699
%1704 = getelementptr inbounds i32, i32* %1681, i64 3
store i32 %1703, i32* %1697
%1705 = getelementptr inbounds i32, i32* %1683, i64 4
%1706 = load i32, i32* %1698
%1707 = getelementptr inbounds i32, i32* %1682, i64 4
%1708 = load i32, i32* %1700
%1709 = shl i32 %1708, 4
%1710 = or i32 %1709, %1706
%1711 = getelementptr inbounds i32, i32* %1681, i64 4
store i32 %1710, i32* %1704
%1712 = add nuw nsw i32 %1680, 4
%1713 = icmp eq i32 %1712, %1
br i1 %1713, label %1714, label %1679
1714: ; preds = %1671, %1679, %1644, %141, %266, %427, %588, %749, %910, %1071, %1232, %1393, %1554
%1715 = phi i32* [ %1555, %1554 ], [ %1394, %1393 ], [ %1233, %1232 ], [ %1072, %1071 ], [ %911, %910 ], [ %750, %749 ], [ %589, %588 ], [ %428, %427 ], [ %267, %266 ], [ %144, %141 ], [ %1573, %1644 ], [ %1672, %1671 ], [ %1705, %1679 ]
%1716 = phi i32* [ %1556, %1554 ], [ %1395, %1393 ], [ %1234, %1232 ], [ %1073, %1071 ], [ %912, %910 ], [ %751, %749 ], [ %590, %588 ], [ %429, %427 ], [ %268, %266 ], [ %143, %141 ], [ %1572, %1644 ], [ %1673, %1671 ], [ %1707, %1679 ]
%1717 = tail call i32 @fwrite(i32* %2, i32 %7, i32 1, i32* %0)
%1718 = add nuw nsw i32 %142, 1
%1719 = icmp eq i32 %1718, 96
br i1 %1719, label %265, label %141
1720: ; preds = %256, %1720
%1721 = phi i32 [ %1753, %1720 ], [ %260, %256 ]
%1722 = phi i32* [ %1752, %1720 ], [ %261, %256 ]
%1723 = phi i32* [ %1748, %1720 ], [ %262, %256 ]
%1724 = phi i32* [ %1746, %1720 ], [ %263, %256 ]
%1725 = getelementptr inbounds i32, i32* %1724, i64 1
%1726 = load i32, i32* %1724
%1727 = getelementptr inbounds i32, i32* %1723, i64 1
%1728 = load i32, i32* %1723
%1729 = shl i32 %1728, 4
%1730 = or i32 %1729, %1726
%1731 = getelementptr inbounds i32, i32* %1722, i64 1
store i32 %1730, i32* %1722
%1732 = getelementptr inbounds i32, i32* %1724, i64 2
%1733 = load i32, i32* %1725
%1734 = getelementptr inbounds i32, i32* %1723, i64 2
%1735 = load i32, i32* %1727
%1736 = shl i32 %1735, 4
%1737 = or i32 %1736, %1733
%1738 = getelementptr inbounds i32, i32* %1722, i64 2
store i32 %1737, i32* %1731
%1739 = getelementptr inbounds i32, i32* %1724, i64 3
%1740 = load i32, i32* %1732
%1741 = getelementptr inbounds i32, i32* %1723, i64 3
%1742 = load i32, i32* %1734
%1743 = shl i32 %1742, 4
%1744 = or i32 %1743, %1740
%1745 = getelementptr inbounds i32, i32* %1722, i64 3
store i32 %1744, i32* %1738
%1746 = getelementptr inbounds i32, i32* %1724, i64 4
%1747 = load i32, i32* %1739
%1748 = getelementptr inbounds i32, i32* %1723, i64 4
%1749 = load i32, i32* %1741
%1750 = shl i32 %1749, 4
%1751 = or i32 %1750, %1747
%1752 = getelementptr inbounds i32, i32* %1722, i64 4
store i32 %1751, i32* %1745
%1753 = add nuw nsw i32 %1721, 4
%1754 = icmp eq i32 %1753, %1
br i1 %1754, label %266, label %1720
}