void RGB32toRGB444_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 int *)(s);
    da_rgb =
        ((8 + 4 < 8) ? (((((16 + 8 < 8) ? ((sa_rgb << ((8 - (16 + 8)) & 0x1F)) &
                                           (0x100 - (1U << (8 - 8))))
                                        : ((sa_rgb >> (((16 + 8) - 8) & 0x1F)) &
                                           (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4)))) >>
                        ((8 - (8 + 4)) & 0x1F))
                     : (((((16 + 8 < 8) ? ((sa_rgb << ((8 - (16 + 8)) & 0x1F)) &
                                           (0x100 - (1U << (8 - 8))))
                                        : ((sa_rgb >> (((16 + 8) - 8) & 0x1F)) &
                                           (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4))))
                        << (((8 + 4) - 8) & 0x1F))) |
        ((4 + 4 < 8) ? (((((8 + 8 < 8) ? ((sa_rgb << ((8 - (8 + 8)) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8))))
                                       : ((sa_rgb >> (((8 + 8) - 8) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4)))) >>
                        ((8 - (4 + 4)) & 0x1F))
                     : (((((8 + 8 < 8) ? ((sa_rgb << ((8 - (8 + 8)) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8))))
                                       : ((sa_rgb >> (((8 + 8) - 8) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4))))
                        << (((4 + 4) - 8) & 0x1F))) |
        ((0 + 4 < 8) ? (((((0 + 8 < 8) ? ((sa_rgb << ((8 - (0 + 8)) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8))))
                                       : ((sa_rgb >> (((0 + 8) - 8) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4)))) >>
                        ((8 - (0 + 4)) & 0x1F))
                     : (((((0 + 8 < 8) ? ((sa_rgb << ((8 - (0 + 8)) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8))))
                                       : ((sa_rgb >> (((0 + 8) - 8) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4))))
                        << (((0 + 4) - 8) & 0x1F)));
    s += 4;
    *(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 int *)(s);
    da_rgb =
        ((8 + 4 < 8) ? (((((16 + 8 < 8) ? ((sa_rgb << ((8 - (16 + 8)) & 0x1F)) &
                                           (0x100 - (1U << (8 - 8))))
                                        : ((sa_rgb >> (((16 + 8) - 8) & 0x1F)) &
                                           (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4)))) >>
                        ((8 - (8 + 4)) & 0x1F))
                     : (((((16 + 8 < 8) ? ((sa_rgb << ((8 - (16 + 8)) & 0x1F)) &
                                           (0x100 - (1U << (8 - 8))))
                                        : ((sa_rgb >> (((16 + 8) - 8) & 0x1F)) &
                                           (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4))))
                        << (((8 + 4) - 8) & 0x1F))) |
        ((4 + 4 < 8) ? (((((8 + 8 < 8) ? ((sa_rgb << ((8 - (8 + 8)) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8))))
                                       : ((sa_rgb >> (((8 + 8) - 8) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4)))) >>
                        ((8 - (4 + 4)) & 0x1F))
                     : (((((8 + 8 < 8) ? ((sa_rgb << ((8 - (8 + 8)) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8))))
                                       : ((sa_rgb >> (((8 + 8) - 8) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4))))
                        << (((4 + 4) - 8) & 0x1F))) |
        ((0 + 4 < 8) ? (((((0 + 8 < 8) ? ((sa_rgb << ((8 - (0 + 8)) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8))))
                                       : ((sa_rgb >> (((0 + 8) - 8) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4)))) >>
                        ((8 - (0 + 4)) & 0x1F))
                     : (((((0 + 8 < 8) ? ((sa_rgb << ((8 - (0 + 8)) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8))))
                                       : ((sa_rgb >> (((0 + 8) - 8) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4))))
                        << (((0 + 4) - 8) & 0x1F)));
    *(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 int *)(s + 4);
    da_rgb =
        ((8 + 4 < 8) ? (((((16 + 8 < 8) ? ((sa_rgb << ((8 - (16 + 8)) & 0x1F)) &
                                           (0x100 - (1U << (8 - 8))))
                                        : ((sa_rgb >> (((16 + 8) - 8) & 0x1F)) &
                                           (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4)))) >>
                        ((8 - (8 + 4)) & 0x1F))
                     : (((((16 + 8 < 8) ? ((sa_rgb << ((8 - (16 + 8)) & 0x1F)) &
                                           (0x100 - (1U << (8 - 8))))
                                        : ((sa_rgb >> (((16 + 8) - 8) & 0x1F)) &
                                           (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4))))
                        << (((8 + 4) - 8) & 0x1F))) |
        ((4 + 4 < 8) ? (((((8 + 8 < 8) ? ((sa_rgb << ((8 - (8 + 8)) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8))))
                                       : ((sa_rgb >> (((8 + 8) - 8) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4)))) >>
                        ((8 - (4 + 4)) & 0x1F))
                     : (((((8 + 8 < 8) ? ((sa_rgb << ((8 - (8 + 8)) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8))))
                                       : ((sa_rgb >> (((8 + 8) - 8) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4))))
                        << (((4 + 4) - 8) & 0x1F))) |
        ((0 + 4 < 8) ? (((((0 + 8 < 8) ? ((sa_rgb << ((8 - (0 + 8)) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8))))
                                       : ((sa_rgb >> (((0 + 8) - 8) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4)))) >>
                        ((8 - (0 + 4)) & 0x1F))
                     : (((((0 + 8 < 8) ? ((sa_rgb << ((8 - (0 + 8)) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8))))
                                       : ((sa_rgb >> (((0 + 8) - 8) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4))))
                        << (((0 + 4) - 8) & 0x1F)));
    *(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 int *)(s + 2 * 4);
    da_rgb =
        ((8 + 4 < 8) ? (((((16 + 8 < 8) ? ((sa_rgb << ((8 - (16 + 8)) & 0x1F)) &
                                           (0x100 - (1U << (8 - 8))))
                                        : ((sa_rgb >> (((16 + 8) - 8) & 0x1F)) &
                                           (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4)))) >>
                        ((8 - (8 + 4)) & 0x1F))
                     : (((((16 + 8 < 8) ? ((sa_rgb << ((8 - (16 + 8)) & 0x1F)) &
                                           (0x100 - (1U << (8 - 8))))
                                        : ((sa_rgb >> (((16 + 8) - 8) & 0x1F)) &
                                           (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4))))
                        << (((8 + 4) - 8) & 0x1F))) |
        ((4 + 4 < 8) ? (((((8 + 8 < 8) ? ((sa_rgb << ((8 - (8 + 8)) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8))))
                                       : ((sa_rgb >> (((8 + 8) - 8) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4)))) >>
                        ((8 - (4 + 4)) & 0x1F))
                     : (((((8 + 8 < 8) ? ((sa_rgb << ((8 - (8 + 8)) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8))))
                                       : ((sa_rgb >> (((8 + 8) - 8) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4))))
                        << (((4 + 4) - 8) & 0x1F))) |
        ((0 + 4 < 8) ? (((((0 + 8 < 8) ? ((sa_rgb << ((8 - (0 + 8)) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8))))
                                       : ((sa_rgb >> (((0 + 8) - 8) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4)))) >>
                        ((8 - (0 + 4)) & 0x1F))
                     : (((((0 + 8 < 8) ? ((sa_rgb << ((8 - (0 + 8)) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8))))
                                       : ((sa_rgb >> (((0 + 8) - 8) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4))))
                        << (((0 + 4) - 8) & 0x1F)));
    *(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 int *)(s + 3 * 4);
    da_rgb =
        ((8 + 4 < 8) ? (((((16 + 8 < 8) ? ((sa_rgb << ((8 - (16 + 8)) & 0x1F)) &
                                           (0x100 - (1U << (8 - 8))))
                                        : ((sa_rgb >> (((16 + 8) - 8) & 0x1F)) &
                                           (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4)))) >>
                        ((8 - (8 + 4)) & 0x1F))
                     : (((((16 + 8 < 8) ? ((sa_rgb << ((8 - (16 + 8)) & 0x1F)) &
                                           (0x100 - (1U << (8 - 8))))
                                        : ((sa_rgb >> (((16 + 8) - 8) & 0x1F)) &
                                           (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4))))
                        << (((8 + 4) - 8) & 0x1F))) |
        ((4 + 4 < 8) ? (((((8 + 8 < 8) ? ((sa_rgb << ((8 - (8 + 8)) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8))))
                                       : ((sa_rgb >> (((8 + 8) - 8) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4)))) >>
                        ((8 - (4 + 4)) & 0x1F))
                     : (((((8 + 8 < 8) ? ((sa_rgb << ((8 - (8 + 8)) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8))))
                                       : ((sa_rgb >> (((8 + 8) - 8) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4))))
                        << (((4 + 4) - 8) & 0x1F))) |
        ((0 + 4 < 8) ? (((((0 + 8 < 8) ? ((sa_rgb << ((8 - (0 + 8)) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8))))
                                       : ((sa_rgb >> (((0 + 8) - 8) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4)))) >>
                        ((8 - (0 + 4)) & 0x1F))
                     : (((((0 + 8 < 8) ? ((sa_rgb << ((8 - (0 + 8)) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8))))
                                       : ((sa_rgb >> (((0 + 8) - 8) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4))))
                        << (((0 + 4) - 8) & 0x1F)));
    *(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 += 4 * 4;
    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 int *)(s);
    da_rgb =
        ((8 + 4 < 8) ? (((((16 + 8 < 8) ? ((sa_rgb << ((8 - (16 + 8)) & 0x1F)) &
                                           (0x100 - (1U << (8 - 8))))
                                        : ((sa_rgb >> (((16 + 8) - 8) & 0x1F)) &
                                           (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4)))) >>
                        ((8 - (8 + 4)) & 0x1F))
                     : (((((16 + 8 < 8) ? ((sa_rgb << ((8 - (16 + 8)) & 0x1F)) &
                                           (0x100 - (1U << (8 - 8))))
                                        : ((sa_rgb >> (((16 + 8) - 8) & 0x1F)) &
                                           (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4))))
                        << (((8 + 4) - 8) & 0x1F))) |
        ((4 + 4 < 8) ? (((((8 + 8 < 8) ? ((sa_rgb << ((8 - (8 + 8)) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8))))
                                       : ((sa_rgb >> (((8 + 8) - 8) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4)))) >>
                        ((8 - (4 + 4)) & 0x1F))
                     : (((((8 + 8 < 8) ? ((sa_rgb << ((8 - (8 + 8)) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8))))
                                       : ((sa_rgb >> (((8 + 8) - 8) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4))))
                        << (((4 + 4) - 8) & 0x1F))) |
        ((0 + 4 < 8) ? (((((0 + 8 < 8) ? ((sa_rgb << ((8 - (0 + 8)) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8))))
                                       : ((sa_rgb >> (((0 + 8) - 8) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4)))) >>
                        ((8 - (0 + 4)) & 0x1F))
                     : (((((0 + 8 < 8) ? ((sa_rgb << ((8 - (0 + 8)) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8))))
                                       : ((sa_rgb >> (((0 + 8) - 8) & 0x1F)) &
                                          (0x100 - (1U << (8 - 8)))))) &
                         (0x100 - (1U << (8 - 4))))
                        << (((0 + 4) - 8) & 0x1F)));
    s += 4;
    *(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):
<RGB32toRGB444_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 <RGB32toRGB444_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 <RGB32toRGB444_ROW2X_COPY+0x79>
cmpl   $0x0,-0x54(%rbp)
setne  %al
mov    %al,-0x79(%rbp)
mov    -0x79(%rbp),%al
test   $0x1,%al
jne    1189 <RGB32toRGB444_ROW2X_COPY+0x89>
jmp    1251 <RGB32toRGB444_ROW2X_COPY+0x151>
mov    -0x50(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
and    $0xf0,%eax
shl    $0x4,%eax
mov    -0x5c(%rbp),%ecx
shr    $0x8,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shl    $0x0,%ecx
or     %ecx,%eax
mov    -0x5c(%rbp),%ecx
shr    $0x0,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shr    $0x4,%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x50(%rbp),%rax
add    $0x4,%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 <RGB32toRGB444_ROW2X_COPY+0x41>
jmp    1256 <RGB32toRGB444_ROW2X_COPY+0x156>
cmpl   $0x4,-0x54(%rbp)
jl     14d2 <RGB32toRGB444_ROW2X_COPY+0x3d2>
mov    -0x50(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
and    $0xf0,%eax
shl    $0x4,%eax
mov    -0x68(%rbp),%ecx
shr    $0x8,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shl    $0x0,%ecx
or     %ecx,%eax
mov    -0x68(%rbp),%ecx
shr    $0x0,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shr    $0x4,%ecx
or     %ecx,%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
mov    0x4(%rax),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
and    $0xf0,%eax
shl    $0x4,%eax
mov    -0x68(%rbp),%ecx
shr    $0x8,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shl    $0x0,%ecx
or     %ecx,%eax
mov    -0x68(%rbp),%ecx
shr    $0x0,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shr    $0x4,%ecx
or     %ecx,%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
mov    0x8(%rax),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
and    $0xf0,%eax
shl    $0x4,%eax
mov    -0x68(%rbp),%ecx
shr    $0x8,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shl    $0x0,%ecx
or     %ecx,%eax
mov    -0x68(%rbp),%ecx
shr    $0x0,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shr    $0x4,%ecx
or     %ecx,%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
mov    0xc(%rax),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
and    $0xf0,%eax
shl    $0x4,%eax
mov    -0x68(%rbp),%ecx
shr    $0x8,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shl    $0x0,%ecx
or     %ecx,%eax
mov    -0x68(%rbp),%ecx
shr    $0x0,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shr    $0x4,%ecx
or     %ecx,%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    $0x10,%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    1256 <RGB32toRGB444_ROW2X_COPY+0x156>
jmp    14d7 <RGB32toRGB444_ROW2X_COPY+0x3d7>
cmpl   $0x0,-0x54(%rbp)
je     15a9 <RGB32toRGB444_ROW2X_COPY+0x4a9>
mov    -0x50(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
and    $0xf0,%eax
shl    $0x4,%eax
mov    -0x74(%rbp),%ecx
shr    $0x8,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shl    $0x0,%ecx
or     %ecx,%eax
mov    -0x74(%rbp),%ecx
shr    $0x0,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shr    $0x4,%ecx
or     %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x50(%rbp),%rax
add    $0x4,%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    14d7 <RGB32toRGB444_ROW2X_COPY+0x3d7>
pop    %rbp
ret

x86 assembly (clang, -O2):
<RGB32toRGB444_ROW2X_COPY>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
test   $0x3,%dl
je     150a <RGB32toRGB444_ROW2X_COPY+0x40a>
lea    0x2(%rdx),%r9
xor    %r14d,%r14d
mov    %r8,%r10
mov    %r8,%r11
xchg   %ax,%ax
test   $0x3,%r10b
je     1183 <RGB32toRGB444_ROW2X_COPY+0x83>
test   %ecx,%ecx
je     1183 <RGB32toRGB444_ROW2X_COPY+0x83>
mov    (%r8,%r14,2),%ebx
mov    %ebx,%ebp
shr    $0xc,%ebp
and    $0xf00,%ebp
mov    %ebx,%eax
shr    $0x8,%eax
and    $0xf0,%eax
or     %ebp,%eax
shr    $0x4,%ebx
and    $0xf,%ebx
or     %eax,%ebx
add    $0x4,%r11
mov    %bx,(%rdx,%r14,1)
movzwl (%rdi,%r14,1),%eax
mov    %ebx,%ebp
xor    %eax,%ebp
shr    %ebp
and    $0x777,%ebp
and    %eax,%ebx
add    %ebp,%ebx
mov    %bx,(%rsi,%r14,1)
add    $0xffffffff,%ecx
lea    (%r9,%r14,1),%eax
add    $0x2,%r14
add    $0x4,%r10
test   $0x3,%al
jne    1120 <RGB32toRGB444_ROW2X_COPY+0x20>
add    %r14,%rdi
add    %r14,%rsi
add    %r14,%rdx
cmp    $0x4,%ecx
jl     1516 <RGB32toRGB444_ROW2X_COPY+0x416>
xor    %eax,%eax
mov    %ecx,%r14d
sub    $0x7,%r14d
cmovb  %eax,%r14d
add    $0x3,%r14d
cmp    $0xc,%r14d
jb     1527 <RGB32toRGB444_ROW2X_COPY+0x427>
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    (%rdi,%rbp,8),%rbp
add    $0x8,%rbp
cmp    %rax,%rdx
setb   %r15b
cmp    %rbx,%rsi
setb   %r12b
cmp    %rbp,%rdx
setb   %r10b
cmp    %rbx,%rdi
setb   %r8b
cmp    %rbp,%rsi
setb   %bl
cmp    %rax,%rdi
setb   %r9b
test   %r12b,%r15b
jne    1527 <RGB32toRGB444_ROW2X_COPY+0x427>
and    %r8b,%r10b
jne    1527 <RGB32toRGB444_ROW2X_COPY+0x427>
and    %r9b,%bl
jne    1527 <RGB32toRGB444_ROW2X_COPY+0x427>
shr    $0x2,%r14d
add    $0x1,%r14d
mov    %r14d,%r15d
and    $0xfffffffc,%r15d
lea    (%rdi,%r15,8),%r10
lea    (%rsi,%r15,8),%r9
lea    (%rdx,%r15,8),%rax
mov    %r15,%r8
shl    $0x4,%r8
add    %r11,%r8
lea    0x0(,%r15,4),%ebx
sub    %ebx,%ecx
xor    %ebx,%ebx
movdqa 0xdac(%rip),%xmm8
movdqa 0xdb3(%rip),%xmm9
movdqa 0xdba(%rip),%xmm10
pxor   %xmm11,%xmm11
movdqa 0xdbc(%rip),%xmm12
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu (%r11),%xmm1
movdqu 0x10(%r11),%xmm0
movdqu 0x20(%r11),%xmm2
movdqu 0x30(%r11),%xmm3
movdqa %xmm2,%xmm4
punpckldq %xmm3,%xmm4
movdqa %xmm1,%xmm5
punpckldq %xmm0,%xmm5
movdqa %xmm5,%xmm6
punpcklqdq %xmm4,%xmm6
punpckhqdq %xmm4,%xmm5
punpckhdq %xmm3,%xmm2
punpckhdq %xmm0,%xmm1
movdqa %xmm1,%xmm0
punpcklqdq %xmm2,%xmm0
punpckhqdq %xmm2,%xmm1
movdqa %xmm6,%xmm2
psrld  $0xc,%xmm2
pand   %xmm8,%xmm2
movdqa %xmm6,%xmm3
psrld  $0x8,%xmm3
pand   %xmm9,%xmm3
por    %xmm2,%xmm3
psrld  $0x4,%xmm6
pand   %xmm10,%xmm6
por    %xmm3,%xmm6
movdqu (%rdi,%rbx,8),%xmm14
movdqu 0x10(%rdi,%rbx,8),%xmm3
pshufd $0xe8,%xmm3,%xmm4
pshuflw $0xe8,%xmm4,%xmm13
pshufd $0xe8,%xmm14,%xmm2
pshuflw $0xe8,%xmm2,%xmm15
punpckldq %xmm13,%xmm15
pshuflw $0xed,%xmm4,%xmm13
pshuflw $0xed,%xmm2,%xmm4
punpckldq %xmm13,%xmm4
pshufd $0xe7,%xmm3,%xmm3
pshuflw $0xe2,%xmm3,%xmm13
pshufd $0xe7,%xmm14,%xmm7
pshuflw $0xe2,%xmm7,%xmm2
punpckldq %xmm13,%xmm2
pshuflw $0xe7,%xmm3,%xmm13
pshuflw $0xe7,%xmm7,%xmm14
punpckldq %xmm13,%xmm14
punpcklwd %xmm11,%xmm15
movdqa %xmm6,%xmm7
pxor   %xmm15,%xmm7
psrld  $0x1,%xmm7
pand   %xmm12,%xmm7
pand   %xmm6,%xmm15
paddd  %xmm7,%xmm15
movdqa %xmm5,%xmm7
psrld  $0xc,%xmm7
pand   %xmm8,%xmm7
movdqa %xmm5,%xmm3
psrld  $0x8,%xmm3
pand   %xmm9,%xmm3
por    %xmm7,%xmm3
psrld  $0x4,%xmm5
pand   %xmm10,%xmm5
por    %xmm3,%xmm5
punpcklwd %xmm11,%xmm4
movdqa %xmm5,%xmm3
pxor   %xmm4,%xmm3
psrld  $0x1,%xmm3
pand   %xmm12,%xmm3
pand   %xmm5,%xmm4
paddd  %xmm3,%xmm4
packssdw %xmm4,%xmm15
movdqa %xmm0,%xmm3
psrld  $0xc,%xmm3
pand   %xmm8,%xmm3
movdqa %xmm0,%xmm4
psrld  $0x8,%xmm4
pand   %xmm9,%xmm4
por    %xmm3,%xmm4
psrld  $0x4,%xmm0
pand   %xmm10,%xmm0
por    %xmm4,%xmm0
punpcklwd %xmm11,%xmm2
movdqa %xmm0,%xmm3
pxor   %xmm2,%xmm3
psrld  $0x1,%xmm3
pand   %xmm12,%xmm3
pand   %xmm0,%xmm2
paddd  %xmm3,%xmm2
movdqa %xmm1,%xmm3
psrld  $0xc,%xmm3
pand   %xmm8,%xmm3
movdqa %xmm1,%xmm4
psrld  $0x8,%xmm4
pand   %xmm9,%xmm4
por    %xmm3,%xmm4
psrld  $0x4,%xmm1
pand   %xmm10,%xmm1
por    %xmm4,%xmm1
packssdw %xmm5,%xmm6
packssdw %xmm1,%xmm0
pshufd $0xe8,%xmm0,%xmm3
pshuflw $0xd8,%xmm3,%xmm3
pshufd $0xe8,%xmm6,%xmm4
pshuflw $0xd8,%xmm4,%xmm4
punpckldq %xmm3,%xmm4
pshufd $0xe7,%xmm0,%xmm0
pshuflw $0x72,%xmm0,%xmm0
pshufd $0xe7,%xmm6,%xmm3
pshuflw $0x72,%xmm3,%xmm3
punpckldq %xmm0,%xmm3
movdqu %xmm3,0x10(%rdx,%rbx,8)
movdqu %xmm4,(%rdx,%rbx,8)
punpcklwd %xmm11,%xmm14
movdqa %xmm1,%xmm0
pxor   %xmm14,%xmm0
psrld  $0x1,%xmm0
pand   %xmm12,%xmm0
pand   %xmm1,%xmm14
paddd  %xmm0,%xmm14
packssdw %xmm14,%xmm2
pshufd $0xe8,%xmm2,%xmm0
pshuflw $0xd8,%xmm0,%xmm0
pshufd $0xe8,%xmm15,%xmm1
pshuflw $0xd8,%xmm1,%xmm1
punpckldq %xmm0,%xmm1
pshufd $0xe7,%xmm2,%xmm0
pshuflw $0x72,%xmm0,%xmm0
pshufd $0xe7,%xmm15,%xmm2
pshuflw $0x72,%xmm2,%xmm2
punpckldq %xmm0,%xmm2
movdqu %xmm2,0x10(%rsi,%rbx,8)
movdqu %xmm1,(%rsi,%rbx,8)
add    $0x4,%rbx
add    $0x40,%r11
cmp    %rbx,%r15
jne    1280 <RGB32toRGB444_ROW2X_COPY+0x180>
cmp    %r14,%r15
jne    1540 <RGB32toRGB444_ROW2X_COPY+0x440>
jmp    1662 <RGB32toRGB444_ROW2X_COPY+0x562>
mov    %r8,%r11
cmp    $0x4,%ecx
jge    1195 <RGB32toRGB444_ROW2X_COPY+0x95>
mov    %r11,%r8
mov    %rdx,%rax
mov    %rsi,%r9
mov    %rdi,%r10
jmp    1662 <RGB32toRGB444_ROW2X_COPY+0x562>
mov    %rdi,%r10
mov    %rsi,%r9
mov    %rdx,%rax
mov    %r11,%r8
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ecx,%edx
mov    (%r8),%ecx
mov    %ecx,%esi
shr    $0xc,%esi
and    $0xf00,%esi
mov    %ecx,%edi
shr    $0x8,%edi
and    $0xf0,%edi
or     %esi,%edi
shr    $0x4,%ecx
and    $0xf,%ecx
or     %edi,%ecx
mov    %cx,(%rax)
movzwl (%r10),%esi
mov    %ecx,%edi
xor    %esi,%edi
shr    %edi
and    $0x777,%edi
and    %esi,%ecx
add    %edi,%ecx
mov    %cx,(%r9)
mov    0x4(%r8),%ecx
mov    %ecx,%esi
shr    $0xc,%esi
and    $0xf00,%esi
mov    %ecx,%edi
shr    $0x8,%edi
and    $0xf0,%edi
or     %esi,%edi
shr    $0x4,%ecx
and    $0xf,%ecx
or     %edi,%ecx
mov    %cx,0x2(%rax)
movzwl 0x2(%r10),%esi
mov    %ecx,%edi
xor    %esi,%edi
shr    %edi
and    $0x777,%edi
and    %esi,%ecx
add    %edi,%ecx
mov    %cx,0x2(%r9)
mov    0x8(%r8),%ecx
mov    %ecx,%esi
shr    $0xc,%esi
and    $0xf00,%esi
mov    %ecx,%edi
shr    $0x8,%edi
and    $0xf0,%edi
or     %esi,%edi
shr    $0x4,%ecx
and    $0xf,%ecx
or     %edi,%ecx
mov    %cx,0x4(%rax)
movzwl 0x4(%r10),%esi
mov    %ecx,%edi
xor    %esi,%edi
shr    %edi
and    $0x777,%edi
and    %esi,%ecx
add    %edi,%ecx
mov    %cx,0x4(%r9)
mov    0xc(%r8),%ecx
mov    %ecx,%esi
shr    $0xc,%esi
and    $0xf00,%esi
mov    %ecx,%edi
shr    $0x8,%edi
and    $0xf0,%edi
or     %esi,%edi
shr    $0x4,%ecx
and    $0xf,%ecx
or     %edi,%ecx
mov    %cx,0x6(%rax)
movzwl 0x6(%r10),%esi
mov    %ecx,%edi
xor    %esi,%edi
shr    %edi
and    $0x777,%edi
and    %esi,%ecx
add    %edi,%ecx
mov    %cx,0x6(%r9)
add    $0x10,%r8
add    $0x8,%r10
add    $0x8,%rax
add    $0x8,%r9
lea    -0x4(%rdx),%ecx
cmp    $0x7,%edx
ja     1540 <RGB32toRGB444_ROW2X_COPY+0x440>
test   %ecx,%ecx
je     16c9 <RGB32toRGB444_ROW2X_COPY+0x5c9>
lea    -0x1(%rcx),%r11d
cmp    $0x3,%r11d
jae    16d2 <RGB32toRGB444_ROW2X_COPY+0x5d2>
mov    %r10,%r15
mov    %r9,%r12
mov    %rax,%rdi
mov    %r8,%rbx
mov    %ecx,%eax
xor    %ecx,%ecx
mov    (%rbx,%rcx,4),%edx
mov    %edx,%ebp
shr    $0xc,%ebp
and    $0xf00,%ebp
mov    %edx,%esi
shr    $0x8,%esi
and    $0xf0,%esi
or     %ebp,%esi
shr    $0x4,%edx
and    $0xf,%edx
or     %esi,%edx
mov    %dx,(%rdi,%rcx,2)
movzwl (%r15,%rcx,2),%esi
mov    %edx,%ebp
xor    %esi,%ebp
shr    %ebp
and    $0x777,%ebp
and    %esi,%edx
add    %ebp,%edx
mov    %dx,(%r12,%rcx,2)
add    $0x1,%rcx
cmp    %ecx,%eax
jne    1680 <RGB32toRGB444_ROW2X_COPY+0x580>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
lea    (%rax,%r11,2),%rsi
add    $0x2,%rsi
lea    (%r9,%r11,2),%rdi
add    $0x2,%rdi
lea    (%r10,%r11,2),%rbx
add    $0x2,%rbx
cmp    %rdi,%rax
setb   %bpl
cmp    %rsi,%r9
setb   %r14b
cmp    %rbx,%rax
setb   %dl
cmp    %rsi,%r10
setb   %sil
cmp    %rbx,%r9
setb   %bl
cmp    %rdi,%r10
setb   %dil
test   %r14b,%bpl
jne    1670 <RGB32toRGB444_ROW2X_COPY+0x570>
and    %sil,%dl
jne    1670 <RGB32toRGB444_ROW2X_COPY+0x570>
and    %dil,%bl
jne    1670 <RGB32toRGB444_ROW2X_COPY+0x570>
add    $0x1,%r11
mov    %r11,%r14
and    $0xfffffffffffffffc,%r14
lea    (%r10,%r14,2),%r15
lea    (%r9,%r14,2),%r12
lea    (%rax,%r14,2),%rdi
lea    (%r8,%r14,4),%rbx
sub    %r14d,%ecx
xor    %edx,%edx
movdqa 0x8ab(%rip),%xmm0
movdqa 0x8b3(%rip),%xmm1
movdqa 0x8bb(%rip),%xmm2
pxor   %xmm3,%xmm3
movdqa 0x8bf(%rip),%xmm4
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu (%r8,%rdx,4),%xmm5
movdqa %xmm5,%xmm6
psrld  $0xc,%xmm6
pand   %xmm0,%xmm6
movdqa %xmm5,%xmm7
psrld  $0x8,%xmm7
pand   %xmm1,%xmm7
por    %xmm6,%xmm7
psrld  $0x4,%xmm5
pand   %xmm2,%xmm5
por    %xmm7,%xmm5
movdqa %xmm5,%xmm6
packssdw %xmm6,%xmm6
movq   %xmm6,(%rax,%rdx,2)
movq   (%r10,%rdx,2),%xmm6
punpcklwd %xmm3,%xmm6
movdqa %xmm5,%xmm7
pxor   %xmm6,%xmm7
psrld  $0x1,%xmm7
pand   %xmm4,%xmm7
pand   %xmm5,%xmm6
paddd  %xmm7,%xmm6
packssdw %xmm6,%xmm6
movq   %xmm6,(%r9,%rdx,2)
add    $0x4,%rdx
cmp    %rdx,%r14
jne    1780 <RGB32toRGB444_ROW2X_COPY+0x680>
cmp    %r14,%r11
jne    167c <RGB32toRGB444_ROW2X_COPY+0x57c>
jmp    16c9 <RGB32toRGB444_ROW2X_COPY+0x5c9>

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

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