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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ chk_args(unsigned char *, int, int, int, int, int, int, int,
                            unsigned char *, int, int, int, int, int, int, int,
                            int *, int *);
int /*<<< orphan*/ memcpy(unsigned char *, unsigned char *, int);
int RGB555toRGB565(unsigned char *dest_ptr, int dest_width, int dest_height,
                   int dest_pitch, int dest_x, int dest_y, int dest_dx,
                   int dest_dy, unsigned char *src_ptr, int src_width,
                   int src_height, int src_pitch, int src_x, int src_y,
                   int src_dx, int src_dy) {
  int scale_x, scale_y;
  if (!chk_args(dest_ptr, dest_width, dest_height, dest_pitch, dest_x, dest_y,
                dest_dx, dest_dy, src_ptr, src_width, src_height, src_pitch,
                src_x, src_y, src_dx, src_dy, &scale_x, &scale_y))
    return -1;
  if (src_pitch < 0)
    src_ptr -= (src_height - 1) * src_pitch;
  if (dest_pitch < 0)
    dest_ptr -= (dest_height - 1) * dest_pitch;
  if (scale_x == 1 && scale_y == 1) {
    unsigned char *s, *d;
    register int i;
    s = src_ptr + src_x * 2 + src_y * src_pitch;
    d = dest_ptr + dest_x * 2 + dest_y * dest_pitch;
    for (i = 0; i < dest_dy; i++) {
      register int sx = src_x, ddx = dest_dx;
      while ((sx & 3) && ddx) {
        register unsigned short c = *(unsigned short *)s;
        *(unsigned short *)d = (c & 0x1F) | ((c & 0x7FE0) << 1);
        d += 2;
        s += 2;
        sx++;
        ddx--;
      }
      while (ddx >= 4) {
        register unsigned int a, b;
        a = *(unsigned int *)s;
        b = *(unsigned int *)(s + 4);
        *(unsigned int *)d = (a & 0x1F001F) | ((a & 0x7FE07FE0) << 1);
        *(unsigned int *)(d + 4) = (b & 0x1F001F) | ((b & 0x7FE07FE0) << 1);
        d += 2 * 4;
        s += 2 * 4;
        ddx -= 4;
      }
      while (ddx) {
        register unsigned short c = *(unsigned short *)s;
        *(unsigned short *)d = (c & 0x1F) | ((c & 0x7FE0) << 1);
        d += 2;
        s += 2;
        ddx--;
      }
      s += src_pitch - dest_dx * 2;
      d += dest_pitch - dest_dx * 2;
    }
    return 0;
  }
  if (scale_x == 2 && scale_y == 2) {
    unsigned char *s, *d;
    register int i;
    s = src_ptr + src_x * 2 + src_y * src_pitch;
    d = dest_ptr + dest_x * 2 + dest_y * dest_pitch;
    for (i = 0; i < src_dy; i++) {
      register int sx = src_x, sdx = src_dx;
      while ((sx & 3) && sdx) {
        register unsigned short a, b;
        a = *(unsigned short *)s;
        b = (a & 0x1F) | ((a & 0x7FE0) << 1);
        *(unsigned short *)d = b;
        *(unsigned short *)(d + 2) = b;
        d += 2 * 2;
        s += 2;
        sx++;
        sdx--;
      }
      while (sdx >= 4) {
        register unsigned int a, b;
        a = *(unsigned int *)s;
        b = (a & 0x1F001F) | ((a & 0x7FE07FE0) << 1);
        *(unsigned int *)d = (b & 0xFFFF) | (b << 16);
        *(unsigned int *)(d + 2 * 2) = (b & 0xFFFF0000) | (b >> 16);
        a = *(unsigned int *)(s + 2 * 2);
        b = (a & 0x1F001F) | ((a & 0x7FE07FE0) << 1);
        *(unsigned int *)(d + 2 * 2 * 2) = (b & 0xFFFF) | (b << 16);
        *(unsigned int *)(d + 3 * 2 * 2) = (b & 0xFFFF0000) | (b >> 16);
        d += 2 * 4 * 2;
        s += 4 * 2;
        sdx -= 4;
      }
      while (sdx) {
        register unsigned short a, b;
        a = *(unsigned short *)s;
        b = (a & 0x1F) | ((a & 0x7FE0) << 1);
        *(unsigned short *)d = b;
        *(unsigned short *)(d + 2) = b;
        d += 2 * 2;
        s += 2;
        sdx--;
      }
      s -= src_dx * 2;
      d -= src_dx * 2 * 2;
      memcpy(d + dest_pitch, d, src_dx * 2 * 2);
      s += src_pitch;
      d += dest_pitch * 2;
    }
    return 0;
  }
  return -1;
}


x86 assembly (clang, -O0):
<RGB555toRGB565>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    0x58(%rbp),%eax
mov    0x50(%rbp),%eax
mov    0x48(%rbp),%eax
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x38(%rbp)
mov    %esi,-0x3c(%rbp)
mov    %edx,-0x40(%rbp)
mov    %ecx,-0x44(%rbp)
mov    %r8d,-0x48(%rbp)
mov    %r9d,-0x4c(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x3c(%rbp),%esi
mov    -0x40(%rbp),%edx
mov    -0x44(%rbp),%ecx
mov    -0x48(%rbp),%r8d
mov    -0x4c(%rbp),%r9d
mov    0x10(%rbp),%eax
mov    %eax,-0xd8(%rbp)
mov    0x18(%rbp),%eax
mov    %eax,-0xd4(%rbp)
mov    0x20(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    0x28(%rbp),%eax
mov    %eax,-0xc4(%rbp)
mov    0x30(%rbp),%r13d
mov    0x38(%rbp),%r12d
mov    0x40(%rbp),%r15d
mov    0x48(%rbp),%r14d
mov    0x50(%rbp),%ebx
mov    0x58(%rbp),%r11d
lea    -0x50(%rbp),%r10
lea    -0x54(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0xd8(%rbp),%eax
mov    %eax,(%rsp)
mov    -0xd4(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0xd0(%rbp),%rax
mov    %rax,0x10(%rsp)
mov    -0xc4(%rbp),%eax
mov    %eax,0x18(%rsp)
mov    -0xc0(%rbp),%rax
mov    %r13d,0x20(%rsp)
mov    %r12d,0x28(%rsp)
mov    %r15d,0x30(%rsp)
mov    %r14d,0x38(%rsp)
mov    %ebx,0x40(%rsp)
mov    %r11d,0x48(%rsp)
mov    %r10,0x50(%rsp)
mov    %rax,0x58(%rsp)
call   1030 <chk_args@plt>
cmp    $0x0,%eax
jne    123a <RGB555toRGB565+0x11a>
movl   $0xffffffff,-0x2c(%rbp)
jmp    18b3 <RGB555toRGB565+0x793>
cmpl   $0x0,0x38(%rbp)
jge    1261 <RGB555toRGB565+0x141>
mov    0x30(%rbp),%ecx
sub    $0x1,%ecx
imul   0x38(%rbp),%ecx
mov    0x20(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,0x20(%rbp)
cmpl   $0x0,-0x44(%rbp)
jge    1288 <RGB555toRGB565+0x168>
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x44(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
cmpl   $0x1,-0x50(%rbp)
jne    14c4 <RGB555toRGB565+0x3a4>
cmpl   $0x1,-0x54(%rbp)
jne    14c4 <RGB555toRGB565+0x3a4>
mov    0x20(%rbp),%rax
mov    0x40(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    0x48(%rbp),%ecx
imul   0x38(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    -0x4c(%rbp),%ecx
imul   -0x44(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    14b8 <RGB555toRGB565+0x398>
mov    0x40(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%ecx
and    $0x3,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0xd9(%rbp)
je     1321 <RGB555toRGB565+0x201>
cmpl   $0x0,-0x74(%rbp)
setne  %al
mov    %al,-0xd9(%rbp)
mov    -0xd9(%rbp),%al
test   $0x1,%al
jne    1334 <RGB555toRGB565+0x214>
jmp    138e <RGB555toRGB565+0x26e>
mov    -0x60(%rbp),%rax
mov    (%rax),%ax
mov    %ax,-0x76(%rbp)
movzwl -0x76(%rbp),%eax
and    $0x1f,%eax
movzwl -0x76(%rbp),%ecx
and    $0x7fe0,%ecx
shl    $0x1,%ecx
or     %ecx,%eax
mov    %ax,%cx
mov    -0x68(%rbp),%rax
mov    %cx,(%rax)
mov    -0x68(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x68(%rbp)
mov    -0x60(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x60(%rbp)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
mov    -0x74(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x74(%rbp)
jmp    12fd <RGB555toRGB565+0x1dd>
jmp    1393 <RGB555toRGB565+0x273>
cmpl   $0x4,-0x74(%rbp)
jl     140f <RGB555toRGB565+0x2ef>
mov    -0x60(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x60(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x80(%rbp)
mov    -0x7c(%rbp),%ecx
and    $0x1f001f,%ecx
mov    -0x7c(%rbp),%eax
and    $0x7fe07fe0,%eax
shl    $0x1,%eax
or     %eax,%ecx
mov    -0x68(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x80(%rbp),%ecx
and    $0x1f001f,%ecx
mov    -0x80(%rbp),%eax
and    $0x7fe07fe0,%eax
shl    $0x1,%eax
or     %eax,%ecx
mov    -0x68(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x68(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x68(%rbp)
mov    -0x60(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x60(%rbp)
mov    -0x74(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x74(%rbp)
jmp    1393 <RGB555toRGB565+0x273>
jmp    1414 <RGB555toRGB565+0x2f4>
cmpl   $0x0,-0x74(%rbp)
je     1478 <RGB555toRGB565+0x358>
mov    -0x60(%rbp),%rax
mov    (%rax),%ax
mov    %ax,-0x82(%rbp)
movzwl -0x82(%rbp),%eax
and    $0x1f,%eax
movzwl -0x82(%rbp),%ecx
and    $0x7fe0,%ecx
shl    $0x1,%ecx
or     %ecx,%eax
mov    %ax,%cx
mov    -0x68(%rbp),%rax
mov    %cx,(%rax)
mov    -0x68(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x68(%rbp)
mov    -0x60(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x60(%rbp)
mov    -0x74(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x74(%rbp)
jmp    1414 <RGB555toRGB565+0x2f4>
mov    0x38(%rbp),%ecx
mov    0x10(%rbp),%eax
shl    $0x1,%eax
sub    %eax,%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x44(%rbp),%ecx
mov    0x10(%rbp),%eax
shl    $0x1,%eax
sub    %eax,%ecx
mov    -0x68(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    12e5 <RGB555toRGB565+0x1c5>
movl   $0x0,-0x2c(%rbp)
jmp    18b3 <RGB555toRGB565+0x793>
cmpl   $0x2,-0x50(%rbp)
jne    18ac <RGB555toRGB565+0x78c>
cmpl   $0x2,-0x54(%rbp)
jne    18ac <RGB555toRGB565+0x78c>
mov    0x20(%rbp),%rax
mov    0x40(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    0x48(%rbp),%ecx
imul   0x38(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    -0x4c(%rbp),%ecx
imul   -0x44(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    0x58(%rbp),%eax
jge    18a0 <RGB555toRGB565+0x780>
mov    0x40(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    0x50(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa0(%rbp),%ecx
and    $0x3,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0xda(%rbp)
je     1575 <RGB555toRGB565+0x455>
cmpl   $0x0,-0xa4(%rbp)
setne  %al
mov    %al,-0xda(%rbp)
mov    -0xda(%rbp),%al
test   $0x1,%al
jne    1588 <RGB555toRGB565+0x468>
jmp    1626 <RGB555toRGB565+0x506>
mov    -0x90(%rbp),%rax
mov    (%rax),%ax
mov    %ax,-0xa6(%rbp)
movzwl -0xa6(%rbp),%eax
and    $0x1f,%eax
movzwl -0xa6(%rbp),%ecx
and    $0x7fe0,%ecx
shl    $0x1,%ecx
or     %ecx,%eax
mov    %ax,-0xa8(%rbp)
mov    -0xa8(%rbp),%cx
mov    -0x98(%rbp),%rax
mov    %cx,(%rax)
mov    -0xa8(%rbp),%cx
mov    -0x98(%rbp),%rax
mov    %cx,0x2(%rax)
mov    -0x98(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x98(%rbp)
mov    -0x90(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x90(%rbp)
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xa4(%rbp)
jmp    154b <RGB555toRGB565+0x42b>
jmp    162b <RGB555toRGB565+0x50b>
cmpl   $0x4,-0xa4(%rbp)
jl     1756 <RGB555toRGB565+0x636>
mov    -0x90(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
and    $0x1f001f,%eax
mov    -0xac(%rbp),%ecx
and    $0x7fe07fe0,%ecx
shl    $0x1,%ecx
or     %ecx,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%ecx
and    $0xffff,%ecx
mov    -0xb0(%rbp),%eax
shl    $0x10,%eax
or     %eax,%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,(%rax)
mov    -0xb0(%rbp),%ecx
and    $0xffff0000,%ecx
mov    -0xb0(%rbp),%eax
shr    $0x10,%eax
or     %eax,%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x90(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
and    $0x1f001f,%eax
mov    -0xac(%rbp),%ecx
and    $0x7fe07fe0,%ecx
shl    $0x1,%ecx
or     %ecx,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%ecx
and    $0xffff,%ecx
mov    -0xb0(%rbp),%eax
shl    $0x10,%eax
or     %eax,%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0xb0(%rbp),%ecx
and    $0xffff0000,%ecx
mov    -0xb0(%rbp),%eax
shr    $0x10,%eax
or     %eax,%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x98(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x98(%rbp)
mov    -0x90(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x90(%rbp)
mov    -0xa4(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0xa4(%rbp)
jmp    162b <RGB555toRGB565+0x50b>
jmp    175b <RGB555toRGB565+0x63b>
cmpl   $0x0,-0xa4(%rbp)
je     17f7 <RGB555toRGB565+0x6d7>
mov    -0x90(%rbp),%rax
mov    (%rax),%ax
mov    %ax,-0xb2(%rbp)
movzwl -0xb2(%rbp),%eax
and    $0x1f,%eax
movzwl -0xb2(%rbp),%ecx
and    $0x7fe0,%ecx
shl    $0x1,%ecx
or     %ecx,%eax
mov    %ax,-0xb4(%rbp)
mov    -0xb4(%rbp),%cx
mov    -0x98(%rbp),%rax
mov    %cx,(%rax)
mov    -0xb4(%rbp),%cx
mov    -0x98(%rbp),%rax
mov    %cx,0x2(%rax)
mov    -0x98(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x98(%rbp)
mov    -0x90(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x90(%rbp)
mov    -0xa4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xa4(%rbp)
jmp    175b <RGB555toRGB565+0x63b>
mov    0x50(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x90(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    0x50(%rbp),%ecx
shl    $0x1,%ecx
shl    $0x1,%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rdi
movslq -0x44(%rbp),%rax
add    %rax,%rdi
mov    -0x98(%rbp),%rsi
mov    0x50(%rbp),%edx
shl    $0x1,%edx
shl    $0x1,%edx
call   1040 <memcpy@plt>
mov    0x38(%rbp),%ecx
mov    -0x90(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x44(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    152a <RGB555toRGB565+0x40a>
movl   $0x0,-0x2c(%rbp)
jmp    18b3 <RGB555toRGB565+0x793>
movl   $0xffffffff,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<RGB555toRGB565>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %ecx,%r15d
mov    %edx,%ebx
mov    %rdi,%r13
mov    0xd8(%rsp),%ebp
mov    0xd0(%rsp),%r10d
mov    0xc8(%rsp),%r12d
mov    0xb0(%rsp),%r14d
lea    0x48(%rsp),%rax
lea    0x4c(%rsp),%r11
mov    %r8d,0x18(%rsp)
mov    %r9d,0x10(%rsp)
push   %rax
push   %r11
push   %rbp
push   %r10
push   %r12
mov    0xc8(%rsp),%rbp
mov    0xe8(%rsp),%eax
push   %rax
mov    0xe8(%rsp),%eax
mov    %rax,%r12
push   %rax
push   %r14
mov    0xe8(%rsp),%eax
push   %rax
push   %rbp
mov    0xe8(%rsp),%eax
push   %rax
mov    0xe8(%rsp),%eax
push   %rax
call   1030 <chk_args@plt>
add    $0x60,%rsp
mov    %eax,%ecx
mov    $0xffffffff,%eax
test   %ecx,%ecx
je     1c98 <RGB555toRGB565+0xb78>
add    $0xffffffff,%r14d
imul   %r12d,%r14d
movslq %r14d,%rcx
neg    %rcx
xor    %edx,%edx
test   %r12d,%r12d
cmovns %rdx,%rcx
add    %rcx,%rbp
add    $0xffffffff,%ebx
imul   %r15d,%ebx
movslq %ebx,%rcx
neg    %rcx
test   %r15d,%r15d
cmovns %rdx,%rcx
add    %rcx,%r13
mov    0x4c(%rsp),%edx
mov    0x48(%rsp),%ecx
cmp    $0x1,%edx
mov    %r12,%rdi
jne    169b <RGB555toRGB565+0x57b>
cmp    $0x1,%ecx
jne    169b <RGB555toRGB565+0x57b>
mov    0x98(%rsp),%r14d
test   %r14d,%r14d
jle    1c96 <RGB555toRGB565+0xb76>
mov    0x18(%rsp),%eax
add    %eax,%eax
cltq
add    %rax,%r13
mov    0x10(%rsp),%eax
imul   %r15d,%eax
movslq %eax,%r9
add    %r13,%r9
mov    0xc0(%rsp),%esi
lea    (%rsi,%rsi,1),%eax
cltq
add    %rax,%rbp
mov    0xc8(%rsp),%eax
imul   %edi,%eax
movslq %eax,%r8
add    %rbp,%r8
test   $0x3,%sil
setne  %al
mov    0x90(%rsp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
setb   %r13b
and    %al,%r13b
lea    (%rcx,%rcx,1),%eax
sub    %eax,%edi
movslq %edi,%r12
sub    %eax,%r15d
movslq %r15d,%r15
lea    0x1(%rsi),%eax
test   $0x3,%al
setne  %al
mov    %edx,0x10(%rsp)
test   %edx,%edx
setne  %r10b
and    %al,%r10b
lea    0x2(%rsi),%eax
test   $0x3,%al
setne  %al
mov    %ecx,%edx
add    $0xfffffffe,%edx
mov    %edx,0x14(%rsp)
setne  %dl
and    %al,%dl
mov    %dl,0x18(%rsp)
add    $0xffffffff,%esi
test   $0x3,%sil
setne  %al
mov    %ecx,%edx
add    $0xfffffffd,%edx
mov    %edx,0x28(%rsp)
setne  %dl
and    %al,%dl
mov    %dl,0x30(%rsp)
lea    -0x4(%rcx),%eax
mov    %eax,0x20(%rsp)
xor    %ebx,%ebx
movdqa 0xd66(%rip),%xmm0
movdqa 0xd6e(%rip),%xmm1
movdqa 0xd16(%rip),%xmm2
movdqa 0xd1e(%rip),%xmm3
xor    %eax,%eax
jmp    1318 <RGB555toRGB565+0x1f8>
cs nopw 0x0(%rax,%rax,1)
mov    %rcx,%r9
mov    %rbp,%r8
add    %r15,%r9
add    %r12,%r8
add    $0x1,%eax
cmp    %r14d,%eax
je     1c96 <RGB555toRGB565+0xb76>
test   %r13b,%r13b
je     13b0 <RGB555toRGB565+0x290>
movzwl (%r8),%ecx
mov    %ecx,%esi
and    $0x1f,%esi
and    $0xffffffe0,%ecx
lea    (%rsi,%rcx,2),%ecx
mov    %cx,(%r9)
test   %r10b,%r10b
je     1470 <RGB555toRGB565+0x350>
movzwl 0x2(%r8),%ecx
mov    %ecx,%esi
and    $0x1f,%esi
and    $0xffffffe0,%ecx
lea    (%rsi,%rcx,2),%ecx
mov    %cx,0x2(%r9)
cmpb   $0x0,0x18(%rsp)
je     1481 <RGB555toRGB565+0x361>
movzwl 0x4(%r8),%ecx
mov    %ecx,%esi
and    $0x1f,%esi
and    $0xffffffe0,%ecx
lea    (%rsi,%rcx,2),%ecx
mov    %cx,0x4(%r9)
cmpb   $0x0,0x30(%rsp)
je     1521 <RGB555toRGB565+0x401>
movzwl 0x6(%r8),%ecx
mov    %ecx,%esi
and    $0x1f,%esi
and    $0xffffffe0,%ecx
lea    (%rsi,%rcx,2),%ecx
mov    %cx,0x6(%r9)
add    $0x8,%r9
add    $0x8,%r8
mov    0x20(%rsp),%ecx
jmp    1530 <RGB555toRGB565+0x410>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x90(%rsp),%r11d
cmp    $0x4,%r11d
jl     153d <RGB555toRGB565+0x41d>
mov    %r11d,%r14d
sub    $0x7,%r14d
cmovb  %ebx,%r14d
add    $0x3,%r14d
cmp    $0x4,%r14d
jb     1408 <RGB555toRGB565+0x2e8>
mov    %r11d,%ecx
sub    $0x7,%ecx
cmovb  %ebx,%ecx
add    $0x3,%ecx
shr    $0x2,%ecx
lea    (%r8,%rcx,8),%rsi
add    $0x8,%rsi
cmp    %rsi,%r9
jae    1492 <RGB555toRGB565+0x372>
lea    (%r9,%rcx,8),%rcx
add    $0x8,%rcx
cmp    %rcx,%r8
jae    1492 <RGB555toRGB565+0x372>
mov    %r8,%rbp
mov    %r9,%rcx
mov    0x98(%rsp),%r14d
cs nopw 0x0(%rax,%rax,1)
mov    %r11d,%esi
mov    0x0(%rbp),%edi
mov    0x4(%rbp),%ebx
mov    %edi,%edx
and    $0x1f001f,%edx
and    $0xffe07fe0,%edi
lea    (%rdx,%rdi,2),%edx
mov    %edx,(%rcx)
mov    %ebx,%edx
and    $0x1f001f,%edx
and    $0xffe07fe0,%ebx
lea    (%rdx,%rbx,2),%edx
mov    %edx,0x4(%rcx)
add    $0x8,%rcx
add    $0x8,%rbp
lea    -0x4(%rsi),%r11d
cmp    $0x7,%esi
ja     1420 <RGB555toRGB565+0x300>
xor    %ebx,%ebx
jmp    1543 <RGB555toRGB565+0x423>
nopl   0x0(%rax,%rax,1)
add    $0x2,%r9
add    $0x2,%r8
mov    0x10(%rsp),%ecx
jmp    1530 <RGB555toRGB565+0x410>
add    $0x4,%r9
add    $0x4,%r8
mov    0x14(%rsp),%ecx
jmp    1530 <RGB555toRGB565+0x410>
shr    $0x2,%r14d
add    $0x1,%r14d
mov    %r14d,%ebx
and    $0xfffffffe,%ebx
lea    (%r8,%rbx,8),%rbp
lea    (%r9,%rbx,8),%rcx
lea    0x0(,%rbx,4),%esi
sub    %esi,%r11d
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu (%r8,%rsi,8),%xmm4
pshufd $0xe8,%xmm4,%xmm5
pshufd $0xed,%xmm4,%xmm6
pand   %xmm0,%xmm5
paddd  %xmm4,%xmm4
pshufd $0xe8,%xmm4,%xmm7
pand   %xmm1,%xmm7
por    %xmm5,%xmm7
pand   %xmm0,%xmm6
pshufd $0xed,%xmm4,%xmm4
pand   %xmm1,%xmm4
por    %xmm6,%xmm4
punpckldq %xmm4,%xmm7
movdqu %xmm7,(%r9,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rbx
jne    14c0 <RGB555toRGB565+0x3a0>
cmp    %r14,%rbx
mov    0x98(%rsp),%r14d
mov    $0x0,%ebx
jne    1420 <RGB555toRGB565+0x300>
jmp    1543 <RGB555toRGB565+0x423>
add    $0x6,%r9
add    $0x6,%r8
mov    0x28(%rsp),%ecx
nopl   (%rax)
mov    %ecx,%r11d
cmp    $0x4,%r11d
jge    13c2 <RGB555toRGB565+0x2a2>
mov    %r9,%rcx
mov    %r8,%rbp
test   %r11d,%r11d
je     1300 <RGB555toRGB565+0x1e0>
lea    -0x1(%r11),%esi
cmp    $0xf,%esi
jb     157a <RGB555toRGB565+0x45a>
lea    0x2(,%rsi,2),%rdi
add    %rbp,%rdi
cmp    %rdi,%rcx
jae    1613 <RGB555toRGB565+0x4f3>
lea    (%rcx,%rsi,2),%rdi
add    $0x2,%rdi
cmp    %rdi,%rbp
jae    1613 <RGB555toRGB565+0x4f3>
mov    %rbp,%r8
mov    %rcx,%r9
test   $0x1,%r11b
jne    15a0 <RGB555toRGB565+0x480>
mov    %r11d,%ecx
cmp    $0x1,%r11d
je     1306 <RGB555toRGB565+0x1e6>
jmp    15c9 <RGB555toRGB565+0x4a9>
cs nopw 0x0(%rax,%rax,1)
nop
movzwl (%r8),%ecx
mov    %ecx,%esi
and    $0x1f,%esi
and    $0xffffffe0,%ecx
lea    (%rsi,%rcx,2),%ecx
mov    %cx,(%r9)
add    $0x2,%r9
add    $0x2,%r8
lea    -0x1(%r11),%ecx
cmp    $0x1,%r11d
je     1306 <RGB555toRGB565+0x1e6>
mov    %ecx,%ebp
xor    %esi,%esi
xor    %ecx,%ecx
nop
movzwl (%r8,%rsi,2),%edx
mov    %edx,%edi
and    $0x1f,%edi
and    $0xffffffe0,%edx
lea    (%rdi,%rdx,2),%edx
mov    %dx,(%r9,%rsi,2)
movzwl 0x2(%r8,%rsi,2),%edx
mov    %edx,%edi
and    $0x1f,%edi
and    $0xffffffe0,%edx
lea    (%rdi,%rdx,2),%edx
mov    %dx,0x2(%r9,%rsi,2)
add    $0xfffffffffffffffc,%rcx
add    $0x2,%rsi
cmp    %esi,%ebp
jne    15d0 <RGB555toRGB565+0x4b0>
sub    %rcx,%r8
sub    %rcx,%r9
jmp    1306 <RGB555toRGB565+0x1e6>
add    $0x1,%rsi
mov    %rsi,%rbx
movabs $0x1fffffff0,%rdx
and    %rdx,%rbx
lea    0x0(,%rbx,2),%r8
add    %rbp,%r8
lea    (%rcx,%rbx,2),%r9
sub    %ebx,%r11d
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movdqu 0x0(%rbp,%rdi,2),%xmm4
movdqu 0x10(%rbp,%rdi,2),%xmm5
movdqa %xmm4,%xmm6
pand   %xmm2,%xmm6
movdqa %xmm5,%xmm7
pand   %xmm2,%xmm7
paddw  %xmm4,%xmm4
paddw  %xmm5,%xmm5
pand   %xmm3,%xmm4
por    %xmm6,%xmm4
pand   %xmm3,%xmm5
por    %xmm7,%xmm5
movdqu %xmm4,(%rcx,%rdi,2)
movdqu %xmm5,0x10(%rcx,%rdi,2)
add    $0x10,%rdi
cmp    %rdi,%rbx
jne    1640 <RGB555toRGB565+0x520>
cmp    %rbx,%rsi
mov    $0x0,%ebx
je     1306 <RGB555toRGB565+0x1e6>
jmp    1580 <RGB555toRGB565+0x460>
cmp    $0x2,%edx
jne    1c98 <RGB555toRGB565+0xb78>
cmp    $0x2,%ecx
jne    1c98 <RGB555toRGB565+0xb78>
mov    0xd8(%rsp),%eax
test   %eax,%eax
jle    1c96 <RGB555toRGB565+0xb76>
movabs $0x1fffffff0,%r8
mov    0x18(%rsp),%eax
add    %eax,%eax
cltq
add    %rax,%r13
mov    0x10(%rsp),%eax
imul   %r15d,%eax
movslq %eax,%rbx
add    %r13,%rbx
mov    0xc0(%rsp),%esi
lea    (%rsi,%rsi,1),%eax
cltq
add    %rax,%rbp
mov    0xc8(%rsp),%eax
imul   %edi,%eax
movslq %eax,%r14
add    %rbp,%r14
test   $0x3,%sil
setne  %al
mov    0xd0(%rsp),%ecx
mov    %ecx,%ebp
add    $0xffffffff,%ebp
setb   %dl
and    %al,%dl
mov    %dl,0x10(%rsp)
lea    (%rcx,%rcx,1),%eax
cltq
neg    %rax
mov    %rax,0x18(%rsp)
lea    0x0(,%rcx,4),%eax
mov    %eax,0x14(%rsp)
movslq %eax,%r12
neg    %r12
movslq %r15d,%rax
mov    %rax,0x30(%rsp)
movslq %edi,%rax
mov    %rax,0x28(%rsp)
add    %r15d,%r15d
movslq %r15d,%rax
mov    %rax,0x20(%rsp)
lea    0x1(%rsi),%eax
test   $0x3,%al
setne  %al
mov    %ebp,0x44(%rsp)
test   %ebp,%ebp
setne  %dl
and    %al,%dl
mov    %dl,0xf(%rsp)
lea    0x2(%rsi),%eax
test   $0x3,%al
setne  %al
mov    %ecx,%edx
add    $0xfffffffe,%edx
mov    %edx,0x40(%rsp)
setne  %dl
and    %al,%dl
mov    %dl,0xe(%rsp)
add    $0xffffffff,%esi
test   $0x3,%sil
setne  %al
mov    %ecx,%edx
add    $0xfffffffd,%edx
mov    %edx,0x3c(%rsp)
setne  %dl
and    %al,%dl
mov    %dl,0xd(%rsp)
lea    -0x4(%rcx),%eax
mov    %eax,0x38(%rsp)
movaps 0x851(%rip),%xmm8
movdqa 0x858(%rip),%xmm9
movdqa 0x85f(%rip),%xmm10
movdqa 0x867(%rip),%xmm7
add    $0x8,%r8
mov    %r8,0x50(%rsp)
movdqa 0x865(%rip),%xmm11
movdqa 0x86c(%rip),%xmm12
xor    %ebp,%ebp
xor    %r15d,%r15d
mov    0xd8(%rsp),%r13d
jmp    186e <RGB555toRGB565+0x74e>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rdx,%r14
mov    %rcx,%rbx
add    %r12,%rbx
add    0x18(%rsp),%r14
add    0x28(%rsp),%r14
mov    0x30(%rsp),%rax
lea    (%rbx,%rax,1),%rdi
mov    %rbx,%rsi
mov    0x14(%rsp),%edx
call   1040 <memcpy@plt>
add    0x20(%rsp),%rbx
add    $0x1,%r15d
cmp    %r13d,%r15d
movaps 0x7c4(%rip),%xmm8
movdqa 0x7cb(%rip),%xmm9
movdqa 0x7d2(%rip),%xmm10
movdqa 0x7da(%rip),%xmm7
movdqa 0x7e1(%rip),%xmm11
movdqa 0x7e8(%rip),%xmm12
je     1c96 <RGB555toRGB565+0xb76>
cmpb   $0x0,0x10(%rsp)
je     1910 <RGB555toRGB565+0x7f0>
movzwl (%r14),%eax
mov    %eax,%ecx
and    $0x1f,%ecx
and    $0xffffffe0,%eax
lea    (%rcx,%rax,2),%eax
mov    %ax,(%rbx)
mov    %ax,0x2(%rbx)
cmpb   $0x0,0xf(%rsp)
je     19f0 <RGB555toRGB565+0x8d0>
movzwl 0x2(%r14),%eax
mov    %eax,%ecx
and    $0x1f,%ecx
and    $0xffffffe0,%eax
lea    (%rcx,%rax,2),%eax
mov    %ax,0x4(%rbx)
mov    %ax,0x6(%rbx)
cmpb   $0x0,0xe(%rsp)
je     1b20 <RGB555toRGB565+0xa00>
movzwl 0x4(%r14),%eax
mov    %eax,%ecx
and    $0x1f,%ecx
and    $0xffffffe0,%eax
lea    (%rcx,%rax,2),%eax
mov    %ax,0x8(%rbx)
mov    %ax,0xa(%rbx)
cmpb   $0x0,0xd(%rsp)
je     1b36 <RGB555toRGB565+0xa16>
movzwl 0x6(%r14),%eax
mov    %eax,%ecx
and    $0x1f,%ecx
and    $0xffffffe0,%eax
lea    (%rcx,%rax,2),%eax
mov    %ax,0xc(%rbx)
mov    %ax,0xe(%rbx)
add    $0x10,%rbx
add    $0x8,%r14
mov    0x38(%rsp),%eax
cmp    $0x4,%eax
jl     1b50 <RGB555toRGB565+0xa30>
jmp    1920 <RGB555toRGB565+0x800>
nop
mov    0xd0(%rsp),%eax
cmp    $0x4,%eax
jl     1b50 <RGB555toRGB565+0xa30>
mov    %eax,%esi
sub    $0x7,%esi
cmovb  %ebp,%esi
add    $0x3,%esi
cmp    $0xc,%esi
jb     1963 <RGB555toRGB565+0x843>
mov    %eax,%ecx
sub    $0x7,%ecx
cmovb  %ebp,%ecx
add    $0x3,%ecx
shr    $0x2,%ecx
lea    (%r14,%rcx,8),%rdx
add    $0x8,%rdx
cmp    %rdx,%rbx
jae    1a0a <RGB555toRGB565+0x8ea>
shl    $0x4,%rcx
add    %rbx,%rcx
add    $0x10,%rcx
cmp    %rcx,%r14
jae    1a0a <RGB555toRGB565+0x8ea>
mov    %rbx,%rcx
mov    %r14,%rdx
nopl   0x0(%rax)
mov    %eax,%esi
mov    (%rdx),%eax
mov    %eax,%edi
and    $0x1f001f,%edi
and    $0xffe07fe0,%eax
lea    (%rdi,%rax,2),%ebp
movzwl %bp,%edi
mov    %ebp,%eax
shl    $0x10,%eax
or     %edi,%eax
mov    %eax,(%rcx)
mov    %ebp,%eax
and    $0xffdf0000,%eax
shr    $0x10,%ebp
or     %eax,%ebp
mov    %ebp,0x4(%rcx)
mov    0x4(%rdx),%eax
mov    %eax,%edi
and    $0x1f001f,%edi
and    $0xffe07fe0,%eax
lea    (%rdi,%rax,2),%ebp
movzwl %bp,%edi
mov    %ebp,%eax
shl    $0x10,%eax
or     %edi,%eax
mov    %eax,0x8(%rcx)
mov    %ebp,%eax
and    $0xffdf0000,%eax
shr    $0x10,%ebp
or     %eax,%ebp
mov    %ebp,0xc(%rcx)
add    $0x10,%rcx
add    $0x8,%rdx
lea    -0x4(%rsi),%eax
cmp    $0x7,%esi
ja     1970 <RGB555toRGB565+0x850>
xor    %ebp,%ebp
jmp    1b56 <RGB555toRGB565+0xa36>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x4,%rbx
add    $0x2,%r14
mov    0x44(%rsp),%eax
cmp    $0x4,%eax
jl     1b50 <RGB555toRGB565+0xa30>
jmp    1920 <RGB555toRGB565+0x800>
shr    $0x2,%esi
add    $0x1,%esi
mov    %esi,%edi
and    $0xfffffffc,%edi
lea    0x0(,%rdi,4),%ecx
sub    %ecx,%eax
mov    %rdi,%rcx
shl    $0x4,%rcx
add    %rbx,%rcx
lea    (%r14,%rdi,8),%rdx
xor    %ebp,%ebp
xchg   %ax,%ax
movups (%r14,%rbp,8),%xmm1
movups 0x10(%r14,%rbp,8),%xmm2
movaps %xmm1,%xmm0
shufps $0x88,%xmm2,%xmm0
shufps $0xdd,%xmm2,%xmm1
movaps %xmm0,%xmm2
andps  %xmm8,%xmm2
paddd  %xmm0,%xmm0
pand   %xmm9,%xmm0
por    %xmm2,%xmm0
movdqa %xmm0,%xmm3
pand   %xmm10,%xmm3
movdqa %xmm0,%xmm2
pslld  $0x10,%xmm2
por    %xmm3,%xmm2
movdqa %xmm0,%xmm3
pand   %xmm7,%xmm3
psrld  $0x10,%xmm0
por    %xmm3,%xmm0
movaps %xmm1,%xmm3
andps  %xmm8,%xmm3
paddd  %xmm1,%xmm1
pand   %xmm9,%xmm1
por    %xmm3,%xmm1
movdqa %xmm1,%xmm3
pand   %xmm10,%xmm3
movdqa %xmm1,%xmm4
pslld  $0x10,%xmm4
por    %xmm3,%xmm4
movdqa %xmm1,%xmm3
pand   %xmm7,%xmm3
psrld  $0x10,%xmm1
por    %xmm3,%xmm1
movdqa %xmm4,%xmm3
punpckldq %xmm1,%xmm3
movdqa %xmm2,%xmm5
punpckldq %xmm0,%xmm5
movdqa %xmm5,%xmm6
punpcklqdq %xmm3,%xmm6
punpckhqdq %xmm3,%xmm5
punpckhdq %xmm1,%xmm4
punpckhdq %xmm0,%xmm2
movdqa %xmm2,%xmm0
punpcklqdq %xmm4,%xmm0
punpckhqdq %xmm4,%xmm2
movdqu %xmm2,0x30(%rbx)
movdqu %xmm0,0x20(%rbx)
movdqu %xmm5,0x10(%rbx)
movdqu %xmm6,(%rbx)
add    $0x4,%rbp
add    $0x40,%rbx
cmp    %rbp,%rdi
jne    1a30 <RGB555toRGB565+0x910>
cmp    %rsi,%rdi
mov    $0x0,%ebp
jne    1970 <RGB555toRGB565+0x850>
jmp    1b56 <RGB555toRGB565+0xa36>
add    $0x8,%rbx
add    $0x4,%r14
mov    0x40(%rsp),%eax
cmp    $0x4,%eax
jl     1b50 <RGB555toRGB565+0xa30>
jmp    1920 <RGB555toRGB565+0x800>
add    $0xc,%rbx
add    $0x6,%r14
mov    0x3c(%rsp),%eax
cmp    $0x4,%eax
jge    1920 <RGB555toRGB565+0x800>
nopl   0x0(%rax,%rax,1)
mov    %r14,%rdx
mov    %rbx,%rcx
test   %eax,%eax
je     1800 <RGB555toRGB565+0x6e0>
lea    -0x1(%rax),%esi
cmp    $0x7,%esi
jb     1b88 <RGB555toRGB565+0xa68>
lea    (%rdx,%rsi,2),%rdi
add    $0x2,%rdi
cmp    %rdi,%rcx
jae    1c10 <RGB555toRGB565+0xaf0>
lea    (%rcx,%rsi,4),%rdi
add    $0x4,%rdi
cmp    %rdi,%rdx
jae    1c10 <RGB555toRGB565+0xaf0>
mov    %rcx,%rbx
mov    %rdx,%r14
test   $0x1,%al
jne    1ba0 <RGB555toRGB565+0xa80>
mov    %eax,%ecx
cmp    $0x1,%eax
jne    1bd0 <RGB555toRGB565+0xab0>
jmp    1806 <RGB555toRGB565+0x6e6>
xchg   %ax,%ax
movzwl (%r14),%ecx
mov    %ecx,%edx
and    $0x1f,%edx
and    $0xffffffe0,%ecx
lea    (%rdx,%rcx,2),%ecx
mov    %cx,(%rbx)
mov    %cx,0x2(%rbx)
add    $0x4,%rbx
add    $0x2,%r14
lea    -0x1(%rax),%ecx
cmp    $0x1,%eax
je     1806 <RGB555toRGB565+0x6e6>
nopw   0x0(%rax,%rax,1)
movzwl (%r14),%eax
mov    %eax,%edx
and    $0x1f,%edx
and    $0xffffffe0,%eax
lea    (%rdx,%rax,2),%eax
mov    %ax,(%rbx)
mov    %ax,0x2(%rbx)
movzwl 0x2(%r14),%eax
mov    %eax,%edx
and    $0x1f,%edx
and    $0xffffffe0,%eax
lea    (%rdx,%rax,2),%eax
mov    %ax,0x4(%rbx)
mov    %ax,0x6(%rbx)
add    $0x8,%rbx
add    $0x4,%r14
add    $0xfffffffe,%ecx
jne    1bd0 <RGB555toRGB565+0xab0>
jmp    1806 <RGB555toRGB565+0x6e6>
add    $0x1,%rsi
mov    %rsi,%rdi
and    0x50(%rsp),%rdi
sub    %edi,%eax
lea    (%rcx,%rdi,4),%rbx
lea    (%rdx,%rdi,2),%r14
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movq   (%rdx,%rbp,2),%xmm0
movq   0x8(%rdx,%rbp,2),%xmm1
movdqa %xmm0,%xmm2
pand   %xmm11,%xmm2
movdqa %xmm1,%xmm3
pand   %xmm11,%xmm3
paddw  %xmm0,%xmm0
paddw  %xmm1,%xmm1
pand   %xmm12,%xmm0
por    %xmm2,%xmm0
pand   %xmm12,%xmm1
por    %xmm3,%xmm1
punpcklwd %xmm0,%xmm0
movdqu %xmm0,(%rcx,%rbp,4)
punpcklwd %xmm1,%xmm1
movdqu %xmm1,0x10(%rcx,%rbp,4)
add    $0x8,%rbp
cmp    %rbp,%rdi
jne    1c30 <RGB555toRGB565+0xb10>
cmp    %rdi,%rsi
mov    $0x0,%ebp
je     1806 <RGB555toRGB565+0x6e6>
jmp    1b8e <RGB555toRGB565+0xa6e>
xor    %eax,%eax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @RGB555toRGB565(i8* %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6, i32 %7, i8* %8, i32 %9, i32 %10, i32 %11, i32 %12, i32 %13, i32 %14, i32 %15) {
%17 = alloca i32
%18 = alloca i8*
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i8*
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i8*
%37 = alloca i8*
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca i16
%42 = alloca i32
%43 = alloca i32
%44 = alloca i16
%45 = alloca i8*
%46 = alloca i8*
%47 = alloca i32
%48 = alloca i32
%49 = alloca i32
%50 = alloca i16
%51 = alloca i16
%52 = alloca i32
%53 = alloca i32
%54 = alloca i16
%55 = alloca i16
store i8* %0, i8** %18
store i32 %1, i32* %19
store i32 %2, i32* %20
store i32 %3, i32* %21
store i32 %4, i32* %22
store i32 %5, i32* %23
store i32 %6, i32* %24
store i32 %7, i32* %25
store i8* %8, i8** %26
store i32 %9, i32* %27
store i32 %10, i32* %28
store i32 %11, i32* %29
store i32 %12, i32* %30
store i32 %13, i32* %31
store i32 %14, i32* %32
store i32 %15, i32* %33
%56 = load i8*, i8** %18
%57 = load i32, i32* %19
%58 = load i32, i32* %20
%59 = load i32, i32* %21
%60 = load i32, i32* %22
%61 = load i32, i32* %23
%62 = load i32, i32* %24
%63 = load i32, i32* %25
%64 = load i8*, i8** %26
%65 = load i32, i32* %27
%66 = load i32, i32* %28
%67 = load i32, i32* %29
%68 = load i32, i32* %30
%69 = load i32, i32* %31
%70 = load i32, i32* %32
%71 = load i32, i32* %33
%72 = call i32 @chk_args(i8* %56, i32 %57, i32 %58, i32 %59, i32 %60, i32 %61, i32 %62, i32 %63, i8* %64, i32 %65, i32 %66, i32 %67, i32 %68, i32 %69, i32 %70, i32 %71, i32* %34, i32* %35)
%73 = icmp ne i32 %72, 0
br i1 %73, label %75, label %74
74: ; preds = %16
store i32 -1, i32* %17
br label %443
75: ; preds = %16
%76 = load i32, i32* %29
%77 = icmp slt i32 %76, 0
br i1 %77, label %78, label %87
78: ; preds = %75
%79 = load i32, i32* %28
%80 = sub nsw i32 %79, 1
%81 = load i32, i32* %29
%82 = mul nsw i32 %80, %81
%83 = load i8*, i8** %26
%84 = sext i32 %82 to i64
%85 = sub i64 0, %84
%86 = getelementptr inbounds i8, i8* %83, i64 %85
store i8* %86, i8** %26
br label %87
87: ; preds = %78, %75
%88 = load i32, i32* %21
%89 = icmp slt i32 %88, 0
br i1 %89, label %90, label %99
90: ; preds = %87
%91 = load i32, i32* %20
%92 = sub nsw i32 %91, 1
%93 = load i32, i32* %21
%94 = mul nsw i32 %92, %93
%95 = load i8*, i8** %18
%96 = sext i32 %94 to i64
%97 = sub i64 0, %96
%98 = getelementptr inbounds i8, i8* %95, i64 %97
store i8* %98, i8** %18
br label %99
99: ; preds = %90, %87
%100 = load i32, i32* %34
%101 = icmp eq i32 %100, 1
br i1 %101, label %102, label %244
102: ; preds = %99
%103 = load i32, i32* %35
%104 = icmp eq i32 %103, 1
br i1 %104, label %105, label %244
105: ; preds = %102
%106 = load i8*, i8** %26
%107 = load i32, i32* %30
%108 = mul nsw i32 %107, 2
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i8, i8* %106, i64 %109
%111 = load i32, i32* %31
%112 = load i32, i32* %29
%113 = mul nsw i32 %111, %112
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds i8, i8* %110, i64 %114
store i8* %115, i8** %36
%116 = load i8*, i8** %18
%117 = load i32, i32* %22
%118 = mul nsw i32 %117, 2
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds i8, i8* %116, i64 %119
%121 = load i32, i32* %23
%122 = load i32, i32* %21
%123 = mul nsw i32 %121, %122
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds i8, i8* %120, i64 %124
store i8* %125, i8** %37
store i32 0, i32* %38
br label %126
126: ; preds = %240, %105
%127 = load i32, i32* %38
%128 = load i32, i32* %25
%129 = icmp slt i32 %127, %128
br i1 %129, label %130, label %243
130: ; preds = %126
%131 = load i32, i32* %30
store i32 %131, i32* %39
%132 = load i32, i32* %24
store i32 %132, i32* %40
br label %133
133: ; preds = %142, %130
%134 = load i32, i32* %39
%135 = and i32 %134, 3
%136 = icmp ne i32 %135, 0
br i1 %136, label %137, label %140
137: ; preds = %133
%138 = load i32, i32* %40
%139 = icmp ne i32 %138, 0
br label %140
140: ; preds = %137, %133
%141 = phi i1 [ false, %133 ], [ %139, %137 ]
br i1 %141, label %142, label %165
142: ; preds = %140
%143 = load i8*, i8** %36
%144 = bitcast i8* %143 to i16*
%145 = load i16, i16* %144
store i16 %145, i16* %41
%146 = load i16, i16* %41
%147 = zext i16 %146 to i32
%148 = and i32 %147, 31
%149 = load i16, i16* %41
%150 = zext i16 %149 to i32
%151 = and i32 %150, 32736
%152 = shl i32 %151, 1
%153 = or i32 %148, %152
%154 = trunc i32 %153 to i16
%155 = load i8*, i8** %37
%156 = bitcast i8* %155 to i16*
store i16 %154, i16* %156
%157 = load i8*, i8** %37
%158 = getelementptr inbounds i8, i8* %157, i64 2
store i8* %158, i8** %37
%159 = load i8*, i8** %36
%160 = getelementptr inbounds i8, i8* %159, i64 2
store i8* %160, i8** %36
%161 = load i32, i32* %39
%162 = add nsw i32 %161, 1
store i32 %162, i32* %39
%163 = load i32, i32* %40
%164 = add nsw i32 %163, -1
store i32 %164, i32* %40
br label %133
165: ; preds = %140
br label %166
166: ; preds = %169, %165
%167 = load i32, i32* %40
%168 = icmp sge i32 %167, 4
br i1 %168, label %169, label %200
169: ; preds = %166
%170 = load i8*, i8** %36
%171 = bitcast i8* %170 to i32*
%172 = load i32, i32* %171
store i32 %172, i32* %42
%173 = load i8*, i8** %36
%174 = getelementptr inbounds i8, i8* %173, i64 4
%175 = bitcast i8* %174 to i32*
%176 = load i32, i32* %175
store i32 %176, i32* %43
%177 = load i32, i32* %42
%178 = and i32 %177, 2031647
%179 = load i32, i32* %42
%180 = and i32 %179, 2145419232
%181 = shl i32 %180, 1
%182 = or i32 %178, %181
%183 = load i8*, i8** %37
%184 = bitcast i8* %183 to i32*
store i32 %182, i32* %184
%185 = load i32, i32* %43
%186 = and i32 %185, 2031647
%187 = load i32, i32* %43
%188 = and i32 %187, 2145419232
%189 = shl i32 %188, 1
%190 = or i32 %186, %189
%191 = load i8*, i8** %37
%192 = getelementptr inbounds i8, i8* %191, i64 4
%193 = bitcast i8* %192 to i32*
store i32 %190, i32* %193
%194 = load i8*, i8** %37
%195 = getelementptr inbounds i8, i8* %194, i64 8
store i8* %195, i8** %37
%196 = load i8*, i8** %36
%197 = getelementptr inbounds i8, i8* %196, i64 8
store i8* %197, i8** %36
%198 = load i32, i32* %40
%199 = sub nsw i32 %198, 4
store i32 %199, i32* %40
br label %166
200: ; preds = %166
br label %201
201: ; preds = %204, %200
%202 = load i32, i32* %40
%203 = icmp ne i32 %202, 0
br i1 %203, label %204, label %225
204: ; preds = %201
%205 = load i8*, i8** %36
%206 = bitcast i8* %205 to i16*
%207 = load i16, i16* %206
store i16 %207, i16* %44
%208 = load i16, i16* %44
%209 = zext i16 %208 to i32
%210 = and i32 %209, 31
%211 = load i16, i16* %44
%212 = zext i16 %211 to i32
%213 = and i32 %212, 32736
%214 = shl i32 %213, 1
%215 = or i32 %210, %214
%216 = trunc i32 %215 to i16
%217 = load i8*, i8** %37
%218 = bitcast i8* %217 to i16*
store i16 %216, i16* %218
%219 = load i8*, i8** %37
%220 = getelementptr inbounds i8, i8* %219, i64 2
store i8* %220, i8** %37
%221 = load i8*, i8** %36
%222 = getelementptr inbounds i8, i8* %221, i64 2
store i8* %222, i8** %36
%223 = load i32, i32* %40
%224 = add nsw i32 %223, -1
store i32 %224, i32* %40
br label %201
225: ; preds = %201
%226 = load i32, i32* %29
%227 = load i32, i32* %24
%228 = mul nsw i32 %227, 2
%229 = sub nsw i32 %226, %228
%230 = load i8*, i8** %36
%231 = sext i32 %229 to i64
%232 = getelementptr inbounds i8, i8* %230, i64 %231
store i8* %232, i8** %36
%233 = load i32, i32* %21
%234 = load i32, i32* %24
%235 = mul nsw i32 %234, 2
%236 = sub nsw i32 %233, %235
%237 = load i8*, i8** %37
%238 = sext i32 %236 to i64
%239 = getelementptr inbounds i8, i8* %237, i64 %238
store i8* %239, i8** %37
br label %240
240: ; preds = %225
%241 = load i32, i32* %38
%242 = add nsw i32 %241, 1
store i32 %242, i32* %38
br label %126
243: ; preds = %126
store i32 0, i32* %17
br label %443
244: ; preds = %102, %99
%245 = load i32, i32* %34
%246 = icmp eq i32 %245, 2
br i1 %246, label %247, label %442
247: ; preds = %244
%248 = load i32, i32* %35
%249 = icmp eq i32 %248, 2
br i1 %249, label %250, label %442
250: ; preds = %247
%251 = load i8*, i8** %26
%252 = load i32, i32* %30
%253 = mul nsw i32 %252, 2
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds i8, i8* %251, i64 %254
%256 = load i32, i32* %31
%257 = load i32, i32* %29
%258 = mul nsw i32 %256, %257
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds i8, i8* %255, i64 %259
store i8* %260, i8** %45
%261 = load i8*, i8** %18
%262 = load i32, i32* %22
%263 = mul nsw i32 %262, 2
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds i8, i8* %261, i64 %264
%266 = load i32, i32* %23
%267 = load i32, i32* %21
%268 = mul nsw i32 %266, %267
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds i8, i8* %265, i64 %269
store i8* %270, i8** %46
store i32 0, i32* %47
br label %271
271: ; preds = %438, %250
%272 = load i32, i32* %47
%273 = load i32, i32* %33
%274 = icmp slt i32 %272, %273
br i1 %274, label %275, label %441
275: ; preds = %271
%276 = load i32, i32* %30
store i32 %276, i32* %48
%277 = load i32, i32* %32
store i32 %277, i32* %49
br label %278
278: ; preds = %287, %275
%279 = load i32, i32* %48
%280 = and i32 %279, 3
%281 = icmp ne i32 %280, 0
br i1 %281, label %282, label %285
282: ; preds = %278
%283 = load i32, i32* %49
%284 = icmp ne i32 %283, 0
br label %285
285: ; preds = %282, %278
%286 = phi i1 [ false, %278 ], [ %284, %282 ]
br i1 %286, label %287, label %315
287: ; preds = %285
%288 = load i8*, i8** %45
%289 = bitcast i8* %288 to i16*
%290 = load i16, i16* %289
store i16 %290, i16* %50
%291 = load i16, i16* %50
%292 = zext i16 %291 to i32
%293 = and i32 %292, 31
%294 = load i16, i16* %50
%295 = zext i16 %294 to i32
%296 = and i32 %295, 32736
%297 = shl i32 %296, 1
%298 = or i32 %293, %297
%299 = trunc i32 %298 to i16
store i16 %299, i16* %51
%300 = load i16, i16* %51
%301 = load i8*, i8** %46
%302 = bitcast i8* %301 to i16*
store i16 %300, i16* %302
%303 = load i16, i16* %51
%304 = load i8*, i8** %46
%305 = getelementptr inbounds i8, i8* %304, i64 2
%306 = bitcast i8* %305 to i16*
store i16 %303, i16* %306
%307 = load i8*, i8** %46
%308 = getelementptr inbounds i8, i8* %307, i64 4
store i8* %308, i8** %46
%309 = load i8*, i8** %45
%310 = getelementptr inbounds i8, i8* %309, i64 2
store i8* %310, i8** %45
%311 = load i32, i32* %48
%312 = add nsw i32 %311, 1
store i32 %312, i32* %48
%313 = load i32, i32* %49
%314 = add nsw i32 %313, -1
store i32 %314, i32* %49
br label %278
315: ; preds = %285
br label %316
316: ; preds = %319, %315
%317 = load i32, i32* %49
%318 = icmp sge i32 %317, 4
br i1 %318, label %319, label %376
319: ; preds = %316
%320 = load i8*, i8** %45
%321 = bitcast i8* %320 to i32*
%322 = load i32, i32* %321
store i32 %322, i32* %52
%323 = load i32, i32* %52
%324 = and i32 %323, 2031647
%325 = load i32, i32* %52
%326 = and i32 %325, 2145419232
%327 = shl i32 %326, 1
%328 = or i32 %324, %327
store i32 %328, i32* %53
%329 = load i32, i32* %53
%330 = and i32 %329, 65535
%331 = load i32, i32* %53
%332 = shl i32 %331, 16
%333 = or i32 %330, %332
%334 = load i8*, i8** %46
%335 = bitcast i8* %334 to i32*
store i32 %333, i32* %335
%336 = load i32, i32* %53
%337 = and i32 %336, -65536
%338 = load i32, i32* %53
%339 = lshr i32 %338, 16
%340 = or i32 %337, %339
%341 = load i8*, i8** %46
%342 = getelementptr inbounds i8, i8* %341, i64 4
%343 = bitcast i8* %342 to i32*
store i32 %340, i32* %343
%344 = load i8*, i8** %45
%345 = getelementptr inbounds i8, i8* %344, i64 4
%346 = bitcast i8* %345 to i32*
%347 = load i32, i32* %346
store i32 %347, i32* %52
%348 = load i32, i32* %52
%349 = and i32 %348, 2031647
%350 = load i32, i32* %52
%351 = and i32 %350, 2145419232
%352 = shl i32 %351, 1
%353 = or i32 %349, %352
store i32 %353, i32* %53
%354 = load i32, i32* %53
%355 = and i32 %354, 65535
%356 = load i32, i32* %53
%357 = shl i32 %356, 16
%358 = or i32 %355, %357
%359 = load i8*, i8** %46
%360 = getelementptr inbounds i8, i8* %359, i64 8
%361 = bitcast i8* %360 to i32*
store i32 %358, i32* %361
%362 = load i32, i32* %53
%363 = and i32 %362, -65536
%364 = load i32, i32* %53
%365 = lshr i32 %364, 16
%366 = or i32 %363, %365
%367 = load i8*, i8** %46
%368 = getelementptr inbounds i8, i8* %367, i64 12
%369 = bitcast i8* %368 to i32*
store i32 %366, i32* %369
%370 = load i8*, i8** %46
%371 = getelementptr inbounds i8, i8* %370, i64 16
store i8* %371, i8** %46
%372 = load i8*, i8** %45
%373 = getelementptr inbounds i8, i8* %372, i64 8
store i8* %373, i8** %45
%374 = load i32, i32* %49
%375 = sub nsw i32 %374, 4
store i32 %375, i32* %49
br label %316
376: ; preds = %316
br label %377
377: ; preds = %380, %376
%378 = load i32, i32* %49
%379 = icmp ne i32 %378, 0
br i1 %379, label %380, label %406
380: ; preds = %377
%381 = load i8*, i8** %45
%382 = bitcast i8* %381 to i16*
%383 = load i16, i16* %382
store i16 %383, i16* %54
%384 = load i16, i16* %54
%385 = zext i16 %384 to i32
%386 = and i32 %385, 31
%387 = load i16, i16* %54
%388 = zext i16 %387 to i32
%389 = and i32 %388, 32736
%390 = shl i32 %389, 1
%391 = or i32 %386, %390
%392 = trunc i32 %391 to i16
store i16 %392, i16* %55
%393 = load i16, i16* %55
%394 = load i8*, i8** %46
%395 = bitcast i8* %394 to i16*
store i16 %393, i16* %395
%396 = load i16, i16* %55
%397 = load i8*, i8** %46
%398 = getelementptr inbounds i8, i8* %397, i64 2
%399 = bitcast i8* %398 to i16*
store i16 %396, i16* %399
%400 = load i8*, i8** %46
%401 = getelementptr inbounds i8, i8* %400, i64 4
store i8* %401, i8** %46
%402 = load i8*, i8** %45
%403 = getelementptr inbounds i8, i8* %402, i64 2
store i8* %403, i8** %45
%404 = load i32, i32* %49
%405 = add nsw i32 %404, -1
store i32 %405, i32* %49
br label %377
406: ; preds = %377
%407 = load i32, i32* %32
%408 = mul nsw i32 %407, 2
%409 = load i8*, i8** %45
%410 = sext i32 %408 to i64
%411 = sub i64 0, %410
%412 = getelementptr inbounds i8, i8* %409, i64 %411
store i8* %412, i8** %45
%413 = load i32, i32* %32
%414 = mul nsw i32 %413, 2
%415 = mul nsw i32 %414, 2
%416 = load i8*, i8** %46
%417 = sext i32 %415 to i64
%418 = sub i64 0, %417
%419 = getelementptr inbounds i8, i8* %416, i64 %418
store i8* %419, i8** %46
%420 = load i8*, i8** %46
%421 = load i32, i32* %21
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds i8, i8* %420, i64 %422
%424 = load i8*, i8** %46
%425 = load i32, i32* %32
%426 = mul nsw i32 %425, 2
%427 = mul nsw i32 %426, 2
%428 = call i32 @memcpy(i8* %423, i8* %424, i32 %427)
%429 = load i32, i32* %29
%430 = load i8*, i8** %45
%431 = sext i32 %429 to i64
%432 = getelementptr inbounds i8, i8* %430, i64 %431
store i8* %432, i8** %45
%433 = load i32, i32* %21
%434 = mul nsw i32 %433, 2
%435 = load i8*, i8** %46
%436 = sext i32 %434 to i64
%437 = getelementptr inbounds i8, i8* %435, i64 %436
store i8* %437, i8** %46
br label %438
438: ; preds = %406
%439 = load i32, i32* %47
%440 = add nsw i32 %439, 1
store i32 %440, i32* %47
br label %271
441: ; preds = %271
store i32 0, i32* %17
br label %443
442: ; preds = %247, %244
store i32 -1, i32* %17
br label %443
443: ; preds = %442, %441, %243, %74
%444 = load i32, i32* %17
ret i32 %444
}

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