void RGB444toRGB444_ROW2X_COPY(unsigned char *dest_ptr_1,
                               unsigned char *dest_ptr_12,
                               unsigned char *dest_ptr_2, int dest_dx,
                               unsigned char *src_ptr, int src_dx) {
  register unsigned char *d1 = dest_ptr_1;
  register unsigned char *d12 = dest_ptr_12;
  register unsigned char *d2 = dest_ptr_2;
  register unsigned char *s = src_ptr;
  register int count = dest_dx;
  while (((unsigned int)d2 & 3) && ((unsigned int)s & 3) && count) {
    register unsigned int da_rgb;
    register unsigned int sa_rgb;
    sa_rgb = *(unsigned short *)(s);
    da_rgb = sa_rgb;
    s += 2;
    *(unsigned short *)(d2) = da_rgb;
    d2 += 2;
    register unsigned int sb_rgb;
    sb_rgb = *(unsigned short *)(d1);
    da_rgb = (((da_rgb ^ sb_rgb) >> 1) & (((1U << (8 + 4 - 1)) - (1U << 8)) |
                                          ((1U << (4 + 4 - 1)) - (1U << 4)) |
                                          ((1U << (0 + 4 - 1)) - (1U << 0)))) +
             (da_rgb & sb_rgb);
    d1 += 2;
    *(unsigned short *)(d12) = da_rgb;
    d12 += 2;
    count--;
  }
  while (count >= 4) {
    register unsigned int da_rgb;
    register unsigned int sa_rgb;
    register unsigned int sb_rgb;
    sa_rgb = *(unsigned short *)(s);
    da_rgb = sa_rgb;
    *(unsigned short *)(d2) = da_rgb;
    sb_rgb = *(unsigned short *)(d1);
    da_rgb = (((da_rgb ^ sb_rgb) >> 1) & (((1U << (8 + 4 - 1)) - (1U << 8)) |
                                          ((1U << (4 + 4 - 1)) - (1U << 4)) |
                                          ((1U << (0 + 4 - 1)) - (1U << 0)))) +
             (da_rgb & sb_rgb);
    *(unsigned short *)(d12) = da_rgb;
    sa_rgb = *(unsigned short *)(s + 2);
    da_rgb = sa_rgb;
    *(unsigned short *)(d2 + 2) = da_rgb;
    sb_rgb = *(unsigned short *)(d1 + 2);
    da_rgb = (((da_rgb ^ sb_rgb) >> 1) & (((1U << (8 + 4 - 1)) - (1U << 8)) |
                                          ((1U << (4 + 4 - 1)) - (1U << 4)) |
                                          ((1U << (0 + 4 - 1)) - (1U << 0)))) +
             (da_rgb & sb_rgb);
    *(unsigned short *)(d12 + 2) = da_rgb;
    sa_rgb = *(unsigned short *)(s + 4);
    da_rgb = sa_rgb;
    *(unsigned short *)(d2 + 2 * 2) = da_rgb;
    sb_rgb = *(unsigned short *)(d1 + 2 * 2);
    da_rgb = (((da_rgb ^ sb_rgb) >> 1) & (((1U << (8 + 4 - 1)) - (1U << 8)) |
                                          ((1U << (4 + 4 - 1)) - (1U << 4)) |
                                          ((1U << (0 + 4 - 1)) - (1U << 0)))) +
             (da_rgb & sb_rgb);
    *(unsigned short *)(d12 + 2 * 2) = da_rgb;
    sa_rgb = *(unsigned short *)(s + 6);
    da_rgb = sa_rgb;
    *(unsigned short *)(d2 + 3 * 2) = da_rgb;
    sb_rgb = *(unsigned short *)(d1 + 3 * 2);
    da_rgb = (((da_rgb ^ sb_rgb) >> 1) & (((1U << (8 + 4 - 1)) - (1U << 8)) |
                                          ((1U << (4 + 4 - 1)) - (1U << 4)) |
                                          ((1U << (0 + 4 - 1)) - (1U << 0)))) +
             (da_rgb & sb_rgb);
    *(unsigned short *)(d12 + 3 * 2) = da_rgb;
    s += 8;
    d1 += 4 * 2;
    d2 += 4 * 2;
    d12 += 4 * 2;
    count -= 4;
  }
  while (count) {
    register unsigned int da_rgb;
    register unsigned int sa_rgb;
    sa_rgb = *(unsigned short *)(s);
    da_rgb = sa_rgb;
    s += 2;
    *(unsigned short *)(d2) = da_rgb;
    d2 += 2;
    register unsigned int sb_rgb;
    sb_rgb = *(unsigned short *)(d1);
    da_rgb = (((da_rgb ^ sb_rgb) >> 1) & (((1U << (8 + 4 - 1)) - (1U << 8)) |
                                          ((1U << (4 + 4 - 1)) - (1U << 4)) |
                                          ((1U << (0 + 4 - 1)) - (1U << 0)))) +
             (da_rgb & sb_rgb);
    d1 += 2;
    *(unsigned short *)(d12) = da_rgb;
    d12 += 2;
    count--;
  }
}


x86 assembly (clang, -O0):
<RGB444toRGB444_ROW2X_COPY>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x48(%rbp),%rax
mov    %eax,%ecx
and    $0x3,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x79(%rbp)
je     1179 <RGB444toRGB444_ROW2X_COPY+0x79>
mov    -0x50(%rbp),%rax
mov    %eax,%ecx
and    $0x3,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x79(%rbp)
je     1179 <RGB444toRGB444_ROW2X_COPY+0x79>
cmpl   $0x0,-0x54(%rbp)
setne  %al
mov    %al,-0x79(%rbp)
mov    -0x79(%rbp),%al
test   $0x1,%al
jne    1189 <RGB444toRGB444_ROW2X_COPY+0x89>
jmp    1214 <RGB444toRGB444_ROW2X_COPY+0x114>
mov    -0x50(%rbp),%rax
movzwl (%rax),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x50(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%eax
mov    %ax,%cx
mov    -0x48(%rbp),%rax
mov    %cx,(%rax)
mov    -0x48(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%rax
movzwl (%rax),%eax
mov    %eax,-0x60(%rbp)
mov    -0x58(%rbp),%eax
xor    -0x60(%rbp),%eax
shr    $0x1,%eax
and    $0x777,%eax
mov    -0x58(%rbp),%ecx
and    -0x60(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x38(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x38(%rbp)
mov    -0x58(%rbp),%eax
mov    %ax,%cx
mov    -0x40(%rbp),%rax
mov    %cx,(%rax)
mov    -0x40(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x40(%rbp)
mov    -0x54(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x54(%rbp)
jmp    1141 <RGB444toRGB444_ROW2X_COPY+0x41>
jmp    1219 <RGB444toRGB444_ROW2X_COPY+0x119>
cmpl   $0x4,-0x54(%rbp)
jl     13a1 <RGB444toRGB444_ROW2X_COPY+0x2a1>
mov    -0x50(%rbp),%rax
movzwl (%rax),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    %ax,%cx
mov    -0x48(%rbp),%rax
mov    %cx,(%rax)
mov    -0x38(%rbp),%rax
movzwl (%rax),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x64(%rbp),%eax
xor    -0x6c(%rbp),%eax
shr    $0x1,%eax
and    $0x777,%eax
mov    -0x64(%rbp),%ecx
and    -0x6c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    %ax,%cx
mov    -0x40(%rbp),%rax
mov    %cx,(%rax)
mov    -0x50(%rbp),%rax
movzwl 0x2(%rax),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    %ax,%cx
mov    -0x48(%rbp),%rax
mov    %cx,0x2(%rax)
mov    -0x38(%rbp),%rax
movzwl 0x2(%rax),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x64(%rbp),%eax
xor    -0x6c(%rbp),%eax
shr    $0x1,%eax
and    $0x777,%eax
mov    -0x64(%rbp),%ecx
and    -0x6c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    %ax,%cx
mov    -0x40(%rbp),%rax
mov    %cx,0x2(%rax)
mov    -0x50(%rbp),%rax
movzwl 0x4(%rax),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    %ax,%cx
mov    -0x48(%rbp),%rax
mov    %cx,0x4(%rax)
mov    -0x38(%rbp),%rax
movzwl 0x4(%rax),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x64(%rbp),%eax
xor    -0x6c(%rbp),%eax
shr    $0x1,%eax
and    $0x777,%eax
mov    -0x64(%rbp),%ecx
and    -0x6c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    %ax,%cx
mov    -0x40(%rbp),%rax
mov    %cx,0x4(%rax)
mov    -0x50(%rbp),%rax
movzwl 0x6(%rax),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    %ax,%cx
mov    -0x48(%rbp),%rax
mov    %cx,0x6(%rax)
mov    -0x38(%rbp),%rax
movzwl 0x6(%rax),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x64(%rbp),%eax
xor    -0x6c(%rbp),%eax
shr    $0x1,%eax
and    $0x777,%eax
mov    -0x64(%rbp),%ecx
and    -0x6c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    %ax,%cx
mov    -0x40(%rbp),%rax
mov    %cx,0x6(%rax)
mov    -0x50(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x38(%rbp)
mov    -0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x40(%rbp)
mov    -0x54(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x54(%rbp)
jmp    1219 <RGB444toRGB444_ROW2X_COPY+0x119>
jmp    13a6 <RGB444toRGB444_ROW2X_COPY+0x2a6>
cmpl   $0x0,-0x54(%rbp)
je     143b <RGB444toRGB444_ROW2X_COPY+0x33b>
mov    -0x50(%rbp),%rax
movzwl (%rax),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x50(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x50(%rbp)
mov    -0x70(%rbp),%eax
mov    %ax,%cx
mov    -0x48(%rbp),%rax
mov    %cx,(%rax)
mov    -0x48(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%rax
movzwl (%rax),%eax
mov    %eax,-0x78(%rbp)
mov    -0x70(%rbp),%eax
xor    -0x78(%rbp),%eax
shr    $0x1,%eax
and    $0x777,%eax
mov    -0x70(%rbp),%ecx
and    -0x78(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x38(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x38(%rbp)
mov    -0x70(%rbp),%eax
mov    %ax,%cx
mov    -0x40(%rbp),%rax
mov    %cx,(%rax)
mov    -0x40(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x40(%rbp)
mov    -0x54(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x54(%rbp)
jmp    13a6 <RGB444toRGB444_ROW2X_COPY+0x2a6>
pop    %rbp
ret

x86 assembly (clang, -O2):
<RGB444toRGB444_ROW2X_COPY>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   $0x3,%dl
je     116f <RGB444toRGB444_ROW2X_COPY+0x6f>
lea    0x2(%rdx),%r9
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%r8,%rax,1),%ebp
test   $0x3,%bpl
je     1163 <RGB444toRGB444_ROW2X_COPY+0x63>
test   %ecx,%ecx
je     1163 <RGB444toRGB444_ROW2X_COPY+0x63>
movzwl (%r8,%rax,1),%r10d
mov    %r10w,(%rdx,%rax,1)
movzwl (%rdi,%rax,1),%ebp
mov    %ebp,%ebx
xor    %r10d,%ebx
shr    %ebx
and    $0x777,%ebx
and    %r10d,%ebp
add    %ebx,%ebp
mov    %bp,(%rsi,%rax,1)
add    $0xffffffff,%ecx
lea    (%r9,%rax,1),%ebp
add    $0x2,%rax
test   $0x3,%bpl
jne    1120 <RGB444toRGB444_ROW2X_COPY+0x20>
add    %rax,%rdi
add    %rax,%rsi
add    %rax,%rdx
add    %rax,%r8
cmp    $0x4,%ecx
jl     151d <RGB444toRGB444_ROW2X_COPY+0x41d>
xor    %eax,%eax
mov    %ecx,%r14d
sub    $0x7,%r14d
cmovb  %eax,%r14d
add    $0x3,%r14d
cmp    $0x1c,%r14d
jb     152e <RGB444toRGB444_ROW2X_COPY+0x42e>
mov    %ecx,%ebp
sub    $0x7,%ebp
cmovb  %eax,%ebp
add    $0x3,%ebp
shr    $0x2,%ebp
lea    (%rdx,%rbp,8),%rbx
add    $0x8,%rbx
lea    (%rsi,%rbp,8),%rax
add    $0x8,%rax
lea    (%r8,%rbp,8),%r9
add    $0x8,%r9
lea    (%rdi,%rbp,8),%rbp
add    $0x8,%rbp
cmp    %rax,%rdx
setb   -0x28(%rsp)
cmp    %rbx,%rsi
setb   %r11b
cmp    %r9,%rdx
setb   %r12b
cmp    %rbx,%r8
setb   %r15b
cmp    %rbp,%rdx
setb   %r13b
cmp    %rbx,%rdi
setb   %bl
cmp    %r9,%rsi
setb   %r9b
cmp    %rax,%r8
setb   -0x38(%rsp)
cmp    %rbp,%rsi
setb   %r10b
cmp    %rax,%rdi
setb   %al
test   %r11b,-0x28(%rsp)
jne    152e <RGB444toRGB444_ROW2X_COPY+0x42e>
and    %r15b,%r12b
jne    152e <RGB444toRGB444_ROW2X_COPY+0x42e>
and    %bl,%r13b
jne    152e <RGB444toRGB444_ROW2X_COPY+0x42e>
and    -0x38(%rsp),%r9b
jne    152e <RGB444toRGB444_ROW2X_COPY+0x42e>
and    %al,%r10b
jne    152e <RGB444toRGB444_ROW2X_COPY+0x42e>
shr    $0x2,%r14d
add    $0x1,%r14d
mov    %r14d,%r15d
and    $0xfffffff8,%r15d
lea    (%rdi,%r15,8),%r11
lea    (%rsi,%r15,8),%r10
lea    (%rdx,%r15,8),%rax
lea    (%r8,%r15,8),%r9
lea    0x0(,%r15,4),%ebx
sub    %ebx,%ecx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu (%r8,%rbx,8),%xmm3
movdqu 0x10(%r8,%rbx,8),%xmm1
movdqu 0x20(%r8,%rbx,8),%xmm6
movdqu 0x30(%r8,%rbx,8),%xmm12
pshufd $0xe8,%xmm1,%xmm0
movdqa %xmm1,%xmm7
movdqa %xmm1,-0x28(%rsp)
pshuflw $0xe8,%xmm0,%xmm1
pshufd $0xe8,%xmm3,%xmm2
movdqa %xmm3,%xmm8
movdqa %xmm3,-0x38(%rsp)
pshuflw $0xe8,%xmm2,%xmm3
punpckldq %xmm1,%xmm3
pshufd $0xe8,%xmm12,%xmm1
pshuflw $0x84,%xmm1,%xmm4
pshufd $0xe8,%xmm6,%xmm5
movdqa %xmm6,-0x18(%rsp)
pshuflw $0x84,%xmm5,%xmm13
punpckldq %xmm4,%xmm13
movsd  %xmm3,%xmm13
pshuflw $0xed,%xmm0,%xmm0
pshuflw $0xed,%xmm2,%xmm2
punpckldq %xmm0,%xmm2
pshuflw $0xd4,%xmm1,%xmm0
pshuflw $0xd4,%xmm5,%xmm10
punpckldq %xmm0,%xmm10
movsd  %xmm2,%xmm10
pshufd $0xe7,%xmm7,%xmm0
pshuflw $0xe2,%xmm0,%xmm1
pshufd $0xe7,%xmm8,%xmm2
pshuflw $0xe2,%xmm2,%xmm3
punpckldq %xmm1,%xmm3
pshufd $0xe7,%xmm12,%xmm4
pshuflw $0x24,%xmm4,%xmm5
pshufd $0xe7,%xmm6,%xmm6
pshuflw $0x24,%xmm6,%xmm7
punpckldq %xmm5,%xmm7
movsd  %xmm3,%xmm7
pshuflw $0xe7,%xmm0,%xmm0
pshuflw $0xe7,%xmm2,%xmm2
punpckldq %xmm0,%xmm2
pshuflw $0x74,%xmm4,%xmm3
pshuflw $0x74,%xmm6,%xmm9
punpckldq %xmm3,%xmm9
movsd  %xmm2,%xmm9
movdqu (%rdi,%rbx,8),%xmm11
movdqu 0x10(%rdi,%rbx,8),%xmm6
movdqu 0x20(%rdi,%rbx,8),%xmm14
movdqu 0x30(%rdi,%rbx,8),%xmm15
pshufd $0xe8,%xmm6,%xmm2
pshuflw $0xe8,%xmm2,%xmm5
pshufd $0xe8,%xmm11,%xmm3
pshuflw $0xe8,%xmm3,%xmm8
punpckldq %xmm5,%xmm8
pshufd $0xe8,%xmm15,%xmm1
pshuflw $0x84,%xmm1,%xmm4
pshufd $0xe8,%xmm14,%xmm0
pshuflw $0x84,%xmm0,%xmm5
punpckldq %xmm4,%xmm5
movsd  %xmm8,%xmm5
pshuflw $0xed,%xmm2,%xmm2
pshuflw $0xed,%xmm3,%xmm3
punpckldq %xmm2,%xmm3
pshuflw $0xd4,%xmm1,%xmm1
pshuflw $0xd4,%xmm0,%xmm2
punpckldq %xmm1,%xmm2
movsd  %xmm3,%xmm2
pshufd $0xe7,%xmm6,%xmm0
pshuflw $0xe2,%xmm0,%xmm1
pshufd $0xe7,%xmm11,%xmm11
pshuflw $0xe2,%xmm11,%xmm6
punpckldq %xmm1,%xmm6
pshufd $0xe7,%xmm15,%xmm1
pshuflw $0x24,%xmm1,%xmm8
pshufd $0xe7,%xmm14,%xmm4
pshuflw $0x24,%xmm4,%xmm3
punpckldq %xmm8,%xmm3
movsd  %xmm6,%xmm3
pshuflw $0xe7,%xmm0,%xmm0
pshuflw $0xe7,%xmm11,%xmm6
punpckldq %xmm0,%xmm6
pshuflw $0x74,%xmm1,%xmm0
pshuflw $0x74,%xmm4,%xmm4
punpckldq %xmm0,%xmm4
movsd  %xmm6,%xmm4
movapd %xmm5,%xmm0
xorpd  %xmm13,%xmm0
andpd  %xmm13,%xmm5
psrlw  $0x1,%xmm0
movdqa 0xbbc(%rip),%xmm1
pand   %xmm1,%xmm0
paddw  %xmm0,%xmm5
movapd %xmm2,%xmm0
xorpd  %xmm10,%xmm0
andpd  %xmm10,%xmm2
psrlw  $0x1,%xmm0
pand   %xmm1,%xmm0
paddw  %xmm0,%xmm2
movapd %xmm3,%xmm0
xorpd  %xmm7,%xmm0
andpd  %xmm7,%xmm3
psrlw  $0x1,%xmm0
pand   %xmm1,%xmm0
paddw  %xmm0,%xmm3
movdqu %xmm12,0x30(%rdx,%rbx,8)
movaps -0x38(%rsp),%xmm0
movups %xmm0,(%rdx,%rbx,8)
movaps -0x28(%rsp),%xmm0
movups %xmm0,0x10(%rdx,%rbx,8)
movaps -0x18(%rsp),%xmm0
movups %xmm0,0x20(%rdx,%rbx,8)
movapd %xmm4,%xmm0
xorpd  %xmm9,%xmm0
psrlw  $0x1,%xmm0
pand   %xmm1,%xmm0
andpd  %xmm9,%xmm4
paddw  %xmm0,%xmm4
movdqa %xmm3,%xmm0
punpcklwd %xmm4,%xmm0
movdqa %xmm5,%xmm1
punpcklwd %xmm2,%xmm1
movdqa %xmm1,%xmm6
punpckhdq %xmm0,%xmm6
punpckldq %xmm0,%xmm1
punpckhwd %xmm4,%xmm3
punpckhwd %xmm2,%xmm5
movdqa %xmm5,%xmm0
punpckhdq %xmm3,%xmm0
punpckldq %xmm3,%xmm5
movdqu %xmm5,0x20(%rsi,%rbx,8)
movdqu %xmm0,0x30(%rsi,%rbx,8)
movdqu %xmm1,(%rsi,%rbx,8)
movdqu %xmm6,0x10(%rsi,%rbx,8)
add    $0x8,%rbx
cmp    %rbx,%r15
jne    1270 <RGB444toRGB444_ROW2X_COPY+0x170>
cmp    %r14,%r15
jne    1540 <RGB444toRGB444_ROW2X_COPY+0x440>
jmp    15e6 <RGB444toRGB444_ROW2X_COPY+0x4e6>
mov    %r8,%r9
mov    %rdx,%rax
mov    %rsi,%r10
mov    %rdi,%r11
jmp    15e6 <RGB444toRGB444_ROW2X_COPY+0x4e6>
mov    %rdi,%r11
mov    %rsi,%r10
mov    %rdx,%rax
mov    %r8,%r9
nopw   0x0(%rax,%rax,1)
mov    %ecx,%edx
movzwl (%r9),%ecx
mov    %cx,(%rax)
movzwl (%r11),%esi
mov    %esi,%edi
xor    %ecx,%edi
shr    %edi
and    $0x777,%edi
and    %ecx,%esi
add    %edi,%esi
mov    %si,(%r10)
movzwl 0x2(%r9),%ecx
mov    %cx,0x2(%rax)
movzwl 0x2(%r11),%esi
mov    %esi,%edi
xor    %ecx,%edi
shr    %edi
and    $0x777,%edi
and    %ecx,%esi
add    %edi,%esi
mov    %si,0x2(%r10)
movzwl 0x4(%r9),%ecx
mov    %cx,0x4(%rax)
movzwl 0x4(%r11),%esi
mov    %esi,%edi
xor    %ecx,%edi
shr    %edi
and    $0x777,%edi
and    %ecx,%esi
add    %edi,%esi
mov    %si,0x4(%r10)
movzwl 0x6(%r9),%ecx
mov    %cx,0x6(%rax)
movzwl 0x6(%r11),%esi
mov    %esi,%edi
xor    %ecx,%edi
shr    %edi
and    $0x777,%edi
and    %ecx,%esi
add    %edi,%esi
mov    %si,0x6(%r10)
add    $0x8,%r9
add    $0x8,%r11
add    $0x8,%rax
add    $0x8,%r10
lea    -0x4(%rdx),%ecx
cmp    $0x7,%edx
ja     1540 <RGB444toRGB444_ROW2X_COPY+0x440>
test   %ecx,%ecx
je     17c0 <RGB444toRGB444_ROW2X_COPY+0x6c0>
lea    -0x1(%rcx),%r8d
cmp    $0x7,%r8d
jae    161d <RGB444toRGB444_ROW2X_COPY+0x51d>
mov    %r11,%r14
mov    %r10,%r15
mov    %rax,%rdi
mov    %r9,%rbx
test   $0x1,%cl
jne    1727 <RGB444toRGB444_ROW2X_COPY+0x627>
mov    %ecx,%eax
cmp    $0x1,%ecx
jne    175d <RGB444toRGB444_ROW2X_COPY+0x65d>
jmp    17c0 <RGB444toRGB444_ROW2X_COPY+0x6c0>
lea    (%rax,%r8,2),%rsi
add    $0x2,%rsi
lea    (%r10,%r8,2),%rbp
add    $0x2,%rbp
lea    (%r9,%r8,2),%rdi
add    $0x2,%rdi
lea    (%r11,%r8,2),%rbx
add    $0x2,%rbx
cmp    %rbp,%rax
setb   -0x28(%rsp)
cmp    %rsi,%r10
setb   %r14b
cmp    %rdi,%rax
setb   %dl
cmp    %rsi,%r9
setb   %r13b
cmp    %rbx,%rax
setb   %r12b
cmp    %rsi,%r11
setb   %r15b
cmp    %rdi,%r10
setb   %sil
cmp    %rbp,%r9
setb   -0x38(%rsp)
cmp    %rbx,%r10
setb   %dil
cmp    %rbp,%r11
setb   %bl
test   %r14b,-0x28(%rsp)
jne    15f8 <RGB444toRGB444_ROW2X_COPY+0x4f8>
and    %r13b,%dl
jne    15f8 <RGB444toRGB444_ROW2X_COPY+0x4f8>
and    %r15b,%r12b
jne    15f8 <RGB444toRGB444_ROW2X_COPY+0x4f8>
and    -0x38(%rsp),%sil
jne    15f8 <RGB444toRGB444_ROW2X_COPY+0x4f8>
and    %bl,%dil
jne    15f8 <RGB444toRGB444_ROW2X_COPY+0x4f8>
add    $0x1,%r8
mov    %r8,%rdx
and    $0xfffffffffffffff8,%rdx
lea    (%r11,%rdx,2),%r14
lea    (%r10,%rdx,2),%r15
lea    (%rax,%rdx,2),%rdi
lea    (%r9,%rdx,2),%rbx
sub    %edx,%ecx
xor    %esi,%esi
movdqa 0x925(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movdqu (%r9,%rsi,2),%xmm1
movdqu %xmm1,(%rax,%rsi,2)
movdqu (%r11,%rsi,2),%xmm2
movdqa %xmm2,%xmm3
pxor   %xmm1,%xmm3
psrlw  $0x1,%xmm3
pand   %xmm0,%xmm3
pand   %xmm1,%xmm2
paddw  %xmm3,%xmm2
movdqu %xmm2,(%r10,%rsi,2)
add    $0x8,%rsi
cmp    %rsi,%rdx
jne    16e0 <RGB444toRGB444_ROW2X_COPY+0x5e0>
cmp    %rdx,%r8
jne    1604 <RGB444toRGB444_ROW2X_COPY+0x504>
jmp    17c0 <RGB444toRGB444_ROW2X_COPY+0x6c0>
movzwl (%rbx),%eax
add    $0x2,%rbx
mov    %ax,(%rdi)
add    $0x2,%rdi
movzwl (%r14),%edx
mov    %edx,%esi
xor    %eax,%esi
shr    %esi
and    $0x777,%esi
and    %eax,%edx
add    %esi,%edx
add    $0x2,%r14
mov    %dx,(%r15)
add    $0x2,%r15
lea    -0x1(%rcx),%eax
cmp    $0x1,%ecx
je     17c0 <RGB444toRGB444_ROW2X_COPY+0x6c0>
mov    %eax,%eax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzwl (%rbx,%rcx,2),%edx
mov    %dx,(%rdi,%rcx,2)
movzwl (%r14,%rcx,2),%ebp
mov    %ebp,%esi
xor    %edx,%esi
shr    %esi
and    $0x777,%esi
and    %edx,%ebp
add    %esi,%ebp
mov    %bp,(%r15,%rcx,2)
movzwl 0x2(%rbx,%rcx,2),%edx
mov    %dx,0x2(%rdi,%rcx,2)
movzwl 0x2(%r14,%rcx,2),%ebp
mov    %ebp,%esi
xor    %edx,%esi
shr    %esi
and    $0x777,%esi
and    %edx,%ebp
add    %esi,%ebp
mov    %bp,0x2(%r15,%rcx,2)
add    $0x2,%rcx
cmp    %ecx,%eax
jne    1770 <RGB444toRGB444_ROW2X_COPY+0x670>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @RGB444toRGB444_ROW2X_COPY(i8* nocapture %0, i8* nocapture writeonly %1, i8* %2, i32 %3, i8* %4, i32 %5) {
%7 = ptrtoint i8* %2 to i64
%8 = and i64 %7, 3
%9 = icmp eq i64 %8, 0
br i1 %9, label %41, label %10
10: ; preds = %6, %21
%11 = phi i8* [ %34, %21 ], [ %0, %6 ]
%12 = phi i8* [ %36, %21 ], [ %1, %6 ]
%13 = phi i8* [ %26, %21 ], [ %2, %6 ]
%14 = phi i8* [ %24, %21 ], [ %4, %6 ]
%15 = phi i32 [ %37, %21 ], [ %3, %6 ]
%16 = ptrtoint i8* %14 to i64
%17 = and i64 %16, 3
%18 = icmp ne i64 %17, 0
%19 = icmp ne i32 %15, 0
%20 = select i1 %18, i1 %19, i1 false
br i1 %20, label %21, label %41
21: ; preds = %10
%22 = bitcast i8* %14 to i16*
%23 = load i16, i16* %22
%24 = getelementptr inbounds i8, i8* %14, i64 2
%25 = bitcast i8* %13 to i16*
store i16 %23, i16* %25
%26 = getelementptr inbounds i8, i8* %13, i64 2
%27 = bitcast i8* %11 to i16*
%28 = load i16, i16* %27
%29 = xor i16 %28, %23
%30 = lshr i16 %29, 1
%31 = and i16 %30, 1911
%32 = and i16 %28, %23
%33 = add i16 %31, %32
%34 = getelementptr inbounds i8, i8* %11, i64 2
%35 = bitcast i8* %12 to i16*
store i16 %33, i16* %35
%36 = getelementptr inbounds i8, i8* %12, i64 2
%37 = add nsw i32 %15, -1
%38 = ptrtoint i8* %26 to i64
%39 = and i64 %38, 3
%40 = icmp eq i64 %39, 0
br i1 %40, label %41, label %10
41: ; preds = %10, %21, %6
%42 = phi i32 [ %3, %6 ], [ %37, %21 ], [ %15, %10 ]
%43 = phi i8* [ %4, %6 ], [ %24, %21 ], [ %14, %10 ]
%44 = phi i8* [ %2, %6 ], [ %26, %21 ], [ %13, %10 ]
%45 = phi i8* [ %1, %6 ], [ %36, %21 ], [ %12, %10 ]
%46 = phi i8* [ %0, %6 ], [ %34, %21 ], [ %11, %10 ]
%47 = icmp sgt i32 %42, 3
br i1 %47, label %48, label %157
48: ; preds = %41
%49 = add i32 %42, 3
%50 = call i32 @llvm.umin.i32(i32 %42, i32 7)
%51 = sub i32 %49, %50
%52 = lshr i32 %51, 2
%53 = add nuw nsw i32 %52, 1
%54 = zext i32 %53 to i64
%55 = icmp ult i32 %51, 28
br i1 %55, label %151, label %56
56: ; preds = %48
%57 = add i32 %42, 3
%58 = call i32 @llvm.umin.i32(i32 %42, i32 7)
%59 = sub i32 %57, %58
%60 = lshr i32 %59, 2
%61 = zext i32 %60 to i64
%62 = shl nuw nsw i64 %61, 3
%63 = add nuw nsw i64 %62, 8
%64 = getelementptr i8, i8* %44, i64 %63
%65 = getelementptr i8, i8* %45, i64 %63
%66 = getelementptr i8, i8* %43, i64 %63
%67 = getelementptr i8, i8* %46, i64 %63
%68 = icmp ult i8* %44, %65
%69 = icmp ult i8* %45, %64
%70 = and i1 %68, %69
%71 = icmp ult i8* %44, %66
%72 = icmp ult i8* %43, %64
%73 = and i1 %71, %72
%74 = or i1 %70, %73
%75 = icmp ult i8* %44, %67
%76 = icmp ult i8* %46, %64
%77 = and i1 %75, %76
%78 = or i1 %74, %77
%79 = icmp ult i8* %45, %66
%80 = icmp ult i8* %43, %65
%81 = and i1 %79, %80
%82 = or i1 %78, %81
%83 = icmp ult i8* %45, %67
%84 = icmp ult i8* %46, %65
%85 = and i1 %83, %84
%86 = or i1 %82, %85
br i1 %86, label %151, label %87
87: ; preds = %56
%88 = and i64 %54, 2147483640
%89 = shl nuw nsw i64 %88, 3
%90 = getelementptr i8, i8* %46, i64 %89
%91 = shl nuw nsw i64 %88, 3
%92 = getelementptr i8, i8* %45, i64 %91
%93 = shl nuw nsw i64 %88, 3
%94 = getelementptr i8, i8* %44, i64 %93
%95 = shl nuw nsw i64 %88, 3
%96 = getelementptr i8, i8* %43, i64 %95
%97 = trunc i64 %88 to i32
%98 = mul i32 %97, -4
%99 = add i32 %42, %98
br label %100
100: ; preds = %100, %87
%101 = phi i64 [ 0, %87 ], [ %147, %100 ]
%102 = shl i64 %101, 3
%103 = getelementptr i8, i8* %46, i64 %102
%104 = shl i64 %101, 3
%105 = shl i64 %101, 3
%106 = shl i64 %101, 3
%107 = getelementptr i8, i8* %43, i64 %106
%108 = bitcast i8* %107 to <32 x i16>*
%109 = load <32 x i16>, <32 x i16>* %108
%110 = shufflevector <32 x i16> %109, <32 x i16> poison, <8 x i32> <i32 0, i32 4, i32 8, i32 12, i32 16, i32 20, i32 24, i32 28>
%111 = shufflevector <32 x i16> %109, <32 x i16> poison, <8 x i32> <i32 1, i32 5, i32 9, i32 13, i32 17, i32 21, i32 25, i32 29>
%112 = shufflevector <32 x i16> %109, <32 x i16> poison, <8 x i32> <i32 2, i32 6, i32 10, i32 14, i32 18, i32 22, i32 26, i32 30>
%113 = shufflevector <32 x i16> %109, <32 x i16> poison, <8 x i32> <i32 3, i32 7, i32 11, i32 15, i32 19, i32 23, i32 27, i32 31>
%114 = bitcast i8* %103 to <32 x i16>*
%115 = load <32 x i16>, <32 x i16>* %114
%116 = shufflevector <32 x i16> %115, <32 x i16> poison, <8 x i32> <i32 0, i32 4, i32 8, i32 12, i32 16, i32 20, i32 24, i32 28>
%117 = shufflevector <32 x i16> %115, <32 x i16> poison, <8 x i32> <i32 1, i32 5, i32 9, i32 13, i32 17, i32 21, i32 25, i32 29>
%118 = shufflevector <32 x i16> %115, <32 x i16> poison, <8 x i32> <i32 2, i32 6, i32 10, i32 14, i32 18, i32 22, i32 26, i32 30>
%119 = shufflevector <32 x i16> %115, <32 x i16> poison, <8 x i32> <i32 3, i32 7, i32 11, i32 15, i32 19, i32 23, i32 27, i32 31>
%120 = xor <8 x i16> %116, %110
%121 = lshr <8 x i16> %120, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%122 = and <8 x i16> %121, <i16 1911, i16 1911, i16 1911, i16 1911, i16 1911, i16 1911, i16 1911, i16 1911>
%123 = and <8 x i16> %116, %110
%124 = add <8 x i16> %122, %123
%125 = xor <8 x i16> %117, %111
%126 = lshr <8 x i16> %125, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%127 = and <8 x i16> %126, <i16 1911, i16 1911, i16 1911, i16 1911, i16 1911, i16 1911, i16 1911, i16 1911>
%128 = and <8 x i16> %117, %111
%129 = add <8 x i16> %127, %128
%130 = xor <8 x i16> %118, %112
%131 = lshr <8 x i16> %130, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%132 = and <8 x i16> %131, <i16 1911, i16 1911, i16 1911, i16 1911, i16 1911, i16 1911, i16 1911, i16 1911>
%133 = and <8 x i16> %118, %112
%134 = add <8 x i16> %132, %133
%135 = getelementptr inbounds i8, i8* %44, i64 %105
%136 = bitcast i8* %135 to <32 x i16>*
store <32 x i16> %109, <32 x i16>* %136
%137 = xor <8 x i16> %119, %113
%138 = lshr <8 x i16> %137, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%139 = and <8 x i16> %138, <i16 1911, i16 1911, i16 1911, i16 1911, i16 1911, i16 1911, i16 1911, i16 1911>
%140 = and <8 x i16> %119, %113
%141 = add <8 x i16> %139, %140
%142 = getelementptr inbounds i8, i8* %45, i64 %104
%143 = bitcast i8* %142 to <32 x i16>*
%144 = shufflevector <8 x i16> %124, <8 x i16> %129, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
%145 = shufflevector <8 x i16> %134, <8 x i16> %141, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
%146 = shufflevector <16 x i16> %144, <16 x i16> %145, <32 x i32> <i32 0, i32 8, i32 16, i32 24, i32 1, i32 9, i32 17, i32 25, i32 2, i32 10, i32 18, i32 26, i32 3, i32 11, i32 19, i32 27, i32 4, i32 12, i32 20, i32 28, i32 5, i32 13, i32 21, i32 29, i32 6, i32 14, i32 22, i32 30, i32 7, i32 15, i32 23, i32 31>
store <32 x i16> %146, <32 x i16>* %143
%147 = add nuw i64 %101, 8
%148 = icmp eq i64 %147, %88
br i1 %148, label %149, label %100
149: ; preds = %100
%150 = icmp eq i64 %88, %54
br i1 %150, label %157, label %151
151: ; preds = %56, %48, %149
%152 = phi i8* [ %46, %56 ], [ %46, %48 ], [ %90, %149 ]
%153 = phi i8* [ %45, %56 ], [ %45, %48 ], [ %92, %149 ]
%154 = phi i8* [ %44, %56 ], [ %44, %48 ], [ %94, %149 ]
%155 = phi i8* [ %43, %56 ], [ %43, %48 ], [ %96, %149 ]
%156 = phi i32 [ %42, %56 ], [ %42, %48 ], [ %99, %149 ]
br label %266
157: ; preds = %266, %149, %41
%158 = phi i32 [ %42, %41 ], [ %99, %149 ], [ %332, %266 ]
%159 = phi i8* [ %43, %41 ], [ %96, %149 ], [ %328, %266 ]
%160 = phi i8* [ %44, %41 ], [ %94, %149 ], [ %330, %266 ]
%161 = phi i8* [ %45, %41 ], [ %92, %149 ], [ %331, %266 ]
%162 = phi i8* [ %46, %41 ], [ %90, %149 ], [ %329, %266 ]
%163 = icmp eq i32 %158, 0
br i1 %163, label %372, label %164
164: ; preds = %157
%165 = add i32 %158, -1
%166 = zext i32 %165 to i64
%167 = add nuw nsw i64 %166, 1
%168 = icmp ult i32 %165, 7
br i1 %168, label %234, label %169
169: ; preds = %164
%170 = add i32 %158, -1
%171 = zext i32 %170 to i64
%172 = shl nuw nsw i64 %171, 1
%173 = add nuw nsw i64 %172, 2
%174 = getelementptr i8, i8* %160, i64 %173
%175 = getelementptr i8, i8* %161, i64 %173
%176 = getelementptr i8, i8* %159, i64 %173
%177 = getelementptr i8, i8* %162, i64 %173
%178 = icmp ult i8* %160, %175
%179 = icmp ult i8* %161, %174
%180 = and i1 %178, %179
%181 = icmp ult i8* %160, %176
%182 = icmp ult i8* %159, %174
%183 = and i1 %181, %182
%184 = or i1 %180, %183
%185 = icmp ult i8* %160, %177
%186 = icmp ult i8* %162, %174
%187 = and i1 %185, %186
%188 = or i1 %184, %187
%189 = icmp ult i8* %161, %176
%190 = icmp ult i8* %159, %175
%191 = and i1 %189, %190
%192 = or i1 %188, %191
%193 = icmp ult i8* %161, %177
%194 = icmp ult i8* %162, %175
%195 = and i1 %193, %194
%196 = or i1 %192, %195
br i1 %196, label %234, label %197
197: ; preds = %169
%198 = and i64 %167, 8589934584
%199 = shl nuw nsw i64 %198, 1
%200 = getelementptr i8, i8* %162, i64 %199
%201 = shl nuw nsw i64 %198, 1
%202 = getelementptr i8, i8* %161, i64 %201
%203 = shl nuw nsw i64 %198, 1
%204 = getelementptr i8, i8* %160, i64 %203
%205 = shl nuw nsw i64 %198, 1
%206 = getelementptr i8, i8* %159, i64 %205
%207 = trunc i64 %198 to i32
%208 = sub i32 %158, %207
br label %209
209: ; preds = %209, %197
%210 = phi i64 [ 0, %197 ], [ %230, %209 ]
%211 = shl i64 %210, 1
%212 = getelementptr i8, i8* %162, i64 %211
%213 = shl i64 %210, 1
%214 = getelementptr i8, i8* %161, i64 %213
%215 = shl i64 %210, 1
%216 = getelementptr i8, i8* %160, i64 %215
%217 = shl i64 %210, 1
%218 = getelementptr i8, i8* %159, i64 %217
%219 = bitcast i8* %218 to <8 x i16>*
%220 = load <8 x i16>, <8 x i16>* %219
%221 = bitcast i8* %216 to <8 x i16>*
store <8 x i16> %220, <8 x i16>* %221
%222 = bitcast i8* %212 to <8 x i16>*
%223 = load <8 x i16>, <8 x i16>* %222
%224 = xor <8 x i16> %223, %220
%225 = lshr <8 x i16> %224, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%226 = and <8 x i16> %225, <i16 1911, i16 1911, i16 1911, i16 1911, i16 1911, i16 1911, i16 1911, i16 1911>
%227 = and <8 x i16> %223, %220
%228 = add <8 x i16> %226, %227
%229 = bitcast i8* %214 to <8 x i16>*
store <8 x i16> %228, <8 x i16>* %229
%230 = add nuw i64 %210, 8
%231 = icmp eq i64 %230, %198
br i1 %231, label %232, label %209
232: ; preds = %209
%233 = icmp eq i64 %167, %198
br i1 %233, label %372, label %234
234: ; preds = %169, %164, %232
%235 = phi i8* [ %162, %169 ], [ %162, %164 ], [ %200, %232 ]
%236 = phi i8* [ %161, %169 ], [ %161, %164 ], [ %202, %232 ]
%237 = phi i8* [ %160, %169 ], [ %160, %164 ], [ %204, %232 ]
%238 = phi i8* [ %159, %169 ], [ %159, %164 ], [ %206, %232 ]
%239 = phi i32 [ %158, %169 ], [ %158, %164 ], [ %208, %232 ]
%240 = and i32 %239, 1
%241 = icmp eq i32 %240, 0
br i1 %241, label %259, label %242
242: ; preds = %234
%243 = bitcast i8* %238 to i16*
%244 = load i16, i16* %243
%245 = getelementptr inbounds i8, i8* %238, i64 2
%246 = bitcast i8* %237 to i16*
store i16 %244, i16* %246
%247 = getelementptr inbounds i8, i8* %237, i64 2
%248 = bitcast i8* %235 to i16*
%249 = load i16, i16* %248
%250 = xor i16 %249, %244
%251 = lshr i16 %250, 1
%252 = and i16 %251, 1911
%253 = and i16 %249, %244
%254 = add i16 %252, %253
%255 = getelementptr inbounds i8, i8* %235, i64 2
%256 = bitcast i8* %236 to i16*
store i16 %254, i16* %256
%257 = getelementptr inbounds i8, i8* %236, i64 2
%258 = add nsw i32 %239, -1
br label %259
259: ; preds = %242, %234
%260 = phi i8* [ %235, %234 ], [ %255, %242 ]
%261 = phi i8* [ %236, %234 ], [ %257, %242 ]
%262 = phi i8* [ %237, %234 ], [ %247, %242 ]
%263 = phi i8* [ %238, %234 ], [ %245, %242 ]
%264 = phi i32 [ %239, %234 ], [ %258, %242 ]
%265 = icmp eq i32 %239, 1
br i1 %265, label %372, label %334
266: ; preds = %151, %266
%267 = phi i8* [ %329, %266 ], [ %152, %151 ]
%268 = phi i8* [ %331, %266 ], [ %153, %151 ]
%269 = phi i8* [ %330, %266 ], [ %154, %151 ]
%270 = phi i8* [ %328, %266 ], [ %155, %151 ]
%271 = phi i32 [ %332, %266 ], [ %156, %151 ]
%272 = bitcast i8* %270 to i16*
%273 = load i16, i16* %272
%274 = bitcast i8* %269 to i16*
store i16 %273, i16* %274
%275 = bitcast i8* %267 to i16*
%276 = load i16, i16* %275
%277 = xor i16 %276, %273
%278 = lshr i16 %277, 1
%279 = and i16 %278, 1911
%280 = and i16 %276, %273
%281 = add i16 %279, %280
%282 = bitcast i8* %268 to i16*
store i16 %281, i16* %282
%283 = getelementptr inbounds i8, i8* %270, i64 2
%284 = bitcast i8* %283 to i16*
%285 = load i16, i16* %284
%286 = getelementptr inbounds i8, i8* %269, i64 2
%287 = bitcast i8* %286 to i16*
store i16 %285, i16* %287
%288 = getelementptr inbounds i8, i8* %267, i64 2
%289 = bitcast i8* %288 to i16*
%290 = load i16, i16* %289
%291 = xor i16 %290, %285
%292 = lshr i16 %291, 1
%293 = and i16 %292, 1911
%294 = and i16 %290, %285
%295 = add i16 %293, %294
%296 = getelementptr inbounds i8, i8* %268, i64 2
%297 = bitcast i8* %296 to i16*
store i16 %295, i16* %297
%298 = getelementptr inbounds i8, i8* %270, i64 4
%299 = bitcast i8* %298 to i16*
%300 = load i16, i16* %299
%301 = getelementptr inbounds i8, i8* %269, i64 4
%302 = bitcast i8* %301 to i16*
store i16 %300, i16* %302
%303 = getelementptr inbounds i8, i8* %267, i64 4
%304 = bitcast i8* %303 to i16*
%305 = load i16, i16* %304
%306 = xor i16 %305, %300
%307 = lshr i16 %306, 1
%308 = and i16 %307, 1911
%309 = and i16 %305, %300
%310 = add i16 %308, %309
%311 = getelementptr inbounds i8, i8* %268, i64 4
%312 = bitcast i8* %311 to i16*
store i16 %310, i16* %312
%313 = getelementptr inbounds i8, i8* %270, i64 6
%314 = bitcast i8* %313 to i16*
%315 = load i16, i16* %314
%316 = getelementptr inbounds i8, i8* %269, i64 6
%317 = bitcast i8* %316 to i16*
store i16 %315, i16* %317
%318 = getelementptr inbounds i8, i8* %267, i64 6
%319 = bitcast i8* %318 to i16*
%320 = load i16, i16* %319
%321 = xor i16 %320, %315
%322 = lshr i16 %321, 1
%323 = and i16 %322, 1911
%324 = and i16 %320, %315
%325 = add i16 %323, %324
%326 = getelementptr inbounds i8, i8* %268, i64 6
%327 = bitcast i8* %326 to i16*
store i16 %325, i16* %327
%328 = getelementptr inbounds i8, i8* %270, i64 8
%329 = getelementptr inbounds i8, i8* %267, i64 8
%330 = getelementptr inbounds i8, i8* %269, i64 8
%331 = getelementptr inbounds i8, i8* %268, i64 8
%332 = add nsw i32 %271, -4
%333 = icmp ugt i32 %271, 7
br i1 %333, label %266, label %157
334: ; preds = %259, %334
%335 = phi i8* [ %367, %334 ], [ %260, %259 ]
%336 = phi i8* [ %369, %334 ], [ %261, %259 ]
%337 = phi i8* [ %359, %334 ], [ %262, %259 ]
%338 = phi i8* [ %357, %334 ], [ %263, %259 ]
%339 = phi i32 [ %370, %334 ], [ %264, %259 ]
%340 = bitcast i8* %338 to i16*
%341 = load i16, i16* %340
%342 = getelementptr inbounds i8, i8* %338, i64 2
%343 = bitcast i8* %337 to i16*
store i16 %341, i16* %343
%344 = getelementptr inbounds i8, i8* %337, i64 2
%345 = bitcast i8* %335 to i16*
%346 = load i16, i16* %345
%347 = xor i16 %346, %341
%348 = lshr i16 %347, 1
%349 = and i16 %348, 1911
%350 = and i16 %346, %341
%351 = add i16 %349, %350
%352 = getelementptr inbounds i8, i8* %335, i64 2
%353 = bitcast i8* %336 to i16*
store i16 %351, i16* %353
%354 = getelementptr inbounds i8, i8* %336, i64 2
%355 = bitcast i8* %342 to i16*
%356 = load i16, i16* %355
%357 = getelementptr inbounds i8, i8* %338, i64 4
%358 = bitcast i8* %344 to i16*
store i16 %356, i16* %358
%359 = getelementptr inbounds i8, i8* %337, i64 4
%360 = bitcast i8* %352 to i16*
%361 = load i16, i16* %360
%362 = xor i16 %361, %356
%363 = lshr i16 %362, 1
%364 = and i16 %363, 1911
%365 = and i16 %361, %356
%366 = add i16 %364, %365
%367 = getelementptr inbounds i8, i8* %335, i64 4
%368 = bitcast i8* %354 to i16*
store i16 %366, i16* %368
%369 = getelementptr inbounds i8, i8* %336, i64 4
%370 = add nsw i32 %339, -2
%371 = icmp eq i32 %370, 0
br i1 %371, label %372, label %334
372: ; preds = %259, %334, %232, %157
ret void
}