#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 RGB565toBGR32(unsigned char *dest_ptr, int dest_width, int dest_height,
                  int dest_pitch, int dest_x, int dest_y, int dest_dx,
                  int dest_dy, unsigned char *src_ptr, int src_width,
                  int src_height, int src_pitch, int src_x, int src_y,
                  int src_dx, int src_dy) {
  int scale_x, scale_y;
  if (!chk_args(dest_ptr, dest_width, dest_height, dest_pitch, dest_x, dest_y,
                dest_dx, dest_dy, src_ptr, src_width, src_height, src_pitch,
                src_x, src_y, src_dx, src_dy, &scale_x, &scale_y))
    return -1;
  if (src_pitch < 0)
    src_ptr -= (src_height - 1) * src_pitch;
  if (dest_pitch < 0)
    dest_ptr -= (dest_height - 1) * dest_pitch;
  if (scale_x == 1 && scale_y == 1) {
    unsigned char *s, *d;
    register int i;
    s = src_ptr + src_x * 2 + src_y * src_pitch;
    d = dest_ptr + dest_x * 4 + dest_y * dest_pitch;
    for (i = 0; i < dest_dy; i++) {
      register int ddx = dest_dx;
      while (ddx) {
        register unsigned short a;
        a = *(unsigned short *)s;
        *(unsigned int *)d = (unsigned int)((a & 0x001F) << 19) |
                             ((a & 0x07E0) << 5) | ((a & 0xF800) >> 8);
        d += 4;
        s += 2;
        ddx--;
      }
      s += src_pitch - dest_dx * 2;
      d += dest_pitch - dest_dx * 4;
    }
    return 0;
  }
  if (scale_x == 2 && scale_y == 2) {
    unsigned char *s, *d;
    register int i;
    s = src_ptr + src_x * 2 + src_y * src_pitch;
    d = dest_ptr + dest_x * 4 + dest_y * dest_pitch;
    for (i = 0; i < src_dy; i++) {
      register int sdx = src_dx;
      while (sdx) {
        register unsigned short a;
        register unsigned int c;
        a = *(unsigned short *)s;
        c = ((a & 0x001F) << 19) | ((a & 0x07E0) << 5) | ((a & 0xF800) >> 8);
        *(unsigned int *)d = c;
        *(unsigned int *)(d + 4) = c;
        d += 2 * 4;
        s += 2;
        sdx--;
      }
      s -= src_dx * 2;
      d -= src_dx * 2 * 4;
      memcpy(d + dest_pitch, d, src_dx * 2 * 4);
      s += src_pitch;
      d += dest_pitch * 2;
    }
    return 0;
  }
  return -1;
}


x86 assembly (clang, -O0):
<RGB565toBGR32>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%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,-0xb8(%rbp)
mov    0x18(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    0x20(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    0x28(%rbp),%eax
mov    %eax,-0xa4(%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,-0xa0(%rbp)
mov    -0xb8(%rbp),%eax
mov    %eax,(%rsp)
mov    -0xb4(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0xb0(%rbp),%rax
mov    %rax,0x10(%rsp)
mov    -0xa4(%rbp),%eax
mov    %eax,0x18(%rsp)
mov    -0xa0(%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 <RGB565toBGR32+0x11a>
movl   $0xffffffff,-0x2c(%rbp)
jmp    1578 <RGB565toBGR32+0x458>
cmpl   $0x0,0x38(%rbp)
jge    1261 <RGB565toBGR32+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 <RGB565toBGR32+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    13aa <RGB565toBGR32+0x28a>
cmpl   $0x1,-0x54(%rbp)
jne    13aa <RGB565toBGR32+0x28a>
mov    0x20(%rbp),%rax
mov    0x40(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    0x48(%rbp),%ecx
imul   0x38(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x2,%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    139e <RGB565toBGR32+0x27e>
mov    0x10(%rbp),%eax
mov    %eax,-0x70(%rbp)
cmpl   $0x0,-0x70(%rbp)
je     135e <RGB565toBGR32+0x23e>
mov    -0x60(%rbp),%rax
mov    (%rax),%ax
mov    %ax,-0x72(%rbp)
movzwl -0x72(%rbp),%ecx
and    $0x1f,%ecx
shl    $0x13,%ecx
movzwl -0x72(%rbp),%eax
and    $0x7e0,%eax
shl    $0x5,%eax
or     %eax,%ecx
movzwl -0x72(%rbp),%eax
and    $0xf800,%eax
sar    $0x8,%eax
or     %eax,%ecx
mov    -0x68(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x68(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x68(%rbp)
mov    -0x60(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x60(%rbp)
mov    -0x70(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x70(%rbp)
jmp    12f7 <RGB565toBGR32+0x1d7>
mov    0x38(%rbp),%ecx
mov    0x10(%rbp),%eax
shl    $0x1,%eax
sub    %eax,%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x44(%rbp),%ecx
mov    0x10(%rbp),%eax
shl    $0x2,%eax
sub    %eax,%ecx
mov    -0x68(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    12e5 <RGB565toBGR32+0x1c5>
movl   $0x0,-0x2c(%rbp)
jmp    1578 <RGB565toBGR32+0x458>
cmpl   $0x2,-0x50(%rbp)
jne    1571 <RGB565toBGR32+0x451>
cmpl   $0x2,-0x54(%rbp)
jne    1571 <RGB565toBGR32+0x451>
mov    0x20(%rbp),%rax
mov    0x40(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    0x48(%rbp),%ecx
imul   0x38(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    -0x4c(%rbp),%ecx
imul   -0x44(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    0x58(%rbp),%eax
jge    1565 <RGB565toBGR32+0x445>
mov    0x50(%rbp),%eax
mov    %eax,-0x90(%rbp)
cmpl   $0x0,-0x90(%rbp)
je     14c8 <RGB565toBGR32+0x3a8>
mov    -0x80(%rbp),%rax
mov    (%rax),%ax
mov    %ax,-0x92(%rbp)
movzwl -0x92(%rbp),%eax
and    $0x1f,%eax
shl    $0x13,%eax
movzwl -0x92(%rbp),%ecx
and    $0x7e0,%ecx
shl    $0x5,%ecx
or     %ecx,%eax
movzwl -0x92(%rbp),%ecx
and    $0xf800,%ecx
sar    $0x8,%ecx
or     %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%ecx
mov    -0x88(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x98(%rbp),%ecx
mov    -0x88(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x88(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x88(%rbp)
mov    -0x80(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x80(%rbp)
mov    -0x90(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x90(%rbp)
jmp    1425 <RGB565toBGR32+0x305>
mov    0x50(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x80(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    0x50(%rbp),%ecx
shl    $0x1,%ecx
shl    $0x2,%ecx
mov    -0x88(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rdi
movslq -0x44(%rbp),%rax
add    %rax,%rdi
mov    -0x88(%rbp),%rsi
mov    0x50(%rbp),%edx
shl    $0x1,%edx
shl    $0x2,%edx
call   1040 <memcpy@plt>
mov    0x38(%rbp),%ecx
mov    -0x80(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x44(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x88(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    140d <RGB565toBGR32+0x2ed>
movl   $0x0,-0x2c(%rbp)
jmp    1578 <RGB565toBGR32+0x458>
movl   $0xffffffff,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<RGB565toBGR32>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %ecx,%r13d
mov    %edx,%ebp
mov    %rdi,%r12
mov    0xd8(%rsp),%ebx
mov    0xd0(%rsp),%r10d
mov    0xc8(%rsp),%r14d
mov    0xb0(%rsp),%r15d
lea    0x20(%rsp),%rax
lea    0x24(%rsp),%r11
mov    %r8d,0xc(%rsp)
mov    %r9d,0x10(%rsp)
push   %rax
push   %r11
push   %rbx
mov    0xd0(%rsp),%eax
push   %r10
push   %r14
mov    0xc8(%rsp),%r14
mov    0xe8(%rsp),%ebx
push   %rbx
mov    %rax,%rbx
push   %rax
push   %r15
mov    0xe8(%rsp),%eax
push   %rax
push   %r14
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     1689 <RGB565toBGR32+0x569>
add    $0xffffffff,%r15d
mov    %rbx,%rsi
imul   %esi,%r15d
movslq %r15d,%rcx
neg    %rcx
xor    %edx,%edx
test   %esi,%esi
cmovns %rdx,%rcx
add    %rcx,%r14
add    $0xffffffff,%ebp
imul   %r13d,%ebp
movslq %ebp,%rcx
neg    %rcx
test   %r13d,%r13d
cmovns %rdx,%rcx
add    %rcx,%r12
mov    0x24(%rsp),%edx
mov    0x20(%rsp),%ecx
cmp    $0x1,%edx
jne    13f2 <RGB565toBGR32+0x2d2>
cmp    $0x1,%ecx
jne    13f2 <RGB565toBGR32+0x2d2>
mov    0x98(%rsp),%eax
test   %eax,%eax
jle    1687 <RGB565toBGR32+0x567>
mov    0xc(%rsp),%eax
shl    $0x2,%eax
cltq
add    %rax,%r12
mov    0x10(%rsp),%eax
imul   %r13d,%eax
movslq %eax,%rdx
add    %r12,%rdx
mov    0xc0(%rsp),%eax
add    %eax,%eax
cltq
add    %rax,%r14
mov    0xc8(%rsp),%eax
imul   %ebx,%eax
cltq
add    %r14,%rax
mov    0x90(%rsp),%ecx
mov    %rcx,%rsi
add    %ecx,%ecx
sub    %ecx,%ebx
movslq %ebx,%r15
lea    0x0(,%rsi,4),%ecx
sub    %ecx,%r13d
movslq %r13d,%r12
lea    -0x1(%rsi),%r14d
lea    0x1(%r14),%r10
mov    %r10,%rdi
and    $0xfffffffffffffff8,%rdi
mov    %esi,%r11d
sub    %edi,%r11d
lea    0x0(,%rdi,4),%r8
lea    (%rdi,%rdi,1),%r9
xor    %r13d,%r13d
pxor   %xmm8,%xmm8
movdqa 0xd8d(%rip),%xmm9
movdqa 0xd95(%rip),%xmm2
movdqa 0xd9d(%rip),%xmm3
jmp    12e6 <RGB565toBGR32+0x1c6>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rax,%rsi
mov    %rdx,%rbp
add    %r12,%rbp
add    %r15,%rsi
add    $0x1,%r13d
mov    %rbp,%rdx
mov    %rsi,%rax
mov    0x98(%rsp),%ecx
cmp    %ecx,%r13d
je     1687 <RGB565toBGR32+0x567>
mov    0x90(%rsp),%ecx
test   %ecx,%ecx
je     12c0 <RGB565toBGR32+0x1a0>
cmp    $0x7,%r14d
jae    1310 <RGB565toBGR32+0x1f0>
mov    0x90(%rsp),%ecx
mov    %rdx,%rbp
mov    %rax,%rsi
jmp    13c0 <RGB565toBGR32+0x2a0>
nopl   0x0(%rax)
lea    (%rdx,%r8,1),%rbp
lea    (%rax,%r9,1),%rsi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movq   (%rax,%rcx,2),%xmm4
movq   0x8(%rax,%rcx,2),%xmm5
punpcklwd %xmm8,%xmm4
punpcklwd %xmm8,%xmm5
movdqa %xmm4,%xmm6
pslld  $0x13,%xmm6
movdqa %xmm5,%xmm7
pslld  $0x13,%xmm7
pand   %xmm9,%xmm6
pand   %xmm9,%xmm7
movdqa %xmm4,%xmm0
pslld  $0x5,%xmm0
movdqa %xmm5,%xmm1
pslld  $0x5,%xmm1
pand   %xmm2,%xmm0
por    %xmm6,%xmm0
pand   %xmm2,%xmm1
por    %xmm7,%xmm1
psrld  $0x8,%xmm4
psrld  $0x8,%xmm5
pand   %xmm3,%xmm4
por    %xmm0,%xmm4
pand   %xmm3,%xmm5
por    %xmm1,%xmm5
movdqu %xmm4,(%rdx,%rcx,4)
movdqu %xmm5,0x10(%rdx,%rcx,4)
add    $0x8,%rcx
cmp    %rcx,%rdi
jne    1320 <RGB565toBGR32+0x200>
mov    %r11d,%ecx
cmp    %rdi,%r10
je     12c6 <RGB565toBGR32+0x1a6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzwl (%rsi),%ebx
mov    %ebx,%edx
and    $0x1f,%edx
shl    $0x13,%edx
mov    %ebx,%eax
shl    $0x5,%eax
and    $0xfc00,%eax
or     %edx,%eax
shr    $0xb,%ebx
lea    (%rax,%rbx,8),%eax
mov    %eax,0x0(%rbp)
add    $0x4,%rbp
add    $0x2,%rsi
add    $0xffffffff,%ecx
jne    13c0 <RGB565toBGR32+0x2a0>
jmp    12c6 <RGB565toBGR32+0x1a6>
cmp    $0x2,%edx
jne    1689 <RGB565toBGR32+0x569>
cmp    $0x2,%ecx
jne    1689 <RGB565toBGR32+0x569>
mov    0xd8(%rsp),%eax
test   %eax,%eax
jle    1687 <RGB565toBGR32+0x567>
mov    0xc(%rsp),%eax
shl    $0x2,%eax
cltq
add    %rax,%r12
mov    0x10(%rsp),%eax
imul   %r13d,%eax
cltq
add    %r12,%rax
mov    0xc0(%rsp),%ecx
add    %ecx,%ecx
movslq %ecx,%rcx
add    %rcx,%r14
mov    0xc8(%rsp),%ecx
mov    %rbx,%rdi
imul   %edi,%ecx
movslq %ecx,%rcx
add    %r14,%rcx
mov    0xd0(%rsp),%edx
mov    %rdx,%rsi
add    %edx,%edx
movslq %edx,%rdx
neg    %rdx
mov    %rdx,0x10(%rsp)
lea    0x0(,%rsi,8),%edx
mov    %edx,0xc(%rsp)
movslq %edx,%rbx
neg    %rbx
movslq %r13d,%rdx
mov    %rdx,0x50(%rsp)
movslq %edi,%rdx
mov    %rdx,0x48(%rsp)
add    %r13d,%r13d
movslq %r13d,%r12
lea    -0x1(%rsi),%edx
mov    %rdx,0x40(%rsp)
add    $0x1,%rdx
movabs $0x1fffffff8,%r13
or     $0x4,%r13
mov    %rdx,0x38(%rsp)
and    %rdx,%r13
mov    %esi,%edx
sub    %r13d,%edx
mov    %edx,0x1c(%rsp)
lea    0x0(,%r13,8),%rdx
mov    %rdx,0x30(%rsp)
mov    %r13,%rdx
add    %r13,%rdx
mov    %rdx,0x28(%rsp)
xor    %r14d,%r14d
pxor   %xmm8,%xmm8
movdqa 0xb20(%rip),%xmm9
movdqa 0xb28(%rip),%xmm6
movdqa 0xb30(%rip),%xmm7
jmp    1563 <RGB565toBGR32+0x443>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rcx,%r15
mov    %rax,%rbp
add    %rbx,%rbp
add    0x10(%rsp),%r15
add    0x48(%rsp),%r15
mov    0x50(%rsp),%rax
lea    (%rax,%rbp,1),%rdi
mov    %rbp,%rsi
mov    0xc(%rsp),%edx
call   1040 <memcpy@plt>
add    %r12,%rbp
add    $0x1,%r14d
mov    %rbp,%rax
mov    %r15,%rcx
mov    0xd8(%rsp),%edx
cmp    %edx,%r14d
pxor   %xmm8,%xmm8
movdqa 0xab3(%rip),%xmm9
movdqa 0xabb(%rip),%xmm6
movdqa 0xac3(%rip),%xmm7
je     1687 <RGB565toBGR32+0x567>
mov    0xd0(%rsp),%edx
test   %edx,%edx
je     1500 <RGB565toBGR32+0x3e0>
cmpl   $0x3,0x40(%rsp)
jae    1590 <RGB565toBGR32+0x470>
mov    0xd0(%rsp),%edx
mov    %rax,%rbp
mov    %rcx,%r15
jmp    1650 <RGB565toBGR32+0x530>
nopw   0x0(%rax,%rax,1)
mov    0x30(%rsp),%rdx
lea    (%rax,%rdx,1),%rbp
mov    0x28(%rsp),%rdx
lea    (%rcx,%rdx,1),%r15
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movd   (%rcx,%rdx,2),%xmm1
movd   0x4(%rcx,%rdx,2),%xmm0
punpcklwd %xmm8,%xmm1
punpcklwd %xmm8,%xmm0
movdqa %xmm1,%xmm2
pslld  $0x13,%xmm2
movdqa %xmm0,%xmm3
pslld  $0x13,%xmm3
pand   %xmm9,%xmm2
pand   %xmm9,%xmm3
movdqa %xmm1,%xmm4
pslld  $0x5,%xmm4
movdqa %xmm0,%xmm5
pslld  $0x5,%xmm5
pand   %xmm6,%xmm4
por    %xmm2,%xmm4
pand   %xmm6,%xmm5
por    %xmm3,%xmm5
psrld  $0x8,%xmm1
psrld  $0x8,%xmm0
pand   %xmm7,%xmm1
por    %xmm4,%xmm1
pand   %xmm7,%xmm0
por    %xmm5,%xmm0
pshufd $0x50,%xmm1,%xmm1
movdqu %xmm1,(%rax,%rdx,8)
pshufd $0x50,%xmm0,%xmm0
movdqu %xmm0,0x10(%rax,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%r13
jne    15b0 <RGB565toBGR32+0x490>
mov    0x1c(%rsp),%edx
cmp    %r13,0x38(%rsp)
je     1506 <RGB565toBGR32+0x3e6>
xchg   %ax,%ax
movzwl (%r15),%eax
mov    %eax,%ecx
and    $0x1f,%ecx
shl    $0x13,%ecx
mov    %eax,%esi
shl    $0x5,%esi
and    $0xfc00,%esi
or     %ecx,%esi
shr    $0xb,%eax
lea    (%rsi,%rax,8),%eax
mov    %eax,0x0(%rbp)
mov    %eax,0x4(%rbp)
add    $0x8,%rbp
add    $0x2,%r15
add    $0xffffffff,%edx
jne    1650 <RGB565toBGR32+0x530>
jmp    1506 <RGB565toBGR32+0x3e6>
xor    %eax,%eax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @RGB565toBGR32(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 i16
%41 = alloca i8*
%42 = alloca i8*
%43 = alloca i32
%44 = alloca i32
%45 = alloca i16
%46 = alloca i32
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
%47 = load i8*, i8** %18
%48 = load i32, i32* %19
%49 = load i32, i32* %20
%50 = load i32, i32* %21
%51 = load i32, i32* %22
%52 = load i32, i32* %23
%53 = load i32, i32* %24
%54 = load i32, i32* %25
%55 = load i8*, i8** %26
%56 = load i32, i32* %27
%57 = load i32, i32* %28
%58 = load i32, i32* %29
%59 = load i32, i32* %30
%60 = load i32, i32* %31
%61 = load i32, i32* %32
%62 = load i32, i32* %33
%63 = call i32 @chk_args(i8* %47, i32 %48, i32 %49, i32 %50, i32 %51, i32 %52, i32 %53, i32 %54, i8* %55, i32 %56, i32 %57, i32 %58, i32 %59, i32 %60, i32 %61, i32 %62, i32* %34, i32* %35)
%64 = icmp ne i32 %63, 0
br i1 %64, label %66, label %65
65: ; preds = %16
store i32 -1, i32* %17
br label %275
66: ; preds = %16
%67 = load i32, i32* %29
%68 = icmp slt i32 %67, 0
br i1 %68, label %69, label %78
69: ; preds = %66
%70 = load i32, i32* %28
%71 = sub nsw i32 %70, 1
%72 = load i32, i32* %29
%73 = mul nsw i32 %71, %72
%74 = load i8*, i8** %26
%75 = sext i32 %73 to i64
%76 = sub i64 0, %75
%77 = getelementptr inbounds i8, i8* %74, i64 %76
store i8* %77, i8** %26
br label %78
78: ; preds = %69, %66
%79 = load i32, i32* %21
%80 = icmp slt i32 %79, 0
br i1 %80, label %81, label %90
81: ; preds = %78
%82 = load i32, i32* %20
%83 = sub nsw i32 %82, 1
%84 = load i32, i32* %21
%85 = mul nsw i32 %83, %84
%86 = load i8*, i8** %18
%87 = sext i32 %85 to i64
%88 = sub i64 0, %87
%89 = getelementptr inbounds i8, i8* %86, i64 %88
store i8* %89, i8** %18
br label %90
90: ; preds = %81, %78
%91 = load i32, i32* %34
%92 = icmp eq i32 %91, 1
br i1 %92, label %93, label %171
93: ; preds = %90
%94 = load i32, i32* %35
%95 = icmp eq i32 %94, 1
br i1 %95, label %96, label %171
96: ; preds = %93
%97 = load i8*, i8** %26
%98 = load i32, i32* %30
%99 = mul nsw i32 %98, 2
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds i8, i8* %97, i64 %100
%102 = load i32, i32* %31
%103 = load i32, i32* %29
%104 = mul nsw i32 %102, %103
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds i8, i8* %101, i64 %105
store i8* %106, i8** %36
%107 = load i8*, i8** %18
%108 = load i32, i32* %22
%109 = mul nsw i32 %108, 4
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds i8, i8* %107, i64 %110
%112 = load i32, i32* %23
%113 = load i32, i32* %21
%114 = mul nsw i32 %112, %113
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds i8, i8* %111, i64 %115
store i8* %116, i8** %37
store i32 0, i32* %38
br label %117
117: ; preds = %167, %96
%118 = load i32, i32* %38
%119 = load i32, i32* %25
%120 = icmp slt i32 %118, %119
br i1 %120, label %121, label %170
121: ; preds = %117
%122 = load i32, i32* %24
store i32 %122, i32* %39
br label %123
123: ; preds = %126, %121
%124 = load i32, i32* %39
%125 = icmp ne i32 %124, 0
br i1 %125, label %126, label %152
126: ; preds = %123
%127 = load i8*, i8** %36
%128 = bitcast i8* %127 to i16*
%129 = load i16, i16* %128
store i16 %129, i16* %40
%130 = load i16, i16* %40
%131 = zext i16 %130 to i32
%132 = and i32 %131, 31
%133 = shl i32 %132, 19
%134 = load i16, i16* %40
%135 = zext i16 %134 to i32
%136 = and i32 %135, 2016
%137 = shl i32 %136, 5
%138 = or i32 %133, %137
%139 = load i16, i16* %40
%140 = zext i16 %139 to i32
%141 = and i32 %140, 63488
%142 = ashr i32 %141, 8
%143 = or i32 %138, %142
%144 = load i8*, i8** %37
%145 = bitcast i8* %144 to i32*
store i32 %143, i32* %145
%146 = load i8*, i8** %37
%147 = getelementptr inbounds i8, i8* %146, i64 4
store i8* %147, i8** %37
%148 = load i8*, i8** %36
%149 = getelementptr inbounds i8, i8* %148, i64 2
store i8* %149, i8** %36
%150 = load i32, i32* %39
%151 = add nsw i32 %150, -1
store i32 %151, i32* %39
br label %123
152: ; preds = %123
%153 = load i32, i32* %29
%154 = load i32, i32* %24
%155 = mul nsw i32 %154, 2
%156 = sub nsw i32 %153, %155
%157 = load i8*, i8** %36
%158 = sext i32 %156 to i64
%159 = getelementptr inbounds i8, i8* %157, i64 %158
store i8* %159, i8** %36
%160 = load i32, i32* %21
%161 = load i32, i32* %24
%162 = mul nsw i32 %161, 4
%163 = sub nsw i32 %160, %162
%164 = load i8*, i8** %37
%165 = sext i32 %163 to i64
%166 = getelementptr inbounds i8, i8* %164, i64 %165
store i8* %166, i8** %37
br label %167
167: ; preds = %152
%168 = load i32, i32* %38
%169 = add nsw i32 %168, 1
store i32 %169, i32* %38
br label %117
170: ; preds = %117
store i32 0, i32* %17
br label %275
171: ; preds = %93, %90
%172 = load i32, i32* %34
%173 = icmp eq i32 %172, 2
br i1 %173, label %174, label %274
174: ; preds = %171
%175 = load i32, i32* %35
%176 = icmp eq i32 %175, 2
br i1 %176, label %177, label %274
177: ; preds = %174
%178 = load i8*, i8** %26
%179 = load i32, i32* %30
%180 = mul nsw i32 %179, 2
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i8, i8* %178, i64 %181
%183 = load i32, i32* %31
%184 = load i32, i32* %29
%185 = mul nsw i32 %183, %184
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds i8, i8* %182, i64 %186
store i8* %187, i8** %41
%188 = load i8*, i8** %18
%189 = load i32, i32* %22
%190 = mul nsw i32 %189, 4
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds i8, i8* %188, i64 %191
%193 = load i32, i32* %23
%194 = load i32, i32* %21
%195 = mul nsw i32 %193, %194
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds i8, i8* %192, i64 %196
store i8* %197, i8** %42
store i32 0, i32* %43
br label %198
198: ; preds = %270, %177
%199 = load i32, i32* %43
%200 = load i32, i32* %33
%201 = icmp slt i32 %199, %200
br i1 %201, label %202, label %273
202: ; preds = %198
%203 = load i32, i32* %32
store i32 %203, i32* %44
br label %204
204: ; preds = %207, %202
%205 = load i32, i32* %44
%206 = icmp ne i32 %205, 0
br i1 %206, label %207, label %238
207: ; preds = %204
%208 = load i8*, i8** %41
%209 = bitcast i8* %208 to i16*
%210 = load i16, i16* %209
store i16 %210, i16* %45
%211 = load i16, i16* %45
%212 = zext i16 %211 to i32
%213 = and i32 %212, 31
%214 = shl i32 %213, 19
%215 = load i16, i16* %45
%216 = zext i16 %215 to i32
%217 = and i32 %216, 2016
%218 = shl i32 %217, 5
%219 = or i32 %214, %218
%220 = load i16, i16* %45
%221 = zext i16 %220 to i32
%222 = and i32 %221, 63488
%223 = ashr i32 %222, 8
%224 = or i32 %219, %223
store i32 %224, i32* %46
%225 = load i32, i32* %46
%226 = load i8*, i8** %42
%227 = bitcast i8* %226 to i32*
store i32 %225, i32* %227
%228 = load i32, i32* %46
%229 = load i8*, i8** %42
%230 = getelementptr inbounds i8, i8* %229, i64 4
%231 = bitcast i8* %230 to i32*
store i32 %228, i32* %231
%232 = load i8*, i8** %42
%233 = getelementptr inbounds i8, i8* %232, i64 8
store i8* %233, i8** %42
%234 = load i8*, i8** %41
%235 = getelementptr inbounds i8, i8* %234, i64 2
store i8* %235, i8** %41
%236 = load i32, i32* %44
%237 = add nsw i32 %236, -1
store i32 %237, i32* %44
br label %204
238: ; preds = %204
%239 = load i32, i32* %32
%240 = mul nsw i32 %239, 2
%241 = load i8*, i8** %41
%242 = sext i32 %240 to i64
%243 = sub i64 0, %242
%244 = getelementptr inbounds i8, i8* %241, i64 %243
store i8* %244, i8** %41
%245 = load i32, i32* %32
%246 = mul nsw i32 %245, 2
%247 = mul nsw i32 %246, 4
%248 = load i8*, i8** %42
%249 = sext i32 %247 to i64
%250 = sub i64 0, %249
%251 = getelementptr inbounds i8, i8* %248, i64 %250
store i8* %251, i8** %42
%252 = load i8*, i8** %42
%253 = load i32, i32* %21
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds i8, i8* %252, i64 %254
%256 = load i8*, i8** %42
%257 = load i32, i32* %32
%258 = mul nsw i32 %257, 2
%259 = mul nsw i32 %258, 4
%260 = call i32 @memcpy(i8* %255, i8* %256, i32 %259)
%261 = load i32, i32* %29
%262 = load i8*, i8** %41
%263 = sext i32 %261 to i64
%264 = getelementptr inbounds i8, i8* %262, i64 %263
store i8* %264, i8** %41
%265 = load i32, i32* %21
%266 = mul nsw i32 %265, 2
%267 = load i8*, i8** %42
%268 = sext i32 %266 to i64
%269 = getelementptr inbounds i8, i8* %267, i64 %268
store i8* %269, i8** %42
br label %270
270: ; preds = %238
%271 = load i32, i32* %43
%272 = add nsw i32 %271, 1
store i32 %272, i32* %43
br label %198
273: ; preds = %198
store i32 0, i32* %17
br label %275
274: ; preds = %174, %171
store i32 -1, i32* %17
br label %275
275: ; preds = %274, %273, %170, %65
%276 = load i32, i32* %17
ret i32 %276
}

LLVM IR (-O2):
define i32 @RGB565toBGR32(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 %275, 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 %149
43: ; preds = %23
%44 = icmp sgt i32 %7, 0
br i1 %44, label %45, label %275
45: ; preds = %43
%46 = shl nsw i32 %4, 2
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds i8, i8* %37, i64 %47
%49 = mul nsw i32 %5, %3
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds i8, i8* %48, i64 %50
%52 = shl nsw i32 %12, 1
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i8, i8* %30, i64 %53
%55 = mul nsw i32 %13, %11
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds i8, i8* %54, i64 %56
%58 = icmp eq i32 %6, 0
%59 = mul i32 %6, -2
%60 = add i32 %59, %11
%61 = sext i32 %60 to i64
%62 = mul i32 %6, -4
%63 = add i32 %62, %3
%64 = sext i32 %63 to i64
%65 = add i32 %6, -1
%66 = zext i32 %65 to i64
%67 = add nuw nsw i64 %66, 1
%68 = icmp ult i32 %65, 7
%69 = and i64 %67, 8589934584
%70 = trunc i64 %69 to i32
%71 = sub i32 %6, %70
%72 = shl nuw nsw i64 %69, 2
%73 = shl nuw nsw i64 %69, 1
%74 = icmp eq i64 %67, %69
br label %75
75: ; preds = %45, %142
%76 = phi i32 [ 0, %45 ], [ %147, %142 ]
%77 = phi i8* [ %51, %45 ], [ %146, %142 ]
%78 = phi i8* [ %57, %45 ], [ %145, %142 ]
br i1 %58, label %142, label %79
79: ; preds = %75
br i1 %68, label %118, label %80
80: ; preds = %79
%81 = getelementptr i8, i8* %77, i64 %72
%82 = getelementptr i8, i8* %78, i64 %73
br label %83
83: ; preds = %83, %80
%84 = phi i64 [ 0, %80 ], [ %115, %83 ]
%85 = shl i64 %84, 2
%86 = getelementptr i8, i8* %77, i64 %85
%87 = shl i64 %84, 1
%88 = getelementptr i8, i8* %78, i64 %87
%89 = bitcast i8* %88 to <4 x i16>*
%90 = load <4 x i16>, <4 x i16>* %89
%91 = getelementptr i8, i8* %88, i64 8
%92 = bitcast i8* %91 to <4 x i16>*
%93 = load <4 x i16>, <4 x i16>* %92
%94 = zext <4 x i16> %90 to <4 x i32>
%95 = zext <4 x i16> %93 to <4 x i32>
%96 = shl <4 x i32> %94, <i32 19, i32 19, i32 19, i32 19>
%97 = shl <4 x i32> %95, <i32 19, i32 19, i32 19, i32 19>
%98 = and <4 x i32> %96, <i32 16252928, i32 16252928, i32 16252928, i32 16252928>
%99 = and <4 x i32> %97, <i32 16252928, i32 16252928, i32 16252928, i32 16252928>
%100 = shl nuw nsw <4 x i32> %94, <i32 5, i32 5, i32 5, i32 5>
%101 = shl nuw nsw <4 x i32> %95, <i32 5, i32 5, i32 5, i32 5>
%102 = and <4 x i32> %100, <i32 64512, i32 64512, i32 64512, i32 64512>
%103 = and <4 x i32> %101, <i32 64512, i32 64512, i32 64512, i32 64512>
%104 = or <4 x i32> %98, %102
%105 = or <4 x i32> %99, %103
%106 = lshr <4 x i32> %94, <i32 8, i32 8, i32 8, i32 8>
%107 = lshr <4 x i32> %95, <i32 8, i32 8, i32 8, i32 8>
%108 = and <4 x i32> %106, <i32 248, i32 248, i32 248, i32 248>
%109 = and <4 x i32> %107, <i32 248, i32 248, i32 248, i32 248>
%110 = or <4 x i32> %104, %108
%111 = or <4 x i32> %105, %109
%112 = bitcast i8* %86 to <4 x i32>*
store <4 x i32> %110, <4 x i32>* %112
%113 = getelementptr i8, i8* %86, i64 16
%114 = bitcast i8* %113 to <4 x i32>*
store <4 x i32> %111, <4 x i32>* %114
%115 = add nuw i64 %84, 8
%116 = icmp eq i64 %115, %69
br i1 %116, label %117, label %83
117: ; preds = %83
br i1 %74, label %142, label %118
118: ; preds = %79, %117
%119 = phi i32 [ %6, %79 ], [ %71, %117 ]
%120 = phi i8* [ %77, %79 ], [ %81, %117 ]
%121 = phi i8* [ %78, %79 ], [ %82, %117 ]
br label %122
122: ; preds = %118, %122
%123 = phi i32 [ %140, %122 ], [ %119, %118 ]
%124 = phi i8* [ %138, %122 ], [ %120, %118 ]
%125 = phi i8* [ %139, %122 ], [ %121, %118 ]
%126 = bitcast i8* %125 to i16*
%127 = load i16, i16* %126
%128 = zext i16 %127 to i32
%129 = shl i32 %128, 19
%130 = and i32 %129, 16252928
%131 = shl nuw nsw i32 %128, 5
%132 = and i32 %131, 64512
%133 = or i32 %130, %132
%134 = lshr i32 %128, 8
%135 = and i32 %134, 248
%136 = or i32 %133, %135
%137 = bitcast i8* %124 to i32*
store i32 %136, i32* %137
%138 = getelementptr inbounds i8, i8* %124, i64 4
%139 = getelementptr inbounds i8, i8* %125, i64 2
%140 = add nsw i32 %123, -1
%141 = icmp eq i32 %140, 0
br i1 %141, label %142, label %122
142: ; preds = %122, %117, %75
%143 = phi i8* [ %78, %75 ], [ %82, %117 ], [ %139, %122 ]
%144 = phi i8* [ %77, %75 ], [ %81, %117 ], [ %138, %122 ]
%145 = getelementptr inbounds i8, i8* %143, i64 %61
%146 = getelementptr inbounds i8, i8* %144, i64 %64
%147 = add nuw nsw i32 %76, 1
%148 = icmp eq i32 %147, %7
br i1 %148, label %275, label %75
149: ; preds = %23
%150 = icmp eq i32 %38, 2
%151 = icmp eq i32 %40, 2
%152 = select i1 %150, i1 %151, i1 false
br i1 %152, label %153, label %275
153: ; preds = %149
%154 = icmp sgt i32 %15, 0
br i1 %154, label %155, label %275
155: ; preds = %153
%156 = shl nsw i32 %4, 2
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds i8, i8* %37, i64 %157
%159 = mul nsw i32 %5, %3
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds i8, i8* %158, i64 %160
%162 = shl nsw i32 %12, 1
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds i8, i8* %30, i64 %163
%165 = mul nsw i32 %13, %11
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds i8, i8* %164, i64 %166
%168 = icmp eq i32 %14, 0
%169 = shl nsw i32 %14, 1
%170 = sext i32 %169 to i64
%171 = sub nsw i64 0, %170
%172 = shl nsw i32 %14, 3
%173 = sext i32 %172 to i64
%174 = sub nsw i64 0, %173
%175 = sext i32 %3 to i64
%176 = sext i32 %11 to i64
%177 = shl nsw i32 %3, 1
%178 = sext i32 %177 to i64
%179 = add i32 %14, -1
%180 = zext i32 %179 to i64
%181 = add nuw nsw i64 %180, 1
%182 = icmp ult i32 %179, 3
%183 = and i64 %181, 8589934588
%184 = trunc i64 %183 to i32
%185 = sub i32 %14, %184
%186 = shl nuw nsw i64 %183, 3
%187 = shl nuw nsw i64 %183, 1
%188 = icmp eq i64 %181, %183
br label %189
189: ; preds = %155, %264
%190 = phi i32 [ 0, %155 ], [ %273, %264 ]
%191 = phi i8* [ %161, %155 ], [ %272, %264 ]
%192 = phi i8* [ %167, %155 ], [ %271, %264 ]
br i1 %168, label %264, label %193
193: ; preds = %189
br i1 %182, label %238, label %194
194: ; preds = %193
%195 = getelementptr i8, i8* %191, i64 %186
%196 = getelementptr i8, i8* %192, i64 %187
br label %197
197: ; preds = %197, %194
%198 = phi i64 [ 0, %194 ], [ %235, %197 ]
%199 = shl i64 %198, 3
%200 = shl i64 %198, 3
%201 = or i64 %200, 16
%202 = shl i64 %198, 1
%203 = getelementptr i8, i8* %192, i64 %202
%204 = bitcast i8* %203 to <2 x i16>*
%205 = load <2 x i16>, <2 x i16>* %204
%206 = getelementptr i8, i8* %203, i64 4
%207 = bitcast i8* %206 to <2 x i16>*
%208 = load <2 x i16>, <2 x i16>* %207
%209 = zext <2 x i16> %205 to <2 x i32>
%210 = zext <2 x i16> %208 to <2 x i32>
%211 = shl <2 x i32> %209, <i32 19, i32 19>
%212 = shl <2 x i32> %210, <i32 19, i32 19>
%213 = and <2 x i32> %211, <i32 16252928, i32 16252928>
%214 = and <2 x i32> %212, <i32 16252928, i32 16252928>
%215 = shl nuw nsw <2 x i32> %209, <i32 5, i32 5>
%216 = shl nuw nsw <2 x i32> %210, <i32 5, i32 5>
%217 = and <2 x i32> %215, <i32 64512, i32 64512>
%218 = and <2 x i32> %216, <i32 64512, i32 64512>
%219 = or <2 x i32> %213, %217
%220 = or <2 x i32> %214, %218
%221 = lshr <2 x i32> %209, <i32 8, i32 8>
%222 = lshr <2 x i32> %210, <i32 8, i32 8>
%223 = and <2 x i32> %221, <i32 248, i32 248>
%224 = and <2 x i32> %222, <i32 248, i32 248>
%225 = or <2 x i32> %219, %223
%226 = or <2 x i32> %220, %224
%227 = getelementptr inbounds i8, i8* %191, i64 %199
%228 = bitcast i8* %227 to <4 x i32>*
%229 = getelementptr inbounds i8, i8* %191, i64 %201
%230 = bitcast i8* %229 to <4 x i32>*
%231 = shufflevector <2 x i32> %225, <2 x i32> poison, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
%232 = shufflevector <4 x i32> %231, <4 x i32> poison, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x i32> %232, <4 x i32>* %228
%233 = shufflevector <2 x i32> %226, <2 x i32> poison, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
%234 = shufflevector <4 x i32> %233, <4 x i32> poison, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x i32> %234, <4 x i32>* %230
%235 = add nuw i64 %198, 4
%236 = icmp eq i64 %235, %183
br i1 %236, label %237, label %197
237: ; preds = %197
br i1 %188, label %264, label %238
238: ; preds = %193, %237
%239 = phi i32 [ %14, %193 ], [ %185, %237 ]
%240 = phi i8* [ %191, %193 ], [ %195, %237 ]
%241 = phi i8* [ %192, %193 ], [ %196, %237 ]
br label %242
242: ; preds = %238, %242
%243 = phi i32 [ %262, %242 ], [ %239, %238 ]
%244 = phi i8* [ %260, %242 ], [ %240, %238 ]
%245 = phi i8* [ %261, %242 ], [ %241, %238 ]
%246 = bitcast i8* %245 to i16*
%247 = load i16, i16* %246
%248 = zext i16 %247 to i32
%249 = shl i32 %248, 19
%250 = and i32 %249, 16252928
%251 = shl nuw nsw i32 %248, 5
%252 = and i32 %251, 64512
%253 = or i32 %250, %252
%254 = lshr i32 %248, 8
%255 = and i32 %254, 248
%256 = or i32 %253, %255
%257 = bitcast i8* %244 to i32*
store i32 %256, i32* %257
%258 = getelementptr inbounds i8, i8* %244, i64 4
%259 = bitcast i8* %258 to i32*
store i32 %256, i32* %259
%260 = getelementptr inbounds i8, i8* %244, i64 8
%261 = getelementptr inbounds i8, i8* %245, i64 2
%262 = add nsw i32 %243, -1
%263 = icmp eq i32 %262, 0
br i1 %263, label %264, label %242
264: ; preds = %242, %237, %189
%265 = phi i8* [ %192, %189 ], [ %196, %237 ], [ %261, %242 ]
%266 = phi i8* [ %191, %189 ], [ %195, %237 ], [ %260, %242 ]
%267 = getelementptr inbounds i8, i8* %265, i64 %171
%268 = getelementptr inbounds i8, i8* %266, i64 %174
%269 = getelementptr inbounds i8, i8* %268, i64 %175
%270 = call i32 @memcpy(i8* %269, i8* %268, i32 %172)
%271 = getelementptr inbounds i8, i8* %267, i64 %176
%272 = getelementptr inbounds i8, i8* %268, i64 %178
%273 = add nuw nsw i32 %190, 1
%274 = icmp eq i32 %273, %15
br i1 %274, label %275, label %189
275: ; preds = %264, %142, %153, %43, %149, %16
%276 = phi i32 [ -1, %16 ], [ -1, %149 ], [ 0, %43 ], [ 0, %153 ], [ 0, %142 ], [ 0, %264 ]
ret i32 %276
}