#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 RGB24toRGB565(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] & 0xFC) << 3) | ((s[2] & 0xF8) << 8);
        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 & 0xFC00) >> 5) |
                             ((a & 0xF80000) >> 8) | ((a & 0xF8000000) >> 11) |
                             ((b & 0xFC) << 19) | ((b & 0xF800) << 16);
        a = *(unsigned int *)(s + 8);
        *(unsigned int *)(d + 4) = ((b & 0xF80000) >> 19) |
                                   ((b & 0xFC000000) >> 21) |
                                   ((a & 0xF8) << 8) | ((a & 0xF800) << 5) |
                                   ((a & 0xFC0000) << 3) | (a & 0xF8000000);
        d += 2 * 4;
        s += 3 * 4;
        ddx -= 4;
      }
      while (ddx) {
        *(unsigned short *)d =
            (s[0] >> 3) | ((s[1] & 0xFC) << 3) | ((s[2] & 0xF8) << 8);
        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] & 0xFC) << 3) | ((s[2] & 0xF8) << 8);
        *(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 & 0xFC00) >> 5) | ((a & 0xF80000) >> 8);
        *(unsigned int *)d = c | (c << 16);
        c = ((a & 0xF8000000) >> 11) | ((b & 0xFC) << 19) |
            ((b & 0xF800) << 16);
        *(unsigned int *)(d + 2 * 2) = c | (c >> 16);
        a = *(unsigned int *)(s + 8);
        c = ((b & 0xF80000) >> 19) | ((b & 0xFC000000) >> 21) |
            ((a & 0xF8) << 8);
        *(unsigned int *)(d + 2 * 2 * 2) = c | (c << 16);
        c = ((a & 0xF800) << 5) | ((a & 0xFC0000) << 3) | (a & 0xF8000000);
        *(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] & 0xFC) << 3) | ((s[2] & 0xF8) << 8);
        *(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):
<RGB24toRGB565>:
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 <RGB24toRGB565+0x11a>
movl   $0xffffffff,-0x2c(%rbp)
jmp    19d6 <RGB24toRGB565+0x8b6>
cmpl   $0x0,0x38(%rbp)
jge    1261 <RGB24toRGB565+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 <RGB24toRGB565+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    154a <RGB24toRGB565+0x42a>
cmpl   $0x1,-0x54(%rbp)
jne    154a <RGB24toRGB565+0x42a>
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    153e <RGB24toRGB565+0x41e>
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 <RGB24toRGB565+0x1ff>
cmpl   $0x0,-0x74(%rbp)
setne  %al
mov    %al,-0xd1(%rbp)
mov    -0xd1(%rbp),%al
test   $0x1,%al
jne    1332 <RGB24toRGB565+0x212>
jmp    139b <RGB24toRGB565+0x27b>
mov    -0x60(%rbp),%rax
movzbl (%rax),%eax
sar    $0x3,%eax
mov    -0x60(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
and    $0xfc,%ecx
shl    $0x3,%ecx
or     %ecx,%eax
mov    -0x60(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
and    $0xf8,%ecx
shl    $0x8,%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 <RGB24toRGB565+0x1db>
jmp    13a0 <RGB24toRGB565+0x280>
cmpl   $0x4,-0x74(%rbp)
jl     1491 <RGB24toRGB565+0x371>
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    $0xfc00,%eax
shr    $0x5,%eax
or     %eax,%ecx
mov    -0x78(%rbp),%eax
and    $0xf80000,%eax
shr    $0x8,%eax
or     %eax,%ecx
mov    -0x78(%rbp),%eax
and    $0xf8000000,%eax
shr    $0xb,%eax
or     %eax,%ecx
mov    -0x7c(%rbp),%eax
and    $0xfc,%eax
shl    $0x13,%eax
or     %eax,%ecx
mov    -0x7c(%rbp),%eax
and    $0xf800,%eax
shl    $0x10,%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    $0xfc000000,%eax
shr    $0x15,%eax
or     %eax,%ecx
mov    -0x78(%rbp),%eax
and    $0xf8,%eax
shl    $0x8,%eax
or     %eax,%ecx
mov    -0x78(%rbp),%eax
and    $0xf800,%eax
shl    $0x5,%eax
or     %eax,%ecx
mov    -0x78(%rbp),%eax
and    $0xfc0000,%eax
shl    $0x3,%eax
or     %eax,%ecx
mov    -0x78(%rbp),%eax
and    $0xf8000000,%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 <RGB24toRGB565+0x280>
jmp    1496 <RGB24toRGB565+0x376>
cmpl   $0x0,-0x74(%rbp)
je     1500 <RGB24toRGB565+0x3e0>
mov    -0x60(%rbp),%rax
movzbl (%rax),%eax
sar    $0x3,%eax
mov    -0x60(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
and    $0xfc,%ecx
shl    $0x3,%ecx
or     %ecx,%eax
mov    -0x60(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
and    $0xf8,%ecx
shl    $0x8,%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    1496 <RGB24toRGB565+0x376>
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 <RGB24toRGB565+0x1c3>
movl   $0x0,-0x2c(%rbp)
jmp    19d6 <RGB24toRGB565+0x8b6>
cmpl   $0x2,-0x50(%rbp)
jne    19cf <RGB24toRGB565+0x8af>
cmpl   $0x2,-0x54(%rbp)
jne    19cf <RGB24toRGB565+0x8af>
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    19c3 <RGB24toRGB565+0x8a3>
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     15f9 <RGB24toRGB565+0x4d9>
cmpl   $0x0,-0x9c(%rbp)
setne  %al
mov    %al,-0xd2(%rbp)
mov    -0xd2(%rbp),%al
test   $0x1,%al
jne    160c <RGB24toRGB565+0x4ec>
jmp    16b6 <RGB24toRGB565+0x596>
mov    -0x88(%rbp),%rax
movzbl (%rax),%eax
sar    $0x3,%eax
mov    -0x88(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
and    $0xfc,%ecx
shl    $0x3,%ecx
or     %ecx,%eax
mov    -0x88(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
and    $0xf8,%ecx
shl    $0x8,%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    15cf <RGB24toRGB565+0x4af>
jmp    16bb <RGB24toRGB565+0x59b>
cmpl   $0x4,-0x9c(%rbp)
jl     186f <RGB24toRGB565+0x74f>
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    $0xfc00,%ecx
shr    $0x5,%ecx
or     %ecx,%eax
mov    -0xa4(%rbp),%ecx
and    $0xf80000,%ecx
shr    $0x8,%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    $0xfc,%ecx
shl    $0x13,%ecx
or     %ecx,%eax
mov    -0xa8(%rbp),%ecx
and    $0xf800,%ecx
shl    $0x10,%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    $0xfc000000,%ecx
shr    $0x15,%ecx
or     %ecx,%eax
mov    -0xa4(%rbp),%ecx
and    $0xf8,%ecx
shl    $0x8,%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    $0xfc0000,%ecx
shl    $0x3,%ecx
or     %ecx,%eax
mov    -0xa4(%rbp),%ecx
and    $0xf8000000,%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    16bb <RGB24toRGB565+0x59b>
jmp    1874 <RGB24toRGB565+0x754>
cmpl   $0x0,-0x9c(%rbp)
je     191c <RGB24toRGB565+0x7fc>
mov    -0x88(%rbp),%rax
movzbl (%rax),%eax
sar    $0x3,%eax
mov    -0x88(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
and    $0xfc,%ecx
shl    $0x3,%ecx
or     %ecx,%eax
mov    -0x88(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
and    $0xf8,%ecx
shl    $0x8,%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    1874 <RGB24toRGB565+0x754>
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    15ae <RGB24toRGB565+0x48e>
movl   $0x0,-0x2c(%rbp)
jmp    19d6 <RGB24toRGB565+0x8b6>
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):
<RGB24toRGB565>:
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,0xc(%rsp)
push   %rax
push   %r11
push   %rbp
push   %r10
push   %r12
mov    0xe0(%rsp),%r12d
mov    0xc8(%rsp),%rbp
mov    0xe8(%rsp),%eax
push   %rax
push   %r12
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     2144 <RGB24toRGB565+0x1024>
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    1973 <RGB24toRGB565+0x853>
cmp    $0x1,%ecx
jne    1973 <RGB24toRGB565+0x853>
mov    0x98(%rsp),%r12d
test   %r12d,%r12d
jle    2142 <RGB24toRGB565+0x1022>
mov    0x18(%rsp),%eax
add    %eax,%eax
cltq
add    %rax,%r13
mov    0xc(%rsp),%eax
imul   %r15d,%eax
movslq %eax,%r14
add    %r13,%r14
mov    0xc0(%rsp),%edx
lea    (%rdx,%rdx,2),%eax
cltq
add    %rax,%rbp
mov    0xc8(%rsp),%eax
imul   %edi,%eax
movslq %eax,%r9
add    %rbp,%r9
test   $0x3,%dl
setne  %al
mov    0x90(%rsp),%ecx
mov    %ecx,%esi
add    $0xffffffff,%esi
setb   %r13b
and    %al,%r13b
lea    (%rcx,%rcx,2),%eax
sub    %eax,%edi
movslq %edi,%rdi
sub    %ecx,%r15d
sub    %ecx,%r15d
movslq %r15d,%rbp
lea    0x1(%rdx),%eax
test   $0x3,%al
setne  %al
mov    %esi,0x18(%rsp)
test   %esi,%esi
setne  %bl
and    %al,%bl
mov    %bl,0xc(%rsp)
lea    0x2(%rdx),%eax
test   $0x3,%al
setne  %al
mov    %ecx,%esi
add    $0xfffffffe,%esi
mov    %esi,0x30(%rsp)
setne  %bl
and    %al,%bl
mov    %bl,0x14(%rsp)
add    $0xffffffff,%edx
test   $0x3,%dl
mov    %rbp,%rdx
setne  %al
mov    %ecx,%esi
add    $0xfffffffd,%esi
mov    %esi,0x20(%rsp)
setne  %bl
and    %al,%bl
mov    %bl,0x28(%rsp)
lea    -0x4(%rcx),%eax
mov    %eax,0x10(%rsp)
xor    %ebp,%ebp
movdqa 0x1d20(%rip),%xmm9
movdqa 0x1d27(%rip),%xmm12
movdqa 0x1d2f(%rip),%xmm0
movdqa 0x1da6(%rip),%xmm10
pxor   %xmm7,%xmm7
movdqa 0x1da9(%rip),%xmm14
movdqa 0x1db0(%rip),%xmm15
movdqa 0x1db7(%rip),%xmm8
movdqa 0x1dce(%rip),%xmm11
movdqa 0x1dd6(%rip),%xmm1
xor    %r15d,%r15d
jmp    1349 <RGB24toRGB565+0x229>
nop
mov    %rcx,%r14
mov    %r8,%r9
add    %rdx,%r14
add    %rdi,%r9
add    $0x1,%r15d
cmp    %r12d,%r15d
je     2142 <RGB24toRGB565+0x1022>
test   %r13b,%r13b
je     1420 <RGB24toRGB565+0x300>
movzbl (%r9),%ecx
shr    $0x3,%ecx
movzbl 0x1(%r9),%esi
and    $0xfffffffc,%esi
lea    (%rcx,%rsi,8),%ecx
movzbl 0x2(%r9),%esi
and    $0xfffffff8,%esi
shl    $0x8,%esi
or     %ecx,%esi
mov    %si,(%r14)
cmpb   $0x0,0xc(%rsp)
je     1550 <RGB24toRGB565+0x430>
movzbl 0x3(%r9),%ecx
shr    $0x3,%ecx
movzbl 0x4(%r9),%esi
and    $0xfffffffc,%esi
lea    (%rcx,%rsi,8),%ecx
movzbl 0x5(%r9),%esi
and    $0xfffffff8,%esi
shl    $0x8,%esi
or     %ecx,%esi
mov    %si,0x2(%r14)
cmpb   $0x0,0x14(%rsp)
je     1561 <RGB24toRGB565+0x441>
movzbl 0x6(%r9),%ecx
shr    $0x3,%ecx
movzbl 0x7(%r9),%esi
and    $0xfffffffc,%esi
lea    (%rcx,%rsi,8),%ecx
movzbl 0x8(%r9),%esi
and    $0xfffffff8,%esi
shl    $0x8,%esi
or     %ecx,%esi
mov    %si,0x4(%r14)
cmpb   $0x0,0x28(%rsp)
je     1734 <RGB24toRGB565+0x614>
movzbl 0x9(%r9),%ecx
shr    $0x3,%ecx
movzbl 0xa(%r9),%esi
and    $0xfffffffc,%esi
lea    (%rcx,%rsi,8),%ecx
movzbl 0xb(%r9),%esi
and    $0xfffffff8,%esi
shl    $0x8,%esi
or     %ecx,%esi
mov    %si,0x6(%r14)
add    $0x8,%r14
add    $0xc,%r9
mov    0x10(%rsp),%eax
jmp    1740 <RGB24toRGB565+0x620>
cs nopw 0x0(%rax,%rax,1)
mov    0x90(%rsp),%r11d
cmp    $0x4,%r11d
jl     174d <RGB24toRGB565+0x62d>
mov    %r11d,%r10d
sub    $0x7,%r10d
cmovb  %ebp,%r10d
add    $0x3,%r10d
cmp    $0xc,%r10d
jb     147c <RGB24toRGB565+0x35c>
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    1572 <RGB24toRGB565+0x452>
lea    (%r14,%rcx,8),%rcx
add    $0x8,%rcx
cmp    %rcx,%r9
jae    1572 <RGB24toRGB565+0x452>
mov    %r9,%r8
mov    %r14,%rcx
mov    %rdx,%r10
mov    %rdi,%r9
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    $0x5,%ebx
and    $0x7e0,%ebx
or     %edx,%ebx
mov    %edi,%edx
shr    $0x8,%edx
and    $0xf800,%edx
or     %ebx,%edx
shr    $0xb,%edi
and    $0x1f0000,%edi
or     %edx,%edi
mov    %ebp,%edx
shl    $0x13,%edx
and    $0x7e00000,%edx
or     %edi,%edx
mov    %ebp,%edi
shl    $0x10,%edi
and    $0xf8000000,%edi
or     %edx,%edi
mov    %edi,(%rcx)
mov    0x8(%r8),%ebx
mov    %ebp,%edx
shr    $0x13,%edx
and    $0x1f,%edx
shr    $0x15,%ebp
and    $0xffffffe0,%ebp
or     %edx,%ebp
mov    %ebx,%edx
shl    $0x8,%edx
and    $0xf800,%edx
mov    %ebx,%edi
shl    $0x5,%edi
and    $0x1f0000,%edi
mov    %ebx,%eax
and    $0xfc0000,%eax
and    $0xf8000000,%ebx
or     %ebp,%ebx
or     %edx,%ebx
or     %edi,%ebx
lea    (%rbx,%rax,8),%eax
mov    %eax,0x4(%rcx)
add    $0x8,%rcx
add    $0xc,%r8
lea    -0x4(%rsi),%r11d
cmp    $0x7,%esi
ja     1490 <RGB24toRGB565+0x370>
mov    0x98(%rsp),%r12d
mov    %r9,%rdi
xor    %ebp,%ebp
mov    %r10,%rdx
jmp    1753 <RGB24toRGB565+0x633>
add    $0x2,%r14
add    $0x3,%r9
mov    0x18(%rsp),%eax
jmp    1740 <RGB24toRGB565+0x620>
add    $0x4,%r14
add    $0x6,%r9
mov    0x30(%rsp),%eax
jmp    1740 <RGB24toRGB565+0x620>
movdqa %xmm10,%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 0x1aa4(%rip),%xmm6
movdqa 0x1a8c(%rip),%xmm3
movdqa 0x1a74(%rip),%xmm4
movdqa %xmm0,%xmm15
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu (%r9),%xmm13
movdqu 0x10(%r9),%xmm0
movups 0x20(%r9),%xmm1
movaps %xmm1,%xmm2
pshufd $0xee,%xmm13,%xmm14
pshufd $0x55,%xmm0,%xmm5
punpckldq %xmm5,%xmm14
shufps $0xc4,%xmm1,%xmm14
shufps $0xe5,%xmm0,%xmm1
movdqa %xmm13,%xmm5
shufps $0x2c,%xmm1,%xmm5
shufps $0xf6,%xmm0,%xmm2
shufps $0x1,%xmm0,%xmm13
shufps $0x28,%xmm2,%xmm13
movaps %xmm5,%xmm0
psrld  $0x3,%xmm0
pand   %xmm9,%xmm0
movaps %xmm5,%xmm1
psrld  $0x5,%xmm1
pand   %xmm12,%xmm1
por    %xmm0,%xmm1
movaps %xmm5,%xmm0
psrld  $0x8,%xmm0
pand   %xmm15,%xmm0
psrld  $0xb,%xmm5
pand   %xmm4,%xmm5
por    %xmm0,%xmm5
por    %xmm1,%xmm5
movaps %xmm13,%xmm1
pslld  $0x13,%xmm1
pand   %xmm3,%xmm1
movaps %xmm13,%xmm0
pslld  $0x10,%xmm0
pand   %xmm6,%xmm0
por    %xmm1,%xmm0
por    %xmm5,%xmm0
movaps %xmm13,%xmm1
psrld  $0x13,%xmm1
pand   %xmm9,%xmm1
psrld  $0x15,%xmm13
pand   %xmm12,%xmm13
por    %xmm1,%xmm13
movaps %xmm14,%xmm1
pslld  $0x8,%xmm1
pand   %xmm15,%xmm1
movaps %xmm14,%xmm2
pslld  $0x5,%xmm2
pand   %xmm4,%xmm2
por    %xmm1,%xmm2
movaps %xmm14,%xmm1
pslld  $0x3,%xmm1
pand   %xmm3,%xmm1
andps  %xmm6,%xmm14
orps   %xmm13,%xmm14
orps   %xmm2,%xmm14
orps   %xmm1,%xmm14
movdqa %xmm0,%xmm1
punpckldq %xmm14,%xmm1
punpckhdq %xmm14,%xmm0
movdqu %xmm0,0x10(%r14,%rbx,8)
movdqu %xmm1,(%r14,%rbx,8)
add    $0x4,%rbx
add    $0x30,%r9
cmp    %rbx,%rbp
jne    15d0 <RGB24toRGB565+0x4b0>
cmp    %r10,%rbp
mov    $0x0,%ebp
movdqa %xmm15,%xmm0
movdqa %xmm8,%xmm10
movdqa 0x199e(%rip),%xmm14
movdqa 0x19a5(%rip),%xmm15
movdqa 0x19ac(%rip),%xmm8
movdqa 0x19d4(%rip),%xmm1
jne    1482 <RGB24toRGB565+0x362>
jmp    1753 <RGB24toRGB565+0x633>
add    $0x6,%r14
add    $0x9,%r9
mov    0x20(%rsp),%eax
mov    %eax,%r11d
cmp    $0x4,%r11d
jge    1432 <RGB24toRGB565+0x312>
mov    %r14,%rcx
mov    %r9,%r8
test   %r11d,%r11d
je     1330 <RGB24toRGB565+0x210>
lea    -0x1(%r11),%ebx
cmp    $0x7,%ebx
jb     1782 <RGB24toRGB565+0x662>
lea    (%rbx,%rbx,2),%rsi
add    %r8,%rsi
add    $0x3,%rsi
cmp    %rsi,%rcx
jae    17c6 <RGB24toRGB565+0x6a6>
lea    (%rcx,%rbx,2),%rsi
add    $0x2,%rsi
cmp    %rsi,%r8
jae    17c6 <RGB24toRGB565+0x6a6>
mov    %r8,%r9
mov    %rcx,%r14
nopl   0x0(%rax,%rax,1)
movzbl (%r9),%eax
shr    $0x3,%eax
movzbl 0x1(%r9),%ecx
and    $0xfffffffc,%ecx
lea    (%rax,%rcx,8),%eax
movzbl 0x2(%r9),%ecx
and    $0xfffffff8,%ecx
shl    $0x8,%ecx
or     %eax,%ecx
mov    %cx,(%r14)
add    $0x2,%r14
add    $0x3,%r9
add    $0xffffffff,%r11d
jne    1790 <RGB24toRGB565+0x670>
jmp    1336 <RGB24toRGB565+0x216>
movdqa %xmm9,%xmm13
add    $0x1,%rbx
mov    %rbx,%rbp
movabs $0x1fffffff8,%rax
and    %rax,%rbp
lea    0x0(,%rbp,2),%r9
add    %rbp,%r9
add    %r8,%r9
lea    (%rcx,%rbp,2),%r14
sub    %ebp,%r11d
xor    %esi,%esi
movdqa %xmm1,%xmm9
movdqa 0x18dd(%rip),%xmm4
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu (%r8),%xmm1
movq   0x10(%r8),%xmm0
movdqa %xmm10,%xmm3
pandn  %xmm0,%xmm3
movdqa %xmm1,%xmm2
pand   %xmm10,%xmm2
por    %xmm3,%xmm2
punpcklbw %xmm7,%xmm2
pand   %xmm14,%xmm2
movdqa %xmm1,%xmm3
punpckhbw %xmm7,%xmm3
movdqa %xmm14,%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 %xmm7,%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
pand   %xmm9,%xmm2
movdqa %xmm4,%xmm5
pandn  %xmm0,%xmm5
pand   %xmm4,%xmm1
por    %xmm5,%xmm1
punpcklbw %xmm7,%xmm1
pand   %xmm11,%xmm1
movdqa %xmm11,%xmm0
pandn  %xmm3,%xmm0
por    %xmm1,%xmm0
pshufd $0x27,%xmm0,%xmm0
pshufhw $0x6c,%xmm0,%xmm0
pshufd $0x27,%xmm0,%xmm0
pshuflw $0xc6,%xmm0,%xmm0
pshufhw $0xc6,%xmm0,%xmm0
packuswb %xmm0,%xmm0
pand   0x180b(%rip),%xmm0
psrlw  $0x3,%xmm6
pand   0x175e(%rip),%xmm6
punpcklbw %xmm7,%xmm6
punpcklbw %xmm7,%xmm2
psllw  $0x3,%xmm2
por    %xmm6,%xmm2
pxor   %xmm1,%xmm1
punpcklbw %xmm0,%xmm1
por    %xmm2,%xmm1
movdqu %xmm1,(%rcx,%rsi,2)
add    $0x8,%rsi
add    $0x18,%r8
cmp    %rsi,%rbp
jne    1810 <RGB24toRGB565+0x6f0>
cmp    %rbp,%rbx
mov    $0x0,%ebp
movdqa 0x16ba(%rip),%xmm12
movdqa 0x16c2(%rip),%xmm0
movdqa %xmm9,%xmm1
movdqa %xmm13,%xmm9
jne    1790 <RGB24toRGB565+0x670>
jmp    1336 <RGB24toRGB565+0x216>
cmp    $0x2,%edx
jne    2144 <RGB24toRGB565+0x1024>
cmp    $0x2,%ecx
jne    2144 <RGB24toRGB565+0x1024>
mov    0xd8(%rsp),%eax
test   %eax,%eax
jle    2142 <RGB24toRGB565+0x1022>
movabs $0x1fffffff8,%r8
mov    0x18(%rsp),%eax
add    %eax,%eax
cltq
add    %rax,%r13
mov    0xc(%rsp),%eax
imul   %r15d,%eax
movslq %eax,%rbx
add    %r13,%rbx
mov    0xc0(%rsp),%esi
lea    (%rsi,%rsi,2),%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,0xc(%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 %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,0x10(%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,0xb(%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,0xa(%rsp)
lea    -0x4(%rcx),%eax
mov    %eax,0x38(%rsp)
movdqa 0x1578(%rip),%xmm8
movdqa 0x157f(%rip),%xmm9
movdqa 0x1586(%rip),%xmm10
movdqa 0x158d(%rip),%xmm11
movdqa 0x1594(%rip),%xmm12
movdqa 0x159b(%rip),%xmm14
add    $0x4,%r8
mov    %r8,0x50(%rsp)
movdqa 0x1599(%rip),%xmm13
pxor   %xmm7,%xmm7
movdqa 0x159c(%rip),%xmm15
xor    %ebp,%ebp
xor    %r15d,%r15d
mov    0xd8(%rsp),%r13d
jmp    1b76 <RGB24toRGB565+0xa56>
cs nopw 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 0x14d3(%rip),%xmm8
movdqa 0x14da(%rip),%xmm9
movdqa 0x14e1(%rip),%xmm10
movdqa 0x14e8(%rip),%xmm11
movdqa 0x14ef(%rip),%xmm12
movdqa 0x14f6(%rip),%xmm14
movdqa 0x14fd(%rip),%xmm13
pxor   %xmm7,%xmm7
movdqa 0x1500(%rip),%xmm15
je     2142 <RGB24toRGB565+0x1022>
cmpb   $0x0,0xc(%rsp)
je     1c60 <RGB24toRGB565+0xb40>
movzbl (%r14),%eax
shr    $0x3,%eax
movzbl 0x1(%r14),%ecx
and    $0xfffffffc,%ecx
lea    (%rax,%rcx,8),%eax
movzbl 0x2(%r14),%ecx
and    $0xfffffff8,%ecx
shl    $0x8,%ecx
or     %eax,%ecx
mov    %cx,(%rbx)
mov    %cx,0x2(%rbx)
cmpb   $0x0,0x10(%rsp)
je     1da0 <RGB24toRGB565+0xc80>
movzbl 0x3(%r14),%eax
shr    $0x3,%eax
movzbl 0x4(%r14),%ecx
and    $0xfffffffc,%ecx
lea    (%rax,%rcx,8),%eax
movzbl 0x5(%r14),%ecx
and    $0xfffffff8,%ecx
shl    $0x8,%ecx
or     %eax,%ecx
mov    %cx,0x4(%rbx)
mov    %cx,0x6(%rbx)
cmpb   $0x0,0xb(%rsp)
je     1f7c <RGB24toRGB565+0xe5c>
movzbl 0x6(%r14),%eax
shr    $0x3,%eax
movzbl 0x7(%r14),%ecx
and    $0xfffffffc,%ecx
lea    (%rax,%rcx,8),%eax
movzbl 0x8(%r14),%ecx
and    $0xfffffff8,%ecx
shl    $0x8,%ecx
or     %eax,%ecx
mov    %cx,0x8(%rbx)
mov    %cx,0xa(%rbx)
cmpb   $0x0,0xa(%rsp)
je     1f92 <RGB24toRGB565+0xe72>
movzbl 0x9(%r14),%eax
shr    $0x3,%eax
movzbl 0xa(%r14),%ecx
and    $0xfffffffc,%ecx
lea    (%rax,%rcx,8),%eax
movzbl 0xb(%r14),%ecx
and    $0xfffffff8,%ecx
shl    $0x8,%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     1fb0 <RGB24toRGB565+0xe90>
jmp    1c70 <RGB24toRGB565+0xb50>
nopw   0x0(%rax,%rax,1)
mov    0xd0(%rsp),%eax
cmp    $0x4,%eax
jl     1fb0 <RGB24toRGB565+0xe90>
mov    %eax,%esi
sub    $0x7,%esi
cmovb  %ebp,%esi
add    $0x3,%esi
cmp    $0xc,%esi
jb     1cb7 <RGB24toRGB565+0xb97>
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    1dba <RGB24toRGB565+0xc9a>
shl    $0x4,%rcx
add    %rbx,%rcx
add    $0x10,%rcx
cmp    %rcx,%r14
jae    1dba <RGB24toRGB565+0xc9a>
mov    %rbx,%r8
mov    %r14,%rdx
movdqa 0x13bb(%rip),%xmm5
movdqa 0x13c3(%rip),%xmm6
nopl   (%rax)
mov    %eax,%esi
mov    (%rdx),%ecx
mov    0x4(%rdx),%eax
mov    %ecx,%edi
shr    $0x3,%edi
and    $0x1f,%edi
mov    %ecx,%ebp
shr    $0x5,%ebp
and    $0x7e0,%ebp
or     %edi,%ebp
mov    %ecx,%ebx
shr    $0x8,%ebx
and    $0xf800,%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    $0x13,%edi
and    $0x7e00000,%edi
or     %ecx,%edi
mov    %eax,%ecx
shl    $0x10,%ecx
and    $0xf8000000,%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    $0x15,%eax
and    $0xffffffe0,%eax
or     %ecx,%eax
mov    %edi,%ecx
shl    $0x8,%ecx
and    $0xf800,%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    $0xfc0000,%ecx
and    $0xf8000000,%edi
lea    (%rdi,%rcx,8),%ecx
or     %eax,%ecx
mov    %ecx,%eax
shr    $0x10,%eax
or     %ecx,%eax
mov    %eax,0xc(%r8)
add    $0x10,%r8
add    $0xc,%rdx
lea    -0x4(%rsi),%eax
cmp    $0x7,%esi
ja     1cd0 <RGB24toRGB565+0xbb0>
xor    %ebp,%ebp
jmp    1fc6 <RGB24toRGB565+0xea6>
nop
add    $0x4,%rbx
add    $0x3,%r14
mov    0x44(%rsp),%eax
cmp    $0x4,%eax
jl     1fb0 <RGB24toRGB565+0xe90>
jmp    1c70 <RGB24toRGB565+0xb50>
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  $0x5,%xmm3
pand   %xmm9,%xmm3
por    %xmm1,%xmm3
movaps %xmm5,%xmm4
psrld  $0x8,%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  $0x13,%xmm3
pand   %xmm12,%xmm3
por    %xmm5,%xmm3
movaps %xmm2,%xmm4
pslld  $0x10,%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  $0x15,%xmm2
pand   %xmm9,%xmm2
por    %xmm4,%xmm2
movaps %xmm0,%xmm4
pslld  $0x8,%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  $0x3,%xmm5
pand   %xmm12,%xmm5
andps  %xmm14,%xmm0
orps   %xmm5,%xmm0
orps   %xmm4,%xmm0
movaps %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    1df0 <RGB24toRGB565+0xcd0>
cmp    %rsi,%rbp
movdqa 0x1119(%rip),%xmm5
movdqa 0x1121(%rip),%xmm6
mov    $0x0,%ebp
jne    1cd0 <RGB24toRGB565+0xbb0>
jmp    1fc6 <RGB24toRGB565+0xea6>
add    $0x8,%rbx
add    $0x6,%r14
mov    0x40(%rsp),%eax
cmp    $0x4,%eax
jl     1fb0 <RGB24toRGB565+0xe90>
jmp    1c70 <RGB24toRGB565+0xb50>
add    $0xc,%rbx
add    $0x9,%r14
mov    0x3c(%rsp),%eax
cmp    $0x4,%eax
jge    1c70 <RGB24toRGB565+0xb50>
nopw   0x0(%rax,%rax,1)
mov    %r14,%rdx
mov    %rbx,%r8
movdqa 0x10c2(%rip),%xmm5
movdqa 0x10ca(%rip),%xmm6
test   %eax,%eax
je     1af0 <RGB24toRGB565+0x9d0>
lea    -0x1(%rax),%esi
cmp    $0x3,%esi
jb     1ff3 <RGB24toRGB565+0xed3>
lea    (%rsi,%rsi,2),%rdi
add    %rdx,%rdi
add    $0x3,%rdi
cmp    %rdi,%r8
jae    2038 <RGB24toRGB565+0xf18>
lea    (%r8,%rsi,4),%rdi
add    $0x4,%rdi
cmp    %rdi,%rdx
jae    2038 <RGB24toRGB565+0xf18>
mov    %r8,%rbx
mov    %rdx,%r14
nopl   0x0(%rax)
movzbl (%r14),%ecx
shr    $0x3,%ecx
movzbl 0x1(%r14),%edx
and    $0xfffffffc,%edx
lea    (%rcx,%rdx,8),%ecx
movzbl 0x2(%r14),%edx
and    $0xfffffff8,%edx
shl    $0x8,%edx
or     %ecx,%edx
mov    %dx,(%rbx)
mov    %dx,0x2(%rbx)
add    $0x4,%rbx
add    $0x3,%r14
add    $0xffffffff,%eax
jne    2000 <RGB24toRGB565+0xee0>
jmp    1af6 <RGB24toRGB565+0x9d6>
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
pand   %xmm5,%xmm1
pshuflw $0xe6,%xmm4,%xmm2
punpckldq %xmm3,%xmm2
packuswb %xmm2,%xmm2
pand   %xmm6,%xmm2
psrlw  $0x3,%xmm0
pand   %xmm15,%xmm0
punpcklbw %xmm7,%xmm0
punpcklbw %xmm7,%xmm1
psllw  $0x3,%xmm1
pxor   %xmm3,%xmm3
punpcklbw %xmm2,%xmm3
punpcklwd %xmm0,%xmm0
punpcklwd %xmm1,%xmm1
por    %xmm0,%xmm1
punpcklwd %xmm3,%xmm3
por    %xmm1,%xmm3
movdqu %xmm3,(%r8,%rbp,4)
add    $0x4,%rbp
add    $0xc,%rdx
cmp    %rbp,%rdi
jne    2060 <RGB24toRGB565+0xf40>
cmp    %rdi,%rsi
mov    $0x0,%ebp
jne    2000 <RGB24toRGB565+0xee0>
jmp    1af6 <RGB24toRGB565+0x9d6>
xor    %eax,%eax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @RGB24toRGB565(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 %540
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 %294
99: ; preds = %96
%100 = load i32, i32* %35
%101 = icmp eq i32 %100, 1
br i1 %101, label %102, label %294
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 = %290, %102
%124 = load i32, i32* %38
%125 = load i32, i32* %25
%126 = icmp slt i32 %124, %125
br i1 %126, label %127, label %293
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, 252
%150 = shl i32 %149, 3
%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, 8
%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 %242
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, 64512
%187 = lshr i32 %186, 5
%188 = or i32 %184, %187
%189 = load i32, i32* %41
%190 = and i32 %189, 16252928
%191 = lshr i32 %190, 8
%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, 252
%199 = shl i32 %198, 19
%200 = or i32 %196, %199
%201 = load i32, i32* %42
%202 = and i32 %201, 63488
%203 = shl i32 %202, 16
%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, -67108864
%216 = lshr i32 %215, 21
%217 = or i32 %213, %216
%218 = load i32, i32* %41
%219 = and i32 %218, 248
%220 = shl i32 %219, 8
%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, 16515072
%228 = shl i32 %227, 3
%229 = or i32 %225, %228
%230 = load i32, i32* %41
%231 = and i32 %230, -134217728
%232 = or i32 %229, %231
%233 = load i8*, i8** %37
%234 = getelementptr inbounds i8, i8* %233, i64 4
%235 = bitcast i8* %234 to i32*
store i32 %232, i32* %235
%236 = load i8*, i8** %37
%237 = getelementptr inbounds i8, i8* %236, i64 8
store i8* %237, i8** %37
%238 = load i8*, i8** %36
%239 = getelementptr inbounds i8, i8* %238, i64 12
store i8* %239, i8** %36
%240 = load i32, i32* %40
%241 = sub nsw i32 %240, 4
store i32 %241, i32* %40
br label %171
242: ; preds = %171
br label %243
243: ; preds = %246, %242
%244 = load i32, i32* %40
%245 = icmp ne i32 %244, 0
br i1 %245, label %246, label %275
246: ; preds = %243
%247 = load i8*, i8** %36
%248 = getelementptr inbounds i8, i8* %247, i64 0
%249 = load i8, i8* %248
%250 = zext i8 %249 to i32
%251 = ashr i32 %250, 3
%252 = load i8*, i8** %36
%253 = getelementptr inbounds i8, i8* %252, i64 1
%254 = load i8, i8* %253
%255 = zext i8 %254 to i32
%256 = and i32 %255, 252
%257 = shl i32 %256, 3
%258 = or i32 %251, %257
%259 = load i8*, i8** %36
%260 = getelementptr inbounds i8, i8* %259, i64 2
%261 = load i8, i8* %260
%262 = zext i8 %261 to i32
%263 = and i32 %262, 248
%264 = shl i32 %263, 8
%265 = or i32 %258, %264
%266 = trunc i32 %265 to i16
%267 = load i8*, i8** %37
%268 = bitcast i8* %267 to i16*
store i16 %266, i16* %268
%269 = load i8*, i8** %37
%270 = getelementptr inbounds i8, i8* %269, i64 2
store i8* %270, i8** %37
%271 = load i8*, i8** %36
%272 = getelementptr inbounds i8, i8* %271, i64 3
store i8* %272, i8** %36
%273 = load i32, i32* %40
%274 = add nsw i32 %273, -1
store i32 %274, i32* %40
br label %243
275: ; preds = %243
%276 = load i32, i32* %29
%277 = load i32, i32* %24
%278 = mul nsw i32 %277, 3
%279 = sub nsw i32 %276, %278
%280 = load i8*, i8** %36
%281 = sext i32 %279 to i64
%282 = getelementptr inbounds i8, i8* %280, i64 %281
store i8* %282, i8** %36
%283 = load i32, i32* %21
%284 = load i32, i32* %24
%285 = mul nsw i32 %284, 2
%286 = sub nsw i32 %283, %285
%287 = load i8*, i8** %37
%288 = sext i32 %286 to i64
%289 = getelementptr inbounds i8, i8* %287, i64 %288
store i8* %289, i8** %37
br label %290
290: ; preds = %275
%291 = load i32, i32* %38
%292 = add nsw i32 %291, 1
store i32 %292, i32* %38
br label %123
293: ; preds = %123
store i32 0, i32* %17
br label %540
294: ; preds = %99, %96
%295 = load i32, i32* %34
%296 = icmp eq i32 %295, 2
br i1 %296, label %297, label %539
297: ; preds = %294
%298 = load i32, i32* %35
%299 = icmp eq i32 %298, 2
br i1 %299, label %300, label %539
300: ; preds = %297
%301 = load i8*, i8** %26
%302 = load i32, i32* %30
%303 = mul nsw i32 %302, 3
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds i8, i8* %301, i64 %304
%306 = load i32, i32* %31
%307 = load i32, i32* %29
%308 = mul nsw i32 %306, %307
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds i8, i8* %305, i64 %309
store i8* %310, i8** %43
%311 = load i8*, i8** %18
%312 = load i32, i32* %22
%313 = mul nsw i32 %312, 2
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds i8, i8* %311, i64 %314
%316 = load i32, i32* %23
%317 = load i32, i32* %21
%318 = mul nsw i32 %316, %317
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds i8, i8* %315, i64 %319
store i8* %320, i8** %44
store i32 0, i32* %45
br label %321
321: ; preds = %535, %300
%322 = load i32, i32* %45
%323 = load i32, i32* %33
%324 = icmp slt i32 %322, %323
br i1 %324, label %325, label %538
325: ; preds = %321
%326 = load i32, i32* %30
store i32 %326, i32* %46
%327 = load i32, i32* %32
store i32 %327, i32* %47
br label %328
328: ; preds = %337, %325
%329 = load i32, i32* %46
%330 = and i32 %329, 3
%331 = icmp ne i32 %330, 0
br i1 %331, label %332, label %335
332: ; preds = %328
%333 = load i32, i32* %47
%334 = icmp ne i32 %333, 0
br label %335
335: ; preds = %332, %328
%336 = phi i1 [ false, %328 ], [ %334, %332 ]
br i1 %336, label %337, label %373
337: ; preds = %335
%338 = load i8*, i8** %43
%339 = getelementptr inbounds i8, i8* %338, i64 0
%340 = load i8, i8* %339
%341 = zext i8 %340 to i32
%342 = ashr i32 %341, 3
%343 = load i8*, i8** %43
%344 = getelementptr inbounds i8, i8* %343, i64 1
%345 = load i8, i8* %344
%346 = zext i8 %345 to i32
%347 = and i32 %346, 252
%348 = shl i32 %347, 3
%349 = or i32 %342, %348
%350 = load i8*, i8** %43
%351 = getelementptr inbounds i8, i8* %350, i64 2
%352 = load i8, i8* %351
%353 = zext i8 %352 to i32
%354 = and i32 %353, 248
%355 = shl i32 %354, 8
%356 = or i32 %349, %355
%357 = trunc i32 %356 to i16
store i16 %357, i16* %48
%358 = load i16, i16* %48
%359 = load i8*, i8** %44
%360 = bitcast i8* %359 to i16*
store i16 %358, i16* %360
%361 = load i16, i16* %48
%362 = load i8*, i8** %44
%363 = getelementptr inbounds i8, i8* %362, i64 2
%364 = bitcast i8* %363 to i16*
store i16 %361, i16* %364
%365 = load i8*, i8** %44
%366 = getelementptr inbounds i8, i8* %365, i64 4
store i8* %366, i8** %44
%367 = load i8*, i8** %43
%368 = getelementptr inbounds i8, i8* %367, i64 3
store i8* %368, i8** %43
%369 = load i32, i32* %46
%370 = add nsw i32 %369, 1
store i32 %370, i32* %46
%371 = load i32, i32* %47
%372 = add nsw i32 %371, -1
store i32 %372, i32* %47
br label %328
373: ; preds = %335
br label %374
374: ; preds = %377, %373
%375 = load i32, i32* %47
%376 = icmp sge i32 %375, 4
br i1 %376, label %377, label %465
377: ; preds = %374
%378 = load i8*, i8** %43
%379 = bitcast i8* %378 to i32*
%380 = load i32, i32* %379
store i32 %380, i32* %49
%381 = load i8*, i8** %43
%382 = getelementptr inbounds i8, i8* %381, i64 4
%383 = bitcast i8* %382 to i32*
%384 = load i32, i32* %383
store i32 %384, i32* %50
%385 = load i32, i32* %49
%386 = and i32 %385, 248
%387 = lshr i32 %386, 3
%388 = load i32, i32* %49
%389 = and i32 %388, 64512
%390 = lshr i32 %389, 5
%391 = or i32 %387, %390
%392 = load i32, i32* %49
%393 = and i32 %392, 16252928
%394 = lshr i32 %393, 8
%395 = or i32 %391, %394
store i32 %395, i32* %51
%396 = load i32, i32* %51
%397 = load i32, i32* %51
%398 = shl i32 %397, 16
%399 = or i32 %396, %398
%400 = load i8*, i8** %44
%401 = bitcast i8* %400 to i32*
store i32 %399, i32* %401
%402 = load i32, i32* %49
%403 = and i32 %402, -134217728
%404 = lshr i32 %403, 11
%405 = load i32, i32* %50
%406 = and i32 %405, 252
%407 = shl i32 %406, 19
%408 = or i32 %404, %407
%409 = load i32, i32* %50
%410 = and i32 %409, 63488
%411 = shl i32 %410, 16
%412 = or i32 %408, %411
store i32 %412, i32* %51
%413 = load i32, i32* %51
%414 = load i32, i32* %51
%415 = lshr i32 %414, 16
%416 = or i32 %413, %415
%417 = load i8*, i8** %44
%418 = getelementptr inbounds i8, i8* %417, i64 4
%419 = bitcast i8* %418 to i32*
store i32 %416, i32* %419
%420 = load i8*, i8** %43
%421 = getelementptr inbounds i8, i8* %420, i64 8
%422 = bitcast i8* %421 to i32*
%423 = load i32, i32* %422
store i32 %423, i32* %49
%424 = load i32, i32* %50
%425 = and i32 %424, 16252928
%426 = lshr i32 %425, 19
%427 = load i32, i32* %50
%428 = and i32 %427, -67108864
%429 = lshr i32 %428, 21
%430 = or i32 %426, %429
%431 = load i32, i32* %49
%432 = and i32 %431, 248
%433 = shl i32 %432, 8
%434 = or i32 %430, %433
store i32 %434, i32* %51
%435 = load i32, i32* %51
%436 = load i32, i32* %51
%437 = shl i32 %436, 16
%438 = or i32 %435, %437
%439 = load i8*, i8** %44
%440 = getelementptr inbounds i8, i8* %439, i64 8
%441 = bitcast i8* %440 to i32*
store i32 %438, i32* %441
%442 = load i32, i32* %49
%443 = and i32 %442, 63488
%444 = shl i32 %443, 5
%445 = load i32, i32* %49
%446 = and i32 %445, 16515072
%447 = shl i32 %446, 3
%448 = or i32 %444, %447
%449 = load i32, i32* %49
%450 = and i32 %449, -134217728
%451 = or i32 %448, %450
store i32 %451, i32* %51
%452 = load i32, i32* %51
%453 = load i32, i32* %51
%454 = lshr i32 %453, 16
%455 = or i32 %452, %454
%456 = load i8*, i8** %44
%457 = getelementptr inbounds i8, i8* %456, i64 12
%458 = bitcast i8* %457 to i32*
store i32 %455, i32* %458
%459 = load i8*, i8** %44
%460 = getelementptr inbounds i8, i8* %459, i64 16
store i8* %460, i8** %44
%461 = load i8*, i8** %43
%462 = getelementptr inbounds i8, i8* %461, i64 12
store i8* %462, i8** %43
%463 = load i32, i32* %47
%464 = sub nsw i32 %463, 4
store i32 %464, i32* %47
br label %374
465: ; preds = %374
br label %466
466: ; preds = %469, %465
%467 = load i32, i32* %47
%468 = icmp ne i32 %467, 0
br i1 %468, label %469, label %503
469: ; preds = %466
%470 = load i8*, i8** %43
%471 = getelementptr inbounds i8, i8* %470, i64 0
%472 = load i8, i8* %471
%473 = zext i8 %472 to i32
%474 = ashr i32 %473, 3
%475 = load i8*, i8** %43
%476 = getelementptr inbounds i8, i8* %475, i64 1
%477 = load i8, i8* %476
%478 = zext i8 %477 to i32
%479 = and i32 %478, 252
%480 = shl i32 %479, 3
%481 = or i32 %474, %480
%482 = load i8*, i8** %43
%483 = getelementptr inbounds i8, i8* %482, i64 2
%484 = load i8, i8* %483
%485 = zext i8 %484 to i32
%486 = and i32 %485, 248
%487 = shl i32 %486, 8
%488 = or i32 %481, %487
%489 = trunc i32 %488 to i16
store i16 %489, i16* %52
%490 = load i16, i16* %52
%491 = load i8*, i8** %44
%492 = bitcast i8* %491 to i16*
store i16 %490, i16* %492
%493 = load i16, i16* %52
%494 = load i8*, i8** %44
%495 = getelementptr inbounds i8, i8* %494, i64 2
%496 = bitcast i8* %495 to i16*
store i16 %493, i16* %496
%497 = load i8*, i8** %44
%498 = getelementptr inbounds i8, i8* %497, i64 4
store i8* %498, i8** %44
%499 = load i8*, i8** %43
%500 = getelementptr inbounds i8, i8* %499, i64 3
store i8* %500, i8** %43
%501 = load i32, i32* %47
%502 = add nsw i32 %501, -1
store i32 %502, i32* %47
br label %466
503: ; preds = %466
%504 = load i32, i32* %32
%505 = mul nsw i32 %504, 3
%506 = load i8*, i8** %43
%507 = sext i32 %505 to i64
%508 = sub i64 0, %507
%509 = getelementptr inbounds i8, i8* %506, i64 %508
store i8* %509, i8** %43
%510 = load i32, i32* %32
%511 = mul nsw i32 %510, 2
%512 = mul nsw i32 %511, 2
%513 = load i8*, i8** %44
%514 = sext i32 %512 to i64
%515 = sub i64 0, %514
%516 = getelementptr inbounds i8, i8* %513, i64 %515
store i8* %516, i8** %44
%517 = load i8*, i8** %44
%518 = load i32, i32* %21
%519 = sext i32 %518 to i64
%520 = getelementptr inbounds i8, i8* %517, i64 %519
%521 = load i8*, i8** %44
%522 = load i32, i32* %32
%523 = mul nsw i32 %522, 2
%524 = mul nsw i32 %523, 2
%525 = call i32 @memcpy(i8* %520, i8* %521, i32 %524)
%526 = load i32, i32* %29
%527 = load i8*, i8** %43
%528 = sext i32 %526 to i64
%529 = getelementptr inbounds i8, i8* %527, i64 %528
store i8* %529, i8** %43
%530 = load i32, i32* %21
%531 = mul nsw i32 %530, 2
%532 = load i8*, i8** %44
%533 = sext i32 %531 to i64
%534 = getelementptr inbounds i8, i8* %532, i64 %533
store i8* %534, i8** %44
br label %535
535: ; preds = %503
%536 = load i32, i32* %45
%537 = add nsw i32 %536, 1
store i32 %537, i32* %45
br label %321
538: ; preds = %321
store i32 0, i32* %17
br label %540
539: ; preds = %297, %294
store i32 -1, i32* %17
br label %540
540: ; preds = %539, %538, %293, %71
%541 = load i32, i32* %17
ret i32 %541
}

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