void RGB32toRGB444_ROW_COPY(unsigned char *dest_ptr, int dest_dx,
                            unsigned char *src_ptr, int src_dx) {
  register unsigned char *d = dest_ptr;
  register unsigned char *s = src_ptr;
  register int count = dest_dx;
  while (((unsigned int)d & 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 *)(d) = da_rgb;
    d += 2;
    count--;
  }
  while (count >= 4) {
    register unsigned int da_rgb;
    register unsigned int sa_rgb;
    sa_rgb = *(unsigned int *)(s);
    da_rgb = ((0) ? (((((0) ? ((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))
                  : (((((0) ? ((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))) |
             ((0) ? (((((0) ? ((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))
                  : (((((0) ? ((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))) |
             ((1) ? (((((0) ? ((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) ? ((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 *)(d) = 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 *)(d + 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 *)(d + 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 *)(d + 3 * 2) = da_rgb;
    s += 4 * 4;
    d += 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 *)(d) = da_rgb;
    d += 2;
    count--;
  }
}


x86 assembly (clang, -O0):
<RGB32toRGB444_ROW_COPY>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%rax
mov    %eax,%ecx
and    $0x3,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x4d(%rbp)
je     1160 <RGB32toRGB444_ROW_COPY+0x60>
mov    -0x30(%rbp),%rax
mov    %eax,%ecx
and    $0x3,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x4d(%rbp)
je     1160 <RGB32toRGB444_ROW_COPY+0x60>
cmpl   $0x0,-0x34(%rbp)
setne  %al
mov    %al,-0x4d(%rbp)
mov    -0x4d(%rbp),%al
test   $0x1,%al
jne    1170 <RGB32toRGB444_ROW_COPY+0x70>
jmp    11f0 <RGB32toRGB444_ROW_COPY+0xf0>
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
and    $0xf0,%eax
shl    $0x4,%eax
mov    -0x3c(%rbp),%ecx
shr    $0x8,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shl    $0x0,%ecx
or     %ecx,%eax
mov    -0x3c(%rbp),%ecx
shr    $0x0,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shr    $0x4,%ecx
or     %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%eax
mov    %ax,%cx
mov    -0x28(%rbp),%rax
mov    %cx,(%rax)
mov    -0x28(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x28(%rbp)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1128 <RGB32toRGB444_ROW_COPY+0x28>
jmp    11f5 <RGB32toRGB444_ROW_COPY+0xf5>
cmpl   $0x4,-0x34(%rbp)
jl     1393 <RGB32toRGB444_ROW_COPY+0x293>
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
and    $0xf0,%eax
shl    $0x4,%eax
mov    -0x44(%rbp),%ecx
shr    $0x8,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shl    $0x0,%ecx
or     %ecx,%eax
mov    -0x44(%rbp),%ecx
shr    $0x0,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shr    $0x4,%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    %ax,%cx
mov    -0x28(%rbp),%rax
mov    %cx,(%rax)
mov    -0x30(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
and    $0xf0,%eax
shl    $0x4,%eax
mov    -0x44(%rbp),%ecx
shr    $0x8,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shl    $0x0,%ecx
or     %ecx,%eax
mov    -0x44(%rbp),%ecx
shr    $0x0,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shr    $0x4,%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    %ax,%cx
mov    -0x28(%rbp),%rax
mov    %cx,0x2(%rax)
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
and    $0xf0,%eax
shl    $0x4,%eax
mov    -0x44(%rbp),%ecx
shr    $0x8,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shl    $0x0,%ecx
or     %ecx,%eax
mov    -0x44(%rbp),%ecx
shr    $0x0,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shr    $0x4,%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    %ax,%cx
mov    -0x28(%rbp),%rax
mov    %cx,0x4(%rax)
mov    -0x30(%rbp),%rax
mov    0xc(%rax),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
and    $0xf0,%eax
shl    $0x4,%eax
mov    -0x44(%rbp),%ecx
shr    $0x8,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shl    $0x0,%ecx
or     %ecx,%eax
mov    -0x44(%rbp),%ecx
shr    $0x0,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shr    $0x4,%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    %ax,%cx
mov    -0x28(%rbp),%rax
mov    %cx,0x6(%rax)
mov    -0x30(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x34(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x34(%rbp)
jmp    11f5 <RGB32toRGB444_ROW_COPY+0xf5>
jmp    1398 <RGB32toRGB444_ROW_COPY+0x298>
cmpl   $0x0,-0x34(%rbp)
je     1422 <RGB32toRGB444_ROW_COPY+0x322>
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
and    $0xf0,%eax
shl    $0x4,%eax
mov    -0x4c(%rbp),%ecx
shr    $0x8,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shl    $0x0,%ecx
or     %ecx,%eax
mov    -0x4c(%rbp),%ecx
shr    $0x0,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shr    $0x4,%ecx
or     %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x30(%rbp)
mov    -0x48(%rbp),%eax
mov    %ax,%cx
mov    -0x28(%rbp),%rax
mov    %cx,(%rax)
mov    -0x28(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x28(%rbp)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1398 <RGB32toRGB444_ROW_COPY+0x298>
pop    %rbp
ret

x86 assembly (clang, -O2):
<RGB32toRGB444_ROW_COPY>:
test   $0x3,%dil
je     1162 <RGB32toRGB444_ROW_COPY+0x62>
lea    0x2(%rdi),%r8
mov    %rdx,%r9
nopl   (%rax)
test   $0x3,%r9b
je     1162 <RGB32toRGB444_ROW_COPY+0x62>
test   %esi,%esi
je     1162 <RGB32toRGB444_ROW_COPY+0x62>
mov    (%rdx),%eax
mov    %eax,%r10d
shr    $0xc,%r10d
and    $0xf00,%r10d
mov    %eax,%ecx
shr    $0x8,%ecx
and    $0xf0,%ecx
or     %r10d,%ecx
shr    $0x4,%eax
and    $0xf,%eax
or     %ecx,%eax
add    $0x4,%rdx
mov    %ax,(%rdi)
add    $0x2,%rdi
add    $0xffffffff,%esi
mov    %r8,%rax
add    $0x2,%rax
add    $0x4,%r9
test   $0x3,%r8b
mov    %rax,%r8
jne    1110 <RGB32toRGB444_ROW_COPY+0x10>
cmp    $0x4,%esi
jl     1189 <RGB32toRGB444_ROW_COPY+0x89>
xor    %eax,%eax
mov    %esi,%r8d
sub    $0x7,%r8d
cmovb  %eax,%r8d
add    $0x3,%r8d
cmp    $0xc,%r8d
jae    1194 <RGB32toRGB444_ROW_COPY+0x94>
mov    %rdi,%r10
mov    %rdx,%rax
jmp    1334 <RGB32toRGB444_ROW_COPY+0x234>
mov    %rdx,%rax
mov    %rdi,%r10
jmp    13b6 <RGB32toRGB444_ROW_COPY+0x2b6>
shr    $0x2,%r8d
add    $0x1,%r8d
mov    %r8d,%r9d
and    $0xfffffffc,%r9d
lea    (%rdi,%r9,8),%r10
mov    %r9,%rax
shl    $0x4,%rax
add    %rdx,%rax
lea    0x0(,%r9,4),%ecx
sub    %ecx,%esi
xor    %ecx,%ecx
movdqa 0xe3a(%rip),%xmm8
movdqa 0xe41(%rip),%xmm9
movdqa 0xe49(%rip),%xmm2
nopw   0x0(%rax,%rax,1)
movdqu (%rdx),%xmm4
movdqu 0x10(%rdx),%xmm5
movdqu 0x20(%rdx),%xmm1
movdqu 0x30(%rdx),%xmm0
movdqa %xmm1,%xmm7
punpckldq %xmm0,%xmm7
movdqa %xmm4,%xmm6
punpckldq %xmm5,%xmm6
movdqa %xmm6,%xmm3
punpcklqdq %xmm7,%xmm3
punpckhqdq %xmm7,%xmm6
punpckhdq %xmm0,%xmm1
punpckhdq %xmm5,%xmm4
movdqa %xmm4,%xmm5
punpcklqdq %xmm1,%xmm5
punpckhqdq %xmm1,%xmm4
movdqa %xmm3,%xmm0
psrld  $0xc,%xmm0
pand   %xmm8,%xmm0
movdqa %xmm3,%xmm1
psrld  $0x8,%xmm1
pand   %xmm9,%xmm1
por    %xmm0,%xmm1
psrld  $0x4,%xmm3
pand   %xmm2,%xmm3
por    %xmm1,%xmm3
movdqa %xmm6,%xmm0
psrld  $0xc,%xmm0
pand   %xmm8,%xmm0
movdqa %xmm6,%xmm1
psrld  $0x8,%xmm1
pand   %xmm9,%xmm1
por    %xmm0,%xmm1
psrld  $0x4,%xmm6
pand   %xmm2,%xmm6
por    %xmm1,%xmm6
packssdw %xmm6,%xmm3
movdqa %xmm5,%xmm0
psrld  $0xc,%xmm0
pand   %xmm8,%xmm0
movdqa %xmm5,%xmm1
psrld  $0x8,%xmm1
pand   %xmm9,%xmm1
por    %xmm0,%xmm1
psrld  $0x4,%xmm5
pand   %xmm2,%xmm5
por    %xmm1,%xmm5
movdqa %xmm4,%xmm0
psrld  $0xc,%xmm0
pand   %xmm8,%xmm0
movdqa %xmm4,%xmm1
psrld  $0x8,%xmm1
pand   %xmm9,%xmm1
por    %xmm0,%xmm1
psrld  $0x4,%xmm4
pand   %xmm2,%xmm4
por    %xmm1,%xmm4
packssdw %xmm4,%xmm5
pshufd $0xe8,%xmm5,%xmm0
pshuflw $0xd8,%xmm0,%xmm0
pshufd $0xe8,%xmm3,%xmm1
pshuflw $0xd8,%xmm1,%xmm1
punpckldq %xmm0,%xmm1
pshufd $0xe7,%xmm5,%xmm0
pshuflw $0x72,%xmm0,%xmm0
pshufd $0xe7,%xmm3,%xmm3
pshuflw $0x72,%xmm3,%xmm3
punpckldq %xmm0,%xmm3
movdqu %xmm3,0x10(%rdi,%rcx,8)
movdqu %xmm1,(%rdi,%rcx,8)
add    $0x4,%rcx
add    $0x40,%rdx
cmp    %rcx,%r9
jne    11e0 <RGB32toRGB444_ROW_COPY+0xe0>
cmp    %r8,%r9
je     13b6 <RGB32toRGB444_ROW_COPY+0x2b6>
movdqa 0xcf4(%rip),%xmm0
movdqa 0xcfc(%rip),%xmm1
movdqa 0xcd4(%rip),%xmm2
mov    %esi,%ecx
xchg   %ax,%ax
movdqu (%rax),%xmm3
movdqa %xmm3,%xmm4
psrld  $0xc,%xmm4
pshufd $0xed,%xmm4,%xmm5
movdqa %xmm3,%xmm6
psrld  $0x8,%xmm6
pshufd $0xe8,%xmm6,%xmm7
punpckldq %xmm5,%xmm7
pand   %xmm0,%xmm7
pshufd $0xed,%xmm6,%xmm5
pshufd $0xe8,%xmm4,%xmm4
punpckldq %xmm5,%xmm4
pand   %xmm1,%xmm4
por    %xmm7,%xmm4
psrld  $0x4,%xmm3
pand   %xmm2,%xmm3
por    %xmm4,%xmm3
packssdw %xmm3,%xmm3
movq   %xmm3,(%r10)
add    $0x10,%rax
add    $0x8,%r10
lea    -0x4(%rcx),%esi
cmp    $0x7,%ecx
mov    %esi,%ecx
ja     1350 <RGB32toRGB444_ROW_COPY+0x250>
test   %esi,%esi
je     14c1 <RGB32toRGB444_ROW_COPY+0x3c1>
lea    -0x1(%rsi),%r8d
cmp    $0x7,%r8d
jae    13d3 <RGB32toRGB444_ROW_COPY+0x2d3>
mov    %r10,%r9
mov    %rax,%r11
jmp    148b <RGB32toRGB444_ROW_COPY+0x38b>
add    $0x1,%r8
mov    %r8,%rdi
and    $0xfffffffffffffff8,%rdi
lea    (%r10,%rdi,2),%r9
lea    (%rax,%rdi,4),%r11
sub    %edi,%esi
xor    %ecx,%ecx
movdqa 0xc0d(%rip),%xmm8
movdqa 0xc15(%rip),%xmm1
movdqa 0xc1d(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu (%rax,%rcx,4),%xmm3
movdqu 0x10(%rax,%rcx,4),%xmm6
movdqa %xmm3,%xmm5
psrld  $0xc,%xmm5
movdqa %xmm6,%xmm0
psrld  $0xc,%xmm0
pand   %xmm8,%xmm5
pand   %xmm8,%xmm0
movdqa %xmm3,%xmm7
psrld  $0x8,%xmm7
movdqa %xmm6,%xmm4
psrld  $0x8,%xmm4
pand   %xmm1,%xmm7
por    %xmm5,%xmm7
pand   %xmm1,%xmm4
por    %xmm0,%xmm4
psrld  $0x4,%xmm3
psrld  $0x4,%xmm6
pand   %xmm2,%xmm3
por    %xmm7,%xmm3
pand   %xmm2,%xmm6
por    %xmm4,%xmm6
packssdw %xmm6,%xmm3
movdqu %xmm3,(%r10,%rcx,2)
add    $0x8,%rcx
cmp    %rcx,%rdi
jne    1410 <RGB32toRGB444_ROW_COPY+0x310>
cmp    %rdi,%r8
je     14c1 <RGB32toRGB444_ROW_COPY+0x3c1>
mov    %esi,%eax
xor    %ecx,%ecx
nop
mov    (%r11,%rcx,4),%esi
mov    %esi,%edi
shr    $0xc,%edi
and    $0xf00,%edi
mov    %esi,%edx
shr    $0x8,%edx
and    $0xf0,%edx
or     %edi,%edx
shr    $0x4,%esi
and    $0xf,%esi
or     %edx,%esi
mov    %si,(%r9,%rcx,2)
add    $0x1,%rcx
cmp    %ecx,%eax
jne    1490 <RGB32toRGB444_ROW_COPY+0x390>
ret

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

LLVM IR (-O2):
define void @RGB32toRGB444_ROW_COPY(i8* %0, i32 %1, i8* %2, i32 %3) {
%5 = ptrtoint i8* %0 to i64
%6 = and i64 %5, 3
%7 = icmp eq i64 %6, 0
br i1 %7, label %36, label %8
8: ; preds = %4, %17
%9 = phi i8* [ %31, %17 ], [ %0, %4 ]
%10 = phi i8* [ %28, %17 ], [ %2, %4 ]
%11 = phi i32 [ %32, %17 ], [ %1, %4 ]
%12 = ptrtoint i8* %10 to i64
%13 = and i64 %12, 3
%14 = icmp ne i64 %13, 0
%15 = icmp ne i32 %11, 0
%16 = select i1 %14, i1 %15, i1 false
br i1 %16, label %17, label %36
17: ; preds = %8
%18 = bitcast i8* %10 to i32*
%19 = load i32, i32* %18
%20 = lshr i32 %19, 12
%21 = and i32 %20, 3840
%22 = lshr i32 %19, 8
%23 = and i32 %22, 240
%24 = or i32 %21, %23
%25 = lshr i32 %19, 4
%26 = and i32 %25, 15
%27 = or i32 %24, %26
%28 = getelementptr inbounds i8, i8* %10, i64 4
%29 = trunc i32 %27 to i16
%30 = bitcast i8* %9 to i16*
store i16 %29, i16* %30
%31 = getelementptr inbounds i8, i8* %9, i64 2
%32 = add nsw i32 %11, -1
%33 = ptrtoint i8* %31 to i64
%34 = and i64 %33, 3
%35 = icmp eq i64 %34, 0
br i1 %35, label %36, label %8
36: ; preds = %8, %17, %4
%37 = phi i32 [ %1, %4 ], [ %32, %17 ], [ %11, %8 ]
%38 = phi i8* [ %2, %4 ], [ %28, %17 ], [ %10, %8 ]
%39 = phi i8* [ %0, %4 ], [ %31, %17 ], [ %9, %8 ]
%40 = icmp sgt i32 %37, 3
br i1 %40, label %41, label %118
41: ; preds = %36
%42 = add i32 %37, 3
%43 = call i32 @llvm.umin.i32(i32 %37, i32 7)
%44 = sub i32 %42, %43
%45 = lshr i32 %44, 2
%46 = add nuw nsw i32 %45, 1
%47 = zext i32 %46 to i64
%48 = icmp ult i32 %44, 12
br i1 %48, label %114, label %49
49: ; preds = %41
%50 = and i64 %47, 2147483644
%51 = shl nuw nsw i64 %50, 3
%52 = getelementptr i8, i8* %39, i64 %51
%53 = shl nuw nsw i64 %50, 4
%54 = getelementptr i8, i8* %38, i64 %53
%55 = trunc i64 %50 to i32
%56 = mul i32 %55, -4
%57 = add i32 %37, %56
br label %58
58: ; preds = %58, %49
%59 = phi i64 [ 0, %49 ], [ %110, %58 ]
%60 = shl i64 %59, 3
%61 = shl i64 %59, 4
%62 = getelementptr i8, i8* %38, i64 %61
%63 = bitcast i8* %62 to <16 x i32>*
%64 = load <16 x i32>, <16 x i32>* %63
%65 = shufflevector <16 x i32> %64, <16 x i32> poison, <4 x i32> <i32 0, i32 4, i32 8, i32 12>
%66 = shufflevector <16 x i32> %64, <16 x i32> poison, <4 x i32> <i32 1, i32 5, i32 9, i32 13>
%67 = shufflevector <16 x i32> %64, <16 x i32> poison, <4 x i32> <i32 2, i32 6, i32 10, i32 14>
%68 = shufflevector <16 x i32> %64, <16 x i32> poison, <4 x i32> <i32 3, i32 7, i32 11, i32 15>
%69 = lshr <4 x i32> %65, <i32 12, i32 12, i32 12, i32 12>
%70 = and <4 x i32> %69, <i32 3840, i32 3840, i32 3840, i32 3840>
%71 = lshr <4 x i32> %65, <i32 8, i32 8, i32 8, i32 8>
%72 = and <4 x i32> %71, <i32 240, i32 240, i32 240, i32 240>
%73 = or <4 x i32> %70, %72
%74 = lshr <4 x i32> %65, <i32 4, i32 4, i32 4, i32 4>
%75 = and <4 x i32> %74, <i32 15, i32 15, i32 15, i32 15>
%76 = or <4 x i32> %73, %75
%77 = trunc <4 x i32> %76 to <4 x i16>
%78 = lshr <4 x i32> %66, <i32 12, i32 12, i32 12, i32 12>
%79 = and <4 x i32> %78, <i32 3840, i32 3840, i32 3840, i32 3840>
%80 = lshr <4 x i32> %66, <i32 8, i32 8, i32 8, i32 8>
%81 = and <4 x i32> %80, <i32 240, i32 240, i32 240, i32 240>
%82 = or <4 x i32> %79, %81
%83 = lshr <4 x i32> %66, <i32 4, i32 4, i32 4, i32 4>
%84 = and <4 x i32> %83, <i32 15, i32 15, i32 15, i32 15>
%85 = or <4 x i32> %82, %84
%86 = trunc <4 x i32> %85 to <4 x i16>
%87 = lshr <4 x i32> %67, <i32 12, i32 12, i32 12, i32 12>
%88 = and <4 x i32> %87, <i32 3840, i32 3840, i32 3840, i32 3840>
%89 = lshr <4 x i32> %67, <i32 8, i32 8, i32 8, i32 8>
%90 = and <4 x i32> %89, <i32 240, i32 240, i32 240, i32 240>
%91 = or <4 x i32> %88, %90
%92 = lshr <4 x i32> %67, <i32 4, i32 4, i32 4, i32 4>
%93 = and <4 x i32> %92, <i32 15, i32 15, i32 15, i32 15>
%94 = or <4 x i32> %91, %93
%95 = trunc <4 x i32> %94 to <4 x i16>
%96 = lshr <4 x i32> %68, <i32 12, i32 12, i32 12, i32 12>
%97 = and <4 x i32> %96, <i32 3840, i32 3840, i32 3840, i32 3840>
%98 = lshr <4 x i32> %68, <i32 8, i32 8, i32 8, i32 8>
%99 = and <4 x i32> %98, <i32 240, i32 240, i32 240, i32 240>
%100 = or <4 x i32> %97, %99
%101 = lshr <4 x i32> %68, <i32 4, i32 4, i32 4, i32 4>
%102 = and <4 x i32> %101, <i32 15, i32 15, i32 15, i32 15>
%103 = or <4 x i32> %100, %102
%104 = trunc <4 x i32> %103 to <4 x i16>
%105 = getelementptr inbounds i8, i8* %39, i64 %60
%106 = bitcast i8* %105 to <16 x i16>*
%107 = shufflevector <4 x i16> %77, <4 x i16> %86, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%108 = shufflevector <4 x i16> %95, <4 x i16> %104, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%109 = shufflevector <8 x i16> %107, <8 x i16> %108, <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> %109, <16 x i16>* %106
%110 = add nuw i64 %59, 4
%111 = icmp eq i64 %110, %50
br i1 %111, label %112, label %58
112: ; preds = %58
%113 = icmp eq i64 %50, %47
br i1 %113, label %118, label %114
114: ; preds = %41, %112
%115 = phi i8* [ %39, %41 ], [ %52, %112 ]
%116 = phi i8* [ %38, %41 ], [ %54, %112 ]
%117 = phi i32 [ %37, %41 ], [ %57, %112 ]
br label %176
118: ; preds = %176, %112, %36
%119 = phi i32 [ %37, %36 ], [ %57, %112 ], [ %194, %176 ]
%120 = phi i8* [ %38, %36 ], [ %54, %112 ], [ %192, %176 ]
%121 = phi i8* [ %39, %36 ], [ %52, %112 ], [ %193, %176 ]
%122 = icmp eq i32 %119, 0
br i1 %122, label %216, label %123
123: ; preds = %118
%124 = add i32 %119, -1
%125 = zext i32 %124 to i64
%126 = add nuw nsw i64 %125, 1
%127 = icmp ult i32 %124, 7
br i1 %127, label %172, label %128
128: ; preds = %123
%129 = and i64 %126, 8589934584
%130 = shl nuw nsw i64 %129, 1
%131 = getelementptr i8, i8* %121, i64 %130
%132 = shl nuw nsw i64 %129, 2
%133 = getelementptr i8, i8* %120, i64 %132
%134 = trunc i64 %129 to i32
%135 = sub i32 %119, %134
br label %136
136: ; preds = %136, %128
%137 = phi i64 [ 0, %128 ], [ %168, %136 ]
%138 = shl i64 %137, 1
%139 = getelementptr i8, i8* %121, i64 %138
%140 = shl i64 %137, 2
%141 = getelementptr i8, i8* %120, i64 %140
%142 = bitcast i8* %141 to <4 x i32>*
%143 = load <4 x i32>, <4 x i32>* %142
%144 = getelementptr i8, i8* %141, i64 16
%145 = bitcast i8* %144 to <4 x i32>*
%146 = load <4 x i32>, <4 x i32>* %145
%147 = lshr <4 x i32> %143, <i32 12, i32 12, i32 12, i32 12>
%148 = lshr <4 x i32> %146, <i32 12, i32 12, i32 12, i32 12>
%149 = and <4 x i32> %147, <i32 3840, i32 3840, i32 3840, i32 3840>
%150 = and <4 x i32> %148, <i32 3840, i32 3840, i32 3840, i32 3840>
%151 = lshr <4 x i32> %143, <i32 8, i32 8, i32 8, i32 8>
%152 = lshr <4 x i32> %146, <i32 8, i32 8, i32 8, i32 8>
%153 = and <4 x i32> %151, <i32 240, i32 240, i32 240, i32 240>
%154 = and <4 x i32> %152, <i32 240, i32 240, i32 240, i32 240>
%155 = or <4 x i32> %149, %153
%156 = or <4 x i32> %150, %154
%157 = lshr <4 x i32> %143, <i32 4, i32 4, i32 4, i32 4>
%158 = lshr <4 x i32> %146, <i32 4, i32 4, i32 4, i32 4>
%159 = and <4 x i32> %157, <i32 15, i32 15, i32 15, i32 15>
%160 = and <4 x i32> %158, <i32 15, i32 15, i32 15, i32 15>
%161 = or <4 x i32> %155, %159
%162 = or <4 x i32> %156, %160
%163 = trunc <4 x i32> %161 to <4 x i16>
%164 = trunc <4 x i32> %162 to <4 x i16>
%165 = bitcast i8* %139 to <4 x i16>*
store <4 x i16> %163, <4 x i16>* %165
%166 = getelementptr i8, i8* %139, i64 8
%167 = bitcast i8* %166 to <4 x i16>*
store <4 x i16> %164, <4 x i16>* %167
%168 = add nuw i64 %137, 8
%169 = icmp eq i64 %168, %129
br i1 %169, label %170, label %136
170: ; preds = %136
%171 = icmp eq i64 %126, %129
br i1 %171, label %216, label %172
172: ; preds = %123, %170
%173 = phi i8* [ %121, %123 ], [ %131, %170 ]
%174 = phi i8* [ %120, %123 ], [ %133, %170 ]
%175 = phi i32 [ %119, %123 ], [ %135, %170 ]
br label %196
176: ; preds = %114, %176
%177 = phi i8* [ %193, %176 ], [ %115, %114 ]
%178 = phi i8* [ %192, %176 ], [ %116, %114 ]
%179 = phi i32 [ %194, %176 ], [ %117, %114 ]
%180 = bitcast i8* %178 to <4 x i32>*
%181 = load <4 x i32>, <4 x i32>* %180
%182 = lshr <4 x i32> %181, <i32 8, i32 12, i32 8, i32 12>
%183 = and <4 x i32> %182, <i32 240, i32 3840, i32 240, i32 3840>
%184 = lshr <4 x i32> %181, <i32 12, i32 8, i32 12, i32 8>
%185 = and <4 x i32> %184, <i32 3840, i32 240, i32 3840, i32 240>
%186 = or <4 x i32> %183, %185
%187 = lshr <4 x i32> %181, <i32 4, i32 4, i32 4, i32 4>
%188 = and <4 x i32> %187, <i32 15, i32 15, i32 15, i32 15>
%189 = or <4 x i32> %186, %188
%190 = trunc <4 x i32> %189 to <4 x i16>
%191 = bitcast i8* %177 to <4 x i16>*
store <4 x i16> %190, <4 x i16>* %191
%192 = getelementptr inbounds i8, i8* %178, i64 16
%193 = getelementptr inbounds i8, i8* %177, i64 8
%194 = add nsw i32 %179, -4
%195 = icmp ugt i32 %179, 7
br i1 %195, label %176, label %118
196: ; preds = %172, %196
%197 = phi i8* [ %213, %196 ], [ %173, %172 ]
%198 = phi i8* [ %210, %196 ], [ %174, %172 ]
%199 = phi i32 [ %214, %196 ], [ %175, %172 ]
%200 = bitcast i8* %198 to i32*
%201 = load i32, i32* %200
%202 = lshr i32 %201, 12
%203 = and i32 %202, 3840
%204 = lshr i32 %201, 8
%205 = and i32 %204, 240
%206 = or i32 %203, %205
%207 = lshr i32 %201, 4
%208 = and i32 %207, 15
%209 = or i32 %206, %208
%210 = getelementptr inbounds i8, i8* %198, i64 4
%211 = trunc i32 %209 to i16
%212 = bitcast i8* %197 to i16*
store i16 %211, i16* %212
%213 = getelementptr inbounds i8, i8* %197, i64 2
%214 = add nsw i32 %199, -1
%215 = icmp eq i32 %214, 0
br i1 %215, label %216, label %196
216: ; preds = %196, %170, %118
ret void
}