#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 RGB24toRGB555(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 * 3 + 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) {
        *(unsigned short *)d =
            (s[0] >> 3) | ((s[1] & 0xF8) << 2) | ((s[2] & 0xF8) << 7);
        d += 2;
        s += 3;
        sx++;
        ddx--;
      }
      while (ddx >= 4) {
        register unsigned int a, b;
        a = *(unsigned int *)s;
        b = *(unsigned int *)(s + 4);
        *(unsigned int *)d = ((a & 0xF8) >> 3) | ((a & 0xF800) >> 6) |
                             ((a & 0xF80000) >> 9) | ((a & 0xF8000000) >> 11) |
                             ((b & 0xF8) << 18) | ((b & 0xF800) << 15);
        a = *(unsigned int *)(s + 8);
        *(unsigned int *)(d + 4) =
            ((b & 0xF80000) >> 19) | ((b & 0xF8000000) >> 22) |
            ((a & 0xF8) << 7) | ((a & 0xF800) << 5) | ((a & 0xF80000) << 2) |
            ((a & 0xF8000000) >> 1);
        d += 2 * 4;
        s += 3 * 4;
        ddx -= 4;
      }
      while (ddx) {
        *(unsigned short *)d =
            (s[0] >> 3) | ((s[1] & 0xF8) << 2) | ((s[2] & 0xF8) << 7);
        d += 2;
        s += 3;
        ddx--;
      }
      s += src_pitch - dest_dx * 3;
      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 * 3 + 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;
        a = (s[0] >> 3) | ((s[1] & 0xF8) << 2) | ((s[2] & 0xF8) << 7);
        *(unsigned short *)d = a;
        *(unsigned short *)(d + 2) = a;
        d += 2 * 2;
        s += 3;
        sx++;
        sdx--;
      }
      while (sdx >= 4) {
        register unsigned int a, b, c;
        a = *(unsigned int *)s;
        b = *(unsigned int *)(s + 4);
        c = ((a & 0xF8) >> 3) | ((a & 0xF800) >> 6) | ((a & 0xF80000) >> 9);
        *(unsigned int *)d = c | (c << 16);
        c = ((a & 0xF8000000) >> 11) | ((b & 0xF8) << 18) |
            ((b & 0xF800) << 15);
        *(unsigned int *)(d + 2 * 2) = c | (c >> 16);
        a = *(unsigned int *)(s + 8);
        c = ((b & 0xF80000) >> 19) | ((b & 0xF8000000) >> 22) |
            ((a & 0xF8) << 7);
        *(unsigned int *)(d + 2 * 2 * 2) = c | (c << 16);
        c = ((a & 0xF800) << 5) | ((a & 0xF80000) << 2) |
            ((a & 0xF8000000) >> 1);
        *(unsigned int *)(d + 3 * 2 * 2) = c | (c >> 16);
        d += 2 * 4 * 2;
        s += 4 * 3;
        sdx -= 4;
      }
      while (sdx) {
        register unsigned short a;
        a = (s[0] >> 3) | ((s[1] & 0xF8) << 2) | ((s[2] & 0xF8) << 7);
        *(unsigned short *)d = a;
        *(unsigned short *)(d + 2) = a;
        d += 2 * 2;
        s += 3;
        sdx--;
      }
      s -= src_dx * 3;
      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):
<RGB24toRGB555>:
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,-0xd0(%rbp)
mov    0x18(%rbp),%eax
mov    %eax,-0xcc(%rbp)
mov    0x20(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    0x28(%rbp),%eax
mov    %eax,-0xbc(%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,-0xb8(%rbp)
mov    -0xd0(%rbp),%eax
mov    %eax,(%rsp)
mov    -0xcc(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0xc8(%rbp),%rax
mov    %rax,0x10(%rsp)
mov    -0xbc(%rbp),%eax
mov    %eax,0x18(%rsp)
mov    -0xb8(%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 <RGB24toRGB555+0x11a>
movl   $0xffffffff,-0x2c(%rbp)
jmp    19dc <RGB24toRGB555+0x8bc>
cmpl   $0x0,0x38(%rbp)
jge    1261 <RGB24toRGB555+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 <RGB24toRGB555+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    154d <RGB24toRGB555+0x42d>
cmpl   $0x1,-0x54(%rbp)
jne    154d <RGB24toRGB555+0x42d>
mov    0x20(%rbp),%rax
imul   $0x3,0x40(%rbp),%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    1541 <RGB24toRGB555+0x421>
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,-0xd1(%rbp)
je     131f <RGB24toRGB555+0x1ff>
cmpl   $0x0,-0x74(%rbp)
setne  %al
mov    %al,-0xd1(%rbp)
mov    -0xd1(%rbp),%al
test   $0x1,%al
jne    1332 <RGB24toRGB555+0x212>
jmp    139b <RGB24toRGB555+0x27b>
mov    -0x60(%rbp),%rax
movzbl (%rax),%eax
sar    $0x3,%eax
mov    -0x60(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
and    $0xf8,%ecx
shl    $0x2,%ecx
or     %ecx,%eax
mov    -0x60(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
and    $0xf8,%ecx
shl    $0x7,%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    $0x3,%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    12fb <RGB24toRGB555+0x1db>
jmp    13a0 <RGB24toRGB555+0x280>
cmpl   $0x4,-0x74(%rbp)
jl     1494 <RGB24toRGB555+0x374>
mov    -0x60(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x78(%rbp)
mov    -0x60(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x78(%rbp),%ecx
and    $0xf8,%ecx
shr    $0x3,%ecx
mov    -0x78(%rbp),%eax
and    $0xf800,%eax
shr    $0x6,%eax
or     %eax,%ecx
mov    -0x78(%rbp),%eax
and    $0xf80000,%eax
shr    $0x9,%eax
or     %eax,%ecx
mov    -0x78(%rbp),%eax
and    $0xf8000000,%eax
shr    $0xb,%eax
or     %eax,%ecx
mov    -0x7c(%rbp),%eax
and    $0xf8,%eax
shl    $0x12,%eax
or     %eax,%ecx
mov    -0x7c(%rbp),%eax
and    $0xf800,%eax
shl    $0xf,%eax
or     %eax,%ecx
mov    -0x68(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x60(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x78(%rbp)
mov    -0x7c(%rbp),%ecx
and    $0xf80000,%ecx
shr    $0x13,%ecx
mov    -0x7c(%rbp),%eax
and    $0xf8000000,%eax
shr    $0x16,%eax
or     %eax,%ecx
mov    -0x78(%rbp),%eax
and    $0xf8,%eax
shl    $0x7,%eax
or     %eax,%ecx
mov    -0x78(%rbp),%eax
and    $0xf800,%eax
shl    $0x5,%eax
or     %eax,%ecx
mov    -0x78(%rbp),%eax
and    $0xf80000,%eax
shl    $0x2,%eax
or     %eax,%ecx
mov    -0x78(%rbp),%eax
and    $0xf8000000,%eax
shr    $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    $0xc,%rax
mov    %rax,-0x60(%rbp)
mov    -0x74(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x74(%rbp)
jmp    13a0 <RGB24toRGB555+0x280>
jmp    1499 <RGB24toRGB555+0x379>
cmpl   $0x0,-0x74(%rbp)
je     1503 <RGB24toRGB555+0x3e3>
mov    -0x60(%rbp),%rax
movzbl (%rax),%eax
sar    $0x3,%eax
mov    -0x60(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
and    $0xf8,%ecx
shl    $0x2,%ecx
or     %ecx,%eax
mov    -0x60(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
and    $0xf8,%ecx
shl    $0x7,%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    $0x3,%rax
mov    %rax,-0x60(%rbp)
mov    -0x74(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x74(%rbp)
jmp    1499 <RGB24toRGB555+0x379>
mov    0x38(%rbp),%ecx
imul   $0x3,0x10(%rbp),%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    12e3 <RGB24toRGB555+0x1c3>
movl   $0x0,-0x2c(%rbp)
jmp    19dc <RGB24toRGB555+0x8bc>
cmpl   $0x2,-0x50(%rbp)
jne    19d5 <RGB24toRGB555+0x8b5>
cmpl   $0x2,-0x54(%rbp)
jne    19d5 <RGB24toRGB555+0x8b5>
mov    0x20(%rbp),%rax
imul   $0x3,0x40(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    0x48(%rbp),%ecx
imul   0x38(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%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,-0x90(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    0x58(%rbp),%eax
jge    19c9 <RGB24toRGB555+0x8a9>
mov    0x40(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    0x50(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x98(%rbp),%ecx
and    $0x3,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0xd2(%rbp)
je     15fc <RGB24toRGB555+0x4dc>
cmpl   $0x0,-0x9c(%rbp)
setne  %al
mov    %al,-0xd2(%rbp)
mov    -0xd2(%rbp),%al
test   $0x1,%al
jne    160f <RGB24toRGB555+0x4ef>
jmp    16b9 <RGB24toRGB555+0x599>
mov    -0x88(%rbp),%rax
movzbl (%rax),%eax
sar    $0x3,%eax
mov    -0x88(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
and    $0xf8,%ecx
shl    $0x2,%ecx
or     %ecx,%eax
mov    -0x88(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
and    $0xf8,%ecx
shl    $0x7,%ecx
or     %ecx,%eax
mov    %ax,-0x9e(%rbp)
mov    -0x9e(%rbp),%cx
mov    -0x90(%rbp),%rax
mov    %cx,(%rax)
mov    -0x9e(%rbp),%cx
mov    -0x90(%rbp),%rax
mov    %cx,0x2(%rax)
mov    -0x90(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x90(%rbp)
mov    -0x88(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x88(%rbp)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
mov    -0x9c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x9c(%rbp)
jmp    15d2 <RGB24toRGB555+0x4b2>
jmp    16be <RGB24toRGB555+0x59e>
cmpl   $0x4,-0x9c(%rbp)
jl     1875 <RGB24toRGB555+0x755>
mov    -0x88(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x88(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa4(%rbp),%eax
and    $0xf8,%eax
shr    $0x3,%eax
mov    -0xa4(%rbp),%ecx
and    $0xf800,%ecx
shr    $0x6,%ecx
or     %ecx,%eax
mov    -0xa4(%rbp),%ecx
and    $0xf80000,%ecx
shr    $0x9,%ecx
or     %ecx,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%ecx
mov    -0xac(%rbp),%eax
shl    $0x10,%eax
or     %eax,%ecx
mov    -0x90(%rbp),%rax
mov    %ecx,(%rax)
mov    -0xa4(%rbp),%eax
and    $0xf8000000,%eax
shr    $0xb,%eax
mov    -0xa8(%rbp),%ecx
and    $0xf8,%ecx
shl    $0x12,%ecx
or     %ecx,%eax
mov    -0xa8(%rbp),%ecx
and    $0xf800,%ecx
shl    $0xf,%ecx
or     %ecx,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%ecx
mov    -0xac(%rbp),%eax
shr    $0x10,%eax
or     %eax,%ecx
mov    -0x90(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x88(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa8(%rbp),%eax
and    $0xf80000,%eax
shr    $0x13,%eax
mov    -0xa8(%rbp),%ecx
and    $0xf8000000,%ecx
shr    $0x16,%ecx
or     %ecx,%eax
mov    -0xa4(%rbp),%ecx
and    $0xf8,%ecx
shl    $0x7,%ecx
or     %ecx,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%ecx
mov    -0xac(%rbp),%eax
shl    $0x10,%eax
or     %eax,%ecx
mov    -0x90(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0xa4(%rbp),%eax
and    $0xf800,%eax
shl    $0x5,%eax
mov    -0xa4(%rbp),%ecx
and    $0xf80000,%ecx
shl    $0x2,%ecx
or     %ecx,%eax
mov    -0xa4(%rbp),%ecx
and    $0xf8000000,%ecx
shr    $0x1,%ecx
or     %ecx,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%ecx
mov    -0xac(%rbp),%eax
shr    $0x10,%eax
or     %eax,%ecx
mov    -0x90(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x90(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x90(%rbp)
mov    -0x88(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x88(%rbp)
mov    -0x9c(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x9c(%rbp)
jmp    16be <RGB24toRGB555+0x59e>
jmp    187a <RGB24toRGB555+0x75a>
cmpl   $0x0,-0x9c(%rbp)
je     1922 <RGB24toRGB555+0x802>
mov    -0x88(%rbp),%rax
movzbl (%rax),%eax
sar    $0x3,%eax
mov    -0x88(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
and    $0xf8,%ecx
shl    $0x2,%ecx
or     %ecx,%eax
mov    -0x88(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
and    $0xf8,%ecx
shl    $0x7,%ecx
or     %ecx,%eax
mov    %ax,-0xae(%rbp)
mov    -0xae(%rbp),%cx
mov    -0x90(%rbp),%rax
mov    %cx,(%rax)
mov    -0xae(%rbp),%cx
mov    -0x90(%rbp),%rax
mov    %cx,0x2(%rax)
mov    -0x90(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x90(%rbp)
mov    -0x88(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x88(%rbp)
mov    -0x9c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x9c(%rbp)
jmp    187a <RGB24toRGB555+0x75a>
imul   $0x3,0x50(%rbp),%ecx
mov    -0x88(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    0x50(%rbp),%ecx
shl    $0x1,%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    -0x90(%rbp),%rdi
movslq -0x44(%rbp),%rax
add    %rax,%rdi
mov    -0x90(%rbp),%rsi
mov    0x50(%rbp),%edx
shl    $0x1,%edx
shl    $0x1,%edx
call   1040 <memcpy@plt>
mov    0x38(%rbp),%ecx
mov    -0x88(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x44(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x90(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    15b1 <RGB24toRGB555+0x491>
movl   $0x0,-0x2c(%rbp)
jmp    19dc <RGB24toRGB555+0x8bc>
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):
<RGB24toRGB555>:
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     212d <RGB24toRGB555+0x100d>
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,%rsi
jne    1958 <RGB24toRGB555+0x838>
cmp    $0x1,%ecx
jne    1958 <RGB24toRGB555+0x838>
mov    0x98(%rsp),%edi
test   %edi,%edi
jle    212b <RGB24toRGB555+0x100b>
mov    0x18(%rsp),%eax
add    %eax,%eax
cltq
add    %rax,%r13
mov    0x10(%rsp),%eax
imul   %r15d,%eax
movslq %eax,%r14
add    %r13,%r14
mov    0xc0(%rsp),%ebx
lea    (%rbx,%rbx,2),%eax
cltq
add    %rax,%rbp
mov    0xc8(%rsp),%eax
imul   %esi,%eax
movslq %eax,%r9
add    %rbp,%r9
test   $0x3,%bl
setne  %al
mov    0x90(%rsp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
setb   %r12b
and    %al,%r12b
lea    (%rcx,%rcx,2),%eax
sub    %eax,%esi
movslq %esi,%r10
sub    %ecx,%r15d
sub    %ecx,%r15d
movslq %r15d,%r13
lea    0x1(%rbx),%eax
test   $0x3,%al
setne  %al
mov    %edx,0x10(%rsp)
test   %edx,%edx
setne  %r15b
and    %al,%r15b
lea    0x2(%rbx),%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,%ebx
test   $0x3,%bl
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    %ebp,%ebp
movdqa 0x1d37(%rip),%xmm0
movdqa 0x1d6f(%rip),%xmm7
movdqa 0x1da6(%rip),%xmm11
pxor   %xmm10,%xmm10
movdqa 0x1da9(%rip),%xmm4
movdqa 0x1db0(%rip),%xmm15
movdqa 0x1db7(%rip),%xmm8
movdqa 0x1dbe(%rip),%xmm9
movdqa 0x1dc5(%rip),%xmm14
xor    %eax,%eax
jmp    1337 <RGB24toRGB555+0x217>
nop
mov    %rcx,%r14
mov    %r8,%r9
add    %r13,%r14
add    %r10,%r9
add    $0x1,%eax
cmp    %edi,%eax
je     212b <RGB24toRGB555+0x100b>
test   %r12b,%r12b
je     1410 <RGB24toRGB555+0x2f0>
movzbl (%r9),%ecx
shr    $0x3,%ecx
movzbl 0x1(%r9),%esi
and    $0xfffffff8,%esi
lea    (%rcx,%rsi,4),%ecx
movzbl 0x2(%r9),%esi
and    $0xfffffff8,%esi
shl    $0x7,%esi
or     %ecx,%esi
mov    %si,(%r14)
test   %r15b,%r15b
je     1540 <RGB24toRGB555+0x420>
movzbl 0x3(%r9),%ecx
shr    $0x3,%ecx
movzbl 0x4(%r9),%esi
and    $0xfffffff8,%esi
lea    (%rcx,%rsi,4),%ecx
movzbl 0x5(%r9),%esi
and    $0xfffffff8,%esi
shl    $0x7,%esi
or     %ecx,%esi
mov    %si,0x2(%r14)
cmpb   $0x0,0x18(%rsp)
je     1551 <RGB24toRGB555+0x431>
movzbl 0x6(%r9),%ecx
shr    $0x3,%ecx
movzbl 0x7(%r9),%esi
and    $0xfffffff8,%esi
lea    (%rcx,%rsi,4),%ecx
movzbl 0x8(%r9),%esi
and    $0xfffffff8,%esi
shl    $0x7,%esi
or     %ecx,%esi
mov    %si,0x4(%r14)
cmpb   $0x0,0x30(%rsp)
je     1734 <RGB24toRGB555+0x614>
movzbl 0x9(%r9),%ecx
shr    $0x3,%ecx
movzbl 0xa(%r9),%esi
and    $0xfffffff8,%esi
lea    (%rcx,%rsi,4),%ecx
movzbl 0xb(%r9),%esi
and    $0xfffffff8,%esi
shl    $0x7,%esi
or     %ecx,%esi
mov    %si,0x6(%r14)
add    $0x8,%r14
add    $0xc,%r9
mov    0x20(%rsp),%ecx
jmp    1740 <RGB24toRGB555+0x620>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x90(%rsp),%r11d
cmp    $0x4,%r11d
jl     174d <RGB24toRGB555+0x62d>
mov    %r10,%rdx
mov    %r11d,%r10d
sub    $0x7,%r10d
cmovb  %ebp,%r10d
add    $0x3,%r10d
cmp    $0xc,%r10d
jb     146f <RGB24toRGB555+0x34f>
mov    %r11d,%ecx
sub    $0x7,%ecx
cmovb  %ebp,%ecx
add    $0x3,%ecx
shr    $0x2,%ecx
lea    (%rcx,%rcx,2),%rsi
lea    (%r9,%rsi,4),%rsi
add    $0xc,%rsi
cmp    %rsi,%r14
jae    1562 <RGB24toRGB555+0x442>
lea    (%r14,%rcx,8),%rcx
add    $0x8,%rcx
cmp    %rcx,%r9
jae    1562 <RGB24toRGB555+0x442>
mov    %r9,%r8
mov    %r14,%rcx
mov    %rdx,%r10
nopl   0x0(%rax,%rax,1)
mov    %r11d,%esi
mov    (%r8),%edi
mov    0x4(%r8),%ebp
mov    %edi,%edx
shr    $0x3,%edx
and    $0x1f,%edx
mov    %edi,%ebx
shr    $0x6,%ebx
and    $0x3e0,%ebx
or     %edx,%ebx
mov    %edi,%edx
shr    $0x9,%edx
and    $0x7c00,%edx
or     %ebx,%edx
shr    $0xb,%edi
and    $0x1f0000,%edi
or     %edx,%edi
mov    %ebp,%edx
shl    $0x12,%edx
and    $0x3e00000,%edx
or     %edi,%edx
mov    %ebp,%edi
shl    $0xf,%edi
and    $0x7c000000,%edi
or     %edx,%edi
mov    %edi,(%rcx)
mov    0x8(%r8),%ebx
mov    %ebp,%edx
shr    $0x13,%edx
and    $0x1f,%edx
shr    $0x16,%ebp
and    $0xffffffe0,%ebp
or     %edx,%ebp
mov    %ebx,%edx
shl    $0x7,%edx
and    $0x7c00,%edx
or     %ebp,%edx
mov    %ebx,%edi
shl    $0x5,%edi
and    $0x1f0000,%edi
or     %edx,%edi
mov    %ebx,%edx
and    $0xf80000,%edx
lea    (%rdi,%rdx,4),%edx
shr    %ebx
and    $0x7c000000,%ebx
or     %edx,%ebx
mov    %ebx,0x4(%rcx)
add    $0x8,%rcx
add    $0xc,%r8
lea    -0x4(%rsi),%r11d
cmp    $0x7,%esi
ja     1480 <RGB24toRGB555+0x360>
mov    0x98(%rsp),%edi
xor    %ebp,%ebp
jmp    1753 <RGB24toRGB555+0x633>
nopl   0x0(%rax)
add    $0x2,%r14
add    $0x3,%r9
mov    0x10(%rsp),%ecx
jmp    1740 <RGB24toRGB555+0x620>
add    $0x4,%r14
add    $0x6,%r9
mov    0x14(%rsp),%ecx
jmp    1740 <RGB24toRGB555+0x620>
movdqa %xmm11,%xmm8
shr    $0x2,%r10d
add    $0x1,%r10d
mov    %r10d,%ebp
and    $0xfffffffc,%ebp
lea    0x0(,%rbp,2),%rcx
add    %rbp,%rcx
lea    (%r9,%rcx,4),%r8
lea    (%r14,%rbp,8),%rcx
lea    0x0(,%rbp,4),%esi
sub    %esi,%r11d
xor    %ebx,%ebx
movdqa %xmm7,%xmm11
movdqa 0x1a9e(%rip),%xmm9
movdqa 0x1a86(%rip),%xmm3
movdqa 0x1a6e(%rip),%xmm4
movdqa %xmm0,%xmm15
movdqa 0x1a41(%rip),%xmm7
nop
movdqu (%r9),%xmm12
movdqu 0x10(%r9),%xmm0
movups 0x20(%r9),%xmm1
movaps %xmm1,%xmm2
pshufd $0xee,%xmm12,%xmm6
pshufd $0x55,%xmm0,%xmm5
punpckldq %xmm5,%xmm6
shufps $0xc4,%xmm1,%xmm6
shufps $0xe5,%xmm0,%xmm1
movdqa %xmm12,%xmm13
shufps $0x2c,%xmm1,%xmm13
shufps $0xf6,%xmm0,%xmm2
shufps $0x1,%xmm0,%xmm12
shufps $0x28,%xmm2,%xmm12
movaps %xmm13,%xmm0
psrld  $0x3,%xmm0
pand   %xmm7,%xmm0
movaps %xmm13,%xmm1
psrld  $0x6,%xmm1
pand   %xmm15,%xmm1
por    %xmm0,%xmm1
movaps %xmm13,%xmm0
psrld  $0x9,%xmm0
pand   %xmm4,%xmm0
psrld  $0xb,%xmm13
pand   %xmm3,%xmm13
por    %xmm0,%xmm13
por    %xmm1,%xmm13
movaps %xmm12,%xmm0
pslld  $0x12,%xmm0
pand   %xmm9,%xmm0
movaps %xmm12,%xmm5
pslld  $0xf,%xmm5
pand   %xmm11,%xmm5
por    %xmm0,%xmm5
por    %xmm13,%xmm5
movaps %xmm12,%xmm0
psrld  $0x13,%xmm0
pand   %xmm7,%xmm0
psrld  $0x16,%xmm12
pand   %xmm15,%xmm12
por    %xmm0,%xmm12
movaps %xmm6,%xmm0
pslld  $0x7,%xmm0
pand   %xmm4,%xmm0
por    %xmm12,%xmm0
movaps %xmm6,%xmm1
pslld  $0x5,%xmm1
pand   %xmm3,%xmm1
movaps %xmm6,%xmm2
pslld  $0x2,%xmm2
pand   %xmm9,%xmm2
por    %xmm1,%xmm2
por    %xmm0,%xmm2
psrld  $0x1,%xmm6
pand   %xmm11,%xmm6
por    %xmm2,%xmm6
movdqa %xmm5,%xmm0
punpckldq %xmm6,%xmm0
punpckhdq %xmm6,%xmm5
movdqu %xmm5,0x10(%r14,%rbx,8)
movdqu %xmm0,(%r14,%rbx,8)
add    $0x4,%rbx
add    $0x30,%r9
cmp    %rbx,%rbp
jne    15c0 <RGB24toRGB555+0x4a0>
cmp    %r10,%rbp
mov    %rdx,%r10
mov    $0x0,%ebp
movdqa %xmm15,%xmm0
movdqa %xmm11,%xmm7
movdqa %xmm8,%xmm11
movdqa 0x198f(%rip),%xmm4
movdqa 0x1996(%rip),%xmm15
movdqa 0x199d(%rip),%xmm8
movdqa 0x19a4(%rip),%xmm9
jne    1480 <RGB24toRGB555+0x360>
jmp    1753 <RGB24toRGB555+0x633>
add    $0x6,%r14
add    $0x9,%r9
mov    0x28(%rsp),%ecx
mov    %ecx,%r11d
cmp    $0x4,%r11d
jge    1422 <RGB24toRGB555+0x302>
mov    %r14,%rcx
mov    %r9,%r8
test   %r11d,%r11d
je     1320 <RGB24toRGB555+0x200>
lea    -0x1(%r11),%ebx
cmp    $0x7,%ebx
jb     1782 <RGB24toRGB555+0x662>
lea    (%rbx,%rbx,2),%rsi
add    %r8,%rsi
add    $0x3,%rsi
cmp    %rsi,%rcx
jae    17c6 <RGB24toRGB555+0x6a6>
lea    (%rcx,%rbx,2),%rsi
add    $0x2,%rsi
cmp    %rsi,%r8
jae    17c6 <RGB24toRGB555+0x6a6>
mov    %r8,%r9
mov    %rcx,%r14
nopl   0x0(%rax,%rax,1)
movzbl (%r9),%ecx
shr    $0x3,%ecx
movzbl 0x1(%r9),%edx
and    $0xfffffff8,%edx
lea    (%rcx,%rdx,4),%ecx
movzbl 0x2(%r9),%edx
and    $0xfffffff8,%edx
shl    $0x7,%edx
or     %ecx,%edx
mov    %dx,(%r14)
add    $0x2,%r14
add    $0x3,%r9
add    $0xffffffff,%r11d
jne    1790 <RGB24toRGB555+0x670>
jmp    1326 <RGB24toRGB555+0x206>
movdqa %xmm0,%xmm13
add    $0x1,%rbx
mov    %rbx,%rbp
movabs $0x1fffffff8,%rdx
and    %rdx,%rbp
lea    0x0(,%rbp,2),%r9
add    %rbp,%r9
add    %r8,%r9
lea    (%rcx,%rbp,2),%r14
sub    %ebp,%r11d
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movdqu (%r8),%xmm1
movq   0x10(%r8),%xmm0
movdqa %xmm11,%xmm3
pandn  %xmm0,%xmm3
movdqa %xmm1,%xmm2
pand   %xmm11,%xmm2
por    %xmm3,%xmm2
punpcklbw %xmm10,%xmm2
pand   %xmm4,%xmm2
movdqa %xmm1,%xmm3
punpckhbw %xmm10,%xmm3
movdqa %xmm4,%xmm6
pandn  %xmm3,%xmm6
por    %xmm2,%xmm6
pshufd $0xd8,%xmm6,%xmm2
pshufhw $0x6c,%xmm2,%xmm2
pshufd $0x6c,%xmm2,%xmm2
pshuflw $0x6c,%xmm2,%xmm2
pshufhw $0xc6,%xmm2,%xmm6
packuswb %xmm6,%xmm6
movdqa %xmm15,%xmm2
pandn  %xmm0,%xmm2
movdqa %xmm1,%xmm5
pand   %xmm15,%xmm5
por    %xmm2,%xmm5
punpcklbw %xmm10,%xmm5
pand   %xmm8,%xmm5
movdqa %xmm8,%xmm2
pandn  %xmm3,%xmm2
por    %xmm5,%xmm2
pshuflw $0xc6,%xmm2,%xmm2
pshufhw $0xc6,%xmm2,%xmm2
pshufd $0x6c,%xmm2,%xmm2
pshuflw $0x39,%xmm2,%xmm2
pshufhw $0x39,%xmm2,%xmm2
packuswb %xmm2,%xmm2
movdqa %xmm9,%xmm5
pandn  %xmm0,%xmm5
pand   %xmm9,%xmm1
por    %xmm5,%xmm1
punpcklbw %xmm10,%xmm1
pand   %xmm14,%xmm1
movdqa %xmm14,%xmm0
pandn  %xmm3,%xmm0
por    %xmm1,%xmm0
movdqa 0x1819(%rip),%xmm1
pshufd $0x27,%xmm0,%xmm0
pshufhw $0x6c,%xmm0,%xmm0
pshufd $0x27,%xmm0,%xmm0
pshuflw $0xc6,%xmm0,%xmm0
pshufhw $0xc6,%xmm0,%xmm0
packuswb %xmm0,%xmm0
psrlw  $0x3,%xmm6
pand   0x176f(%rip),%xmm6
punpcklbw %xmm10,%xmm6
pand   %xmm1,%xmm2
punpcklbw %xmm10,%xmm2
psllw  $0x2,%xmm2
pand   %xmm1,%xmm0
punpcklbw %xmm10,%xmm0
psllw  $0x7,%xmm0
por    %xmm2,%xmm0
por    %xmm6,%xmm0
movdqu %xmm0,(%rcx,%rsi,2)
add    $0x8,%rsi
add    $0x18,%r8
cmp    %rsi,%rbp
jne    1800 <RGB24toRGB555+0x6e0>
cmp    %rbp,%rbx
mov    $0x0,%ebp
movdqa %xmm13,%xmm0
jne    1790 <RGB24toRGB555+0x670>
jmp    1326 <RGB24toRGB555+0x206>
cmp    $0x2,%edx
jne    212d <RGB24toRGB555+0x100d>
cmp    $0x2,%ecx
jne    212d <RGB24toRGB555+0x100d>
mov    0xd8(%rsp),%eax
test   %eax,%eax
jle    212b <RGB24toRGB555+0x100b>
movabs $0x1fffffff8,%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),%edi
lea    (%rdi,%rdi,2),%eax
cltq
add    %rax,%rbp
mov    0xc8(%rsp),%eax
imul   %esi,%eax
movslq %eax,%r14
add    %rbp,%r14
test   $0x3,%dil
setne  %al
mov    0xd0(%rsp),%ecx
mov    %ecx,%ebp
add    $0xffffffff,%ebp
setb   %dl
and    %al,%dl
mov    %dl,0x10(%rsp)
lea    (%rcx,%rcx,2),%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 %esi,%rax
mov    %rax,0x28(%rsp)
add    %r15d,%r15d
movslq %r15d,%rax
mov    %rax,0x20(%rsp)
lea    0x1(%rdi),%eax
test   $0x3,%al
setne  %al
mov    %ebp,0x44(%rsp)
test   %ebp,%ebp
setne  %dl
and    %al,%dl
mov    %dl,0xf(%rsp)
lea    0x2(%rdi),%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,%edi
test   $0x3,%dil
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)
movdqa 0x1593(%rip),%xmm8
movdqa 0x159a(%rip),%xmm9
movdqa 0x15a1(%rip),%xmm10
movdqa 0x15a8(%rip),%xmm11
movdqa 0x15af(%rip),%xmm12
movdqa 0x15b6(%rip),%xmm14
add    $0x4,%r8
mov    %r8,0x50(%rsp)
movdqa 0x15b4(%rip),%xmm13
pxor   %xmm7,%xmm7
movdqa 0x15b7(%rip),%xmm15
xor    %ebp,%ebp
xor    %r15d,%r15d
mov    0xd8(%rsp),%r13d
jmp    1b56 <RGB24toRGB555+0xa36>
nopl   0x0(%rax,%rax,1)
mov    %rdx,%r14
mov    %r8,%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
movdqa 0x14f3(%rip),%xmm8
movdqa 0x14fa(%rip),%xmm9
movdqa 0x1501(%rip),%xmm10
movdqa 0x1508(%rip),%xmm11
movdqa 0x150f(%rip),%xmm12
movdqa 0x1516(%rip),%xmm14
movdqa 0x151d(%rip),%xmm13
pxor   %xmm7,%xmm7
movdqa 0x1520(%rip),%xmm15
je     212b <RGB24toRGB555+0x100b>
cmpb   $0x0,0x10(%rsp)
je     1c40 <RGB24toRGB555+0xb20>
movzbl (%r14),%eax
shr    $0x3,%eax
movzbl 0x1(%r14),%ecx
and    $0xfffffff8,%ecx
lea    (%rax,%rcx,4),%eax
movzbl 0x2(%r14),%ecx
and    $0xfffffff8,%ecx
shl    $0x7,%ecx
or     %eax,%ecx
mov    %cx,(%rbx)
mov    %cx,0x2(%rbx)
cmpb   $0x0,0xf(%rsp)
je     1d90 <RGB24toRGB555+0xc70>
movzbl 0x3(%r14),%eax
shr    $0x3,%eax
movzbl 0x4(%r14),%ecx
and    $0xfffffff8,%ecx
lea    (%rax,%rcx,4),%eax
movzbl 0x5(%r14),%ecx
and    $0xfffffff8,%ecx
shl    $0x7,%ecx
or     %eax,%ecx
mov    %cx,0x4(%rbx)
mov    %cx,0x6(%rbx)
cmpb   $0x0,0xe(%rsp)
je     1f6d <RGB24toRGB555+0xe4d>
movzbl 0x6(%r14),%eax
shr    $0x3,%eax
movzbl 0x7(%r14),%ecx
and    $0xfffffff8,%ecx
lea    (%rax,%rcx,4),%eax
movzbl 0x8(%r14),%ecx
and    $0xfffffff8,%ecx
shl    $0x7,%ecx
or     %eax,%ecx
mov    %cx,0x8(%rbx)
mov    %cx,0xa(%rbx)
cmpb   $0x0,0xd(%rsp)
je     1f83 <RGB24toRGB555+0xe63>
movzbl 0x9(%r14),%eax
shr    $0x3,%eax
movzbl 0xa(%r14),%ecx
and    $0xfffffff8,%ecx
lea    (%rax,%rcx,4),%eax
movzbl 0xb(%r14),%ecx
and    $0xfffffff8,%ecx
shl    $0x7,%ecx
or     %eax,%ecx
mov    %cx,0xc(%rbx)
mov    %cx,0xe(%rbx)
add    $0x10,%rbx
add    $0xc,%r14
mov    0x38(%rsp),%eax
cmp    $0x4,%eax
jl     1fa0 <RGB24toRGB555+0xe80>
jmp    1c50 <RGB24toRGB555+0xb30>
nopw   0x0(%rax,%rax,1)
mov    0xd0(%rsp),%eax
cmp    $0x4,%eax
jl     1fa0 <RGB24toRGB555+0xe80>
mov    %eax,%esi
sub    $0x7,%esi
cmovb  %ebp,%esi
add    $0x3,%esi
cmp    $0xc,%esi
jb     1c97 <RGB24toRGB555+0xb77>
mov    %eax,%ecx
sub    $0x7,%ecx
cmovb  %ebp,%ecx
add    $0x3,%ecx
shr    $0x2,%ecx
lea    (%rcx,%rcx,2),%rdx
lea    (%r14,%rdx,4),%rdx
add    $0xc,%rdx
cmp    %rdx,%rbx
jae    1daa <RGB24toRGB555+0xc8a>
shl    $0x4,%rcx
add    %rbx,%rcx
add    $0x10,%rcx
cmp    %rcx,%r14
jae    1daa <RGB24toRGB555+0xc8a>
mov    %rbx,%r8
mov    %r14,%rdx
movdqa 0x13db(%rip),%xmm5
cs nopw 0x0(%rax,%rax,1)
nop
mov    %eax,%esi
mov    (%rdx),%ecx
mov    0x4(%rdx),%eax
mov    %ecx,%edi
shr    $0x3,%edi
and    $0x1f,%edi
mov    %ecx,%ebp
shr    $0x6,%ebp
and    $0x3e0,%ebp
or     %edi,%ebp
mov    %ecx,%ebx
shr    $0x9,%ebx
and    $0x7c00,%ebx
or     %ebp,%ebx
mov    %ebx,%edi
shl    $0x10,%edi
or     %ebx,%edi
mov    %edi,(%r8)
shr    $0xb,%ecx
and    $0x1f0000,%ecx
mov    %eax,%edi
shl    $0x12,%edi
and    $0x3e00000,%edi
or     %ecx,%edi
mov    %eax,%ecx
shl    $0xf,%ecx
and    $0x7c000000,%ecx
or     %edi,%ecx
mov    %ecx,%edi
shr    $0x10,%edi
or     %ecx,%edi
mov    %edi,0x4(%r8)
mov    0x8(%rdx),%edi
mov    %eax,%ecx
shr    $0x13,%ecx
and    $0x1f,%ecx
shr    $0x16,%eax
and    $0xffffffe0,%eax
or     %ecx,%eax
mov    %edi,%ecx
shl    $0x7,%ecx
and    $0x7c00,%ecx
or     %eax,%ecx
mov    %ecx,%eax
shl    $0x10,%eax
or     %ecx,%eax
mov    %eax,0x8(%r8)
mov    %edi,%eax
shl    $0x5,%eax
and    $0x1f0000,%eax
mov    %edi,%ecx
and    $0xf80000,%ecx
lea    (%rax,%rcx,4),%eax
shr    %edi
and    $0x7c000000,%edi
or     %eax,%edi
mov    %edi,%eax
shr    $0x10,%eax
or     %edi,%eax
mov    %eax,0xc(%r8)
add    $0x10,%r8
add    $0xc,%rdx
lea    -0x4(%rsi),%eax
cmp    $0x7,%esi
ja     1cb0 <RGB24toRGB555+0xb90>
xor    %ebp,%ebp
jmp    1fae <RGB24toRGB555+0xe8e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x4,%rbx
add    $0x3,%r14
mov    0x44(%rsp),%eax
cmp    $0x4,%eax
jl     1fa0 <RGB24toRGB555+0xe80>
jmp    1c50 <RGB24toRGB555+0xb30>
shr    $0x2,%esi
add    $0x1,%esi
mov    %esi,%ebp
and    $0xfffffffc,%ebp
lea    0x0(,%rbp,4),%ecx
sub    %ecx,%eax
mov    %rbp,%r8
shl    $0x4,%r8
add    %rbx,%r8
lea    0x0(,%rbp,2),%rdx
add    %rbp,%rdx
lea    (%r14,%rdx,4),%rdx
mov    %rbp,%rdi
nopw   0x0(%rax,%rax,1)
movdqu (%r14),%xmm2
movdqu 0x10(%r14),%xmm1
movups 0x20(%r14),%xmm3
movaps %xmm3,%xmm4
pshufd $0xee,%xmm2,%xmm0
pshufd $0x55,%xmm1,%xmm5
punpckldq %xmm5,%xmm0
shufps $0xc4,%xmm3,%xmm0
shufps $0xe5,%xmm1,%xmm3
movdqa %xmm2,%xmm5
shufps $0x2c,%xmm3,%xmm5
shufps $0xf6,%xmm1,%xmm4
shufps $0x1,%xmm1,%xmm2
shufps $0x28,%xmm4,%xmm2
movaps %xmm5,%xmm1
psrld  $0x3,%xmm1
pand   %xmm8,%xmm1
movaps %xmm5,%xmm3
psrld  $0x6,%xmm3
pand   %xmm9,%xmm3
por    %xmm1,%xmm3
movaps %xmm5,%xmm4
psrld  $0x9,%xmm4
pand   %xmm10,%xmm4
por    %xmm3,%xmm4
movdqa %xmm4,%xmm1
pslld  $0x10,%xmm1
por    %xmm4,%xmm1
psrld  $0xb,%xmm5
pand   %xmm11,%xmm5
movaps %xmm2,%xmm3
pslld  $0x12,%xmm3
pand   %xmm12,%xmm3
por    %xmm5,%xmm3
movaps %xmm2,%xmm4
pslld  $0xf,%xmm4
pand   %xmm14,%xmm4
por    %xmm3,%xmm4
movdqa %xmm4,%xmm3
psrld  $0x10,%xmm3
por    %xmm4,%xmm3
movaps %xmm2,%xmm4
psrld  $0x13,%xmm4
pand   %xmm8,%xmm4
psrld  $0x16,%xmm2
pand   %xmm9,%xmm2
por    %xmm4,%xmm2
movaps %xmm0,%xmm4
pslld  $0x7,%xmm4
pand   %xmm10,%xmm4
por    %xmm2,%xmm4
movdqa %xmm4,%xmm2
pslld  $0x10,%xmm2
por    %xmm4,%xmm2
movaps %xmm0,%xmm4
pslld  $0x5,%xmm4
pand   %xmm11,%xmm4
movaps %xmm0,%xmm5
pslld  $0x2,%xmm5
pand   %xmm12,%xmm5
por    %xmm4,%xmm5
psrld  $0x1,%xmm0
pand   %xmm14,%xmm0
por    %xmm5,%xmm0
movdqa %xmm0,%xmm4
psrld  $0x10,%xmm4
por    %xmm0,%xmm4
movdqa %xmm1,%xmm0
punpckldq %xmm3,%xmm0
movdqa %xmm2,%xmm5
punpckldq %xmm4,%xmm5
movdqa %xmm0,%xmm6
punpcklqdq %xmm5,%xmm6
movhlps %xmm0,%xmm5
punpckhdq %xmm3,%xmm1
punpckhdq %xmm4,%xmm2
movdqa %xmm1,%xmm0
punpcklqdq %xmm2,%xmm0
movhlps %xmm1,%xmm2
movups %xmm2,0x30(%rbx)
movdqu %xmm0,0x20(%rbx)
movups %xmm5,0x10(%rbx)
movdqu %xmm6,(%rbx)
add    $0x30,%r14
add    $0x40,%rbx
add    $0xfffffffffffffffc,%rdi
jne    1de0 <RGB24toRGB555+0xcc0>
cmp    %rsi,%rbp
movdqa 0x1120(%rip),%xmm5
mov    $0x0,%ebp
jne    1cb0 <RGB24toRGB555+0xb90>
jmp    1fae <RGB24toRGB555+0xe8e>
add    $0x8,%rbx
add    $0x6,%r14
mov    0x40(%rsp),%eax
cmp    $0x4,%eax
jl     1fa0 <RGB24toRGB555+0xe80>
jmp    1c50 <RGB24toRGB555+0xb30>
add    $0xc,%rbx
add    $0x9,%r14
mov    0x3c(%rsp),%eax
cmp    $0x4,%eax
jge    1c50 <RGB24toRGB555+0xb30>
nopl   0x0(%rax,%rax,1)
mov    %r14,%rdx
mov    %rbx,%r8
movdqa 0x10d2(%rip),%xmm5
test   %eax,%eax
je     1ad0 <RGB24toRGB555+0x9b0>
lea    -0x1(%rax),%esi
cmp    $0x3,%esi
jb     1fdb <RGB24toRGB555+0xebb>
lea    (%rsi,%rsi,2),%rdi
add    %rdx,%rdi
add    $0x3,%rdi
cmp    %rdi,%r8
jae    2028 <RGB24toRGB555+0xf08>
lea    (%r8,%rsi,4),%rdi
add    $0x4,%rdi
cmp    %rdi,%rdx
jae    2028 <RGB24toRGB555+0xf08>
mov    %r8,%rbx
mov    %rdx,%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%r14),%ecx
shr    $0x3,%ecx
movzbl 0x1(%r14),%edx
and    $0xfffffff8,%edx
lea    (%rcx,%rdx,4),%ecx
movzbl 0x2(%r14),%edx
and    $0xfffffff8,%edx
shl    $0x7,%edx
or     %ecx,%edx
mov    %dx,(%rbx)
mov    %dx,0x2(%rbx)
add    $0x4,%rbx
add    $0x3,%r14
add    $0xffffffff,%eax
jne    1ff0 <RGB24toRGB555+0xed0>
jmp    1ad6 <RGB24toRGB555+0x9b6>
add    $0x1,%rsi
mov    %rsi,%rdi
and    0x50(%rsp),%rdi
sub    %edi,%eax
lea    (%r8,%rdi,4),%rbx
lea    (%rdi,%rdi,2),%r14
add    %rdx,%r14
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdx),%xmm0
movss  0x8(%rdx),%xmm2
shufps $0x30,%xmm0,%xmm2
movaps %xmm0,%xmm1
shufps $0x84,%xmm2,%xmm1
punpcklbw %xmm7,%xmm0
punpckhbw %xmm7,%xmm1
movdqa %xmm13,%xmm2
pandn  %xmm1,%xmm2
pshuflw $0xec,%xmm1,%xmm3
shufps $0x1,%xmm0,%xmm1
shufps $0xe2,%xmm0,%xmm1
pshufd $0xe6,%xmm0,%xmm4
pand   %xmm13,%xmm0
por    %xmm0,%xmm2
pshufd $0xd8,%xmm2,%xmm0
pshufhw $0xe6,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshuflw $0x6c,%xmm0,%xmm0
packuswb %xmm0,%xmm0
pshuflw $0xe6,%xmm1,%xmm1
pshufhw $0xec,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pshuflw $0x39,%xmm1,%xmm1
packuswb %xmm1,%xmm1
pshuflw $0xe6,%xmm4,%xmm2
punpckldq %xmm3,%xmm2
packuswb %xmm2,%xmm2
psrlw  $0x3,%xmm0
pand   %xmm15,%xmm0
punpcklbw %xmm7,%xmm0
pand   %xmm5,%xmm1
punpcklbw %xmm7,%xmm1
psllw  $0x2,%xmm1
pand   %xmm5,%xmm2
punpcklbw %xmm7,%xmm2
psllw  $0x7,%xmm2
por    %xmm1,%xmm2
por    %xmm0,%xmm2
punpcklwd %xmm2,%xmm2
movdqu %xmm2,(%r8,%rbp,4)
add    $0x4,%rbp
add    $0xc,%rdx
cmp    %rbp,%rdi
jne    2050 <RGB24toRGB555+0xf30>
cmp    %rdi,%rsi
mov    $0x0,%ebp
jne    1ff0 <RGB24toRGB555+0xed0>
jmp    1ad6 <RGB24toRGB555+0x9b6>
xor    %eax,%eax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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