void RGB32toRGB444_ROW2X_STRETCH2X(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 = src_dx;
  if (count) {
    register unsigned int da_rgb;
    register unsigned int dc_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;
    register unsigned int sb_rgb;
    sb_rgb = *(unsigned short *)(d1);
    dc_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 * 2;
    count--;
    *(unsigned short *)(d2) = da_rgb;
    d2 += 2;
    *(unsigned short *)(d12) = dc_rgb;
    d12 += 2;
    while (count >= 2) {
      register unsigned int db_rgb;
      register unsigned int dd_rgb;
      register unsigned int sa_rgb;
      sa_rgb = *(unsigned int *)(s);
      db_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)));
      da_rgb =
          (((da_rgb ^ db_rgb) >> 1) & (((1U << (8 + 4 - 1)) - (1U << 8)) |
                                       ((1U << (4 + 4 - 1)) - (1U << 4)) |
                                       ((1U << (0 + 4 - 1)) - (1U << 0)))) +
          (da_rgb & db_rgb);
      *(unsigned short *)(d2) = da_rgb;
      *(unsigned short *)(d2 + 2) = db_rgb;
      register unsigned int sb_rgb;
      sb_rgb = *(unsigned short *)(d1);
      dd_rgb =
          (((db_rgb ^ sb_rgb) >> 1) & (((1U << (8 + 4 - 1)) - (1U << 8)) |
                                       ((1U << (4 + 4 - 1)) - (1U << 4)) |
                                       ((1U << (0 + 4 - 1)) - (1U << 0)))) +
          (db_rgb & sb_rgb);
      dc_rgb =
          (((dc_rgb ^ dd_rgb) >> 1) & (((1U << (8 + 4 - 1)) - (1U << 8)) |
                                       ((1U << (4 + 4 - 1)) - (1U << 4)) |
                                       ((1U << (0 + 4 - 1)) - (1U << 0)))) +
          (dc_rgb & dd_rgb);
      *(unsigned short *)(d12) = dc_rgb;
      *(unsigned short *)(d12 + 2) = dd_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)));
      db_rgb =
          (((db_rgb ^ da_rgb) >> 1) & (((1U << (8 + 4 - 1)) - (1U << 8)) |
                                       ((1U << (4 + 4 - 1)) - (1U << 4)) |
                                       ((1U << (0 + 4 - 1)) - (1U << 0)))) +
          (db_rgb & da_rgb);
      *(unsigned short *)(d2 + 2 * 2) = db_rgb;
      *(unsigned short *)(d2 + 3 * 2) = da_rgb;
      sb_rgb = *(unsigned short *)(d1 + 2 * 2);
      dc_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);
      dd_rgb =
          (((dd_rgb ^ dc_rgb) >> 1) & (((1U << (8 + 4 - 1)) - (1U << 8)) |
                                       ((1U << (4 + 4 - 1)) - (1U << 4)) |
                                       ((1U << (0 + 4 - 1)) - (1U << 0)))) +
          (dd_rgb & dc_rgb);
      *(unsigned short *)(d12 + 2 * 2) = dd_rgb;
      *(unsigned short *)(d12 + 3 * 2) = dc_rgb;
      s += 2 * 4;
      d1 += 4 * 2;
      d2 += 4 * 2;
      d12 += 4 * 2;
      count -= 2;
    }
    if (count) {
      register unsigned int db_rgb;
      register unsigned int dd_rgb;
      register unsigned int sa_rgb;
      sa_rgb = *(unsigned int *)(s);
      db_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)));
      da_rgb =
          (((da_rgb ^ db_rgb) >> 1) & (((1U << (8 + 4 - 1)) - (1U << 8)) |
                                       ((1U << (4 + 4 - 1)) - (1U << 4)) |
                                       ((1U << (0 + 4 - 1)) - (1U << 0)))) +
          (da_rgb & db_rgb);
      *(unsigned short *)(d2) = da_rgb;
      *(unsigned short *)(d2 + 2) = db_rgb;
      *(unsigned short *)(d2 + 2 * 2) = db_rgb;
      register unsigned int sb_rgb;
      sb_rgb = *(unsigned short *)(d1);
      dd_rgb =
          (((db_rgb ^ sb_rgb) >> 1) & (((1U << (8 + 4 - 1)) - (1U << 8)) |
                                       ((1U << (4 + 4 - 1)) - (1U << 4)) |
                                       ((1U << (0 + 4 - 1)) - (1U << 0)))) +
          (db_rgb & sb_rgb);
      dc_rgb =
          (((dc_rgb ^ dd_rgb) >> 1) & (((1U << (8 + 4 - 1)) - (1U << 8)) |
                                       ((1U << (4 + 4 - 1)) - (1U << 4)) |
                                       ((1U << (0 + 4 - 1)) - (1U << 0)))) +
          (dc_rgb & dd_rgb);
      *(unsigned short *)(d12) = dc_rgb;
      *(unsigned short *)(d12 + 2) = dd_rgb;
      *(unsigned short *)(d12 + 2 * 2) = dd_rgb;
    } else {
      *(unsigned short *)(d2) = da_rgb;
      *(unsigned short *)(d12) = dc_rgb;
    }
  }
}


x86 assembly (clang, -O0):
<RGB32toRGB444_ROW2X_STRETCH2X>:
push   %rbp
mov    %rsp,%rbp
push   %rax
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    -0x2c(%rbp),%eax
mov    %eax,-0x54(%rbp)
cmpl   $0x0,-0x54(%rbp)
je     1536 <RGB32toRGB444_ROW2X_STRETCH2X+0x436>
mov    -0x50(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
and    $0xf0,%eax
shl    $0x4,%eax
mov    -0x60(%rbp),%ecx
shr    $0x8,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shl    $0x0,%ecx
or     %ecx,%eax
mov    -0x60(%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    -0x38(%rbp),%rax
movzwl (%rax),%eax
mov    %eax,-0x64(%rbp)
mov    -0x58(%rbp),%eax
xor    -0x64(%rbp),%eax
shr    $0x1,%eax
and    $0x777,%eax
mov    -0x58(%rbp),%ecx
and    -0x64(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x38(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x38(%rbp)
mov    -0x54(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x54(%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    -0x5c(%rbp),%eax
mov    %ax,%cx
mov    -0x40(%rbp),%rax
mov    %cx,(%rax)
mov    -0x40(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x40(%rbp)
cmpl   $0x2,-0x54(%rbp)
jl     140b <RGB32toRGB444_ROW2X_STRETCH2X+0x30b>
mov    -0x50(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
and    $0xf0,%eax
shl    $0x4,%eax
mov    -0x70(%rbp),%ecx
shr    $0x8,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shl    $0x0,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%ecx
shr    $0x0,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shr    $0x4,%ecx
or     %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    -0x58(%rbp),%eax
xor    -0x68(%rbp),%eax
shr    $0x1,%eax
and    $0x777,%eax
mov    -0x58(%rbp),%ecx
and    -0x68(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    %ax,%cx
mov    -0x48(%rbp),%rax
mov    %cx,(%rax)
mov    -0x68(%rbp),%eax
mov    %ax,%cx
mov    -0x48(%rbp),%rax
mov    %cx,0x2(%rax)
mov    -0x38(%rbp),%rax
movzwl (%rax),%eax
mov    %eax,-0x74(%rbp)
mov    -0x68(%rbp),%eax
xor    -0x74(%rbp),%eax
shr    $0x1,%eax
and    $0x777,%eax
mov    -0x68(%rbp),%ecx
and    -0x74(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x5c(%rbp),%eax
xor    -0x6c(%rbp),%eax
shr    $0x1,%eax
and    $0x777,%eax
mov    -0x5c(%rbp),%ecx
and    -0x6c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    %ax,%cx
mov    -0x40(%rbp),%rax
mov    %cx,(%rax)
mov    -0x6c(%rbp),%eax
mov    %ax,%cx
mov    -0x40(%rbp),%rax
mov    %cx,0x2(%rax)
mov    -0x50(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
and    $0xf0,%eax
shl    $0x4,%eax
mov    -0x70(%rbp),%ecx
shr    $0x8,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shl    $0x0,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%ecx
shr    $0x0,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shr    $0x4,%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x68(%rbp),%eax
xor    -0x58(%rbp),%eax
shr    $0x1,%eax
and    $0x777,%eax
mov    -0x68(%rbp),%ecx
and    -0x58(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %ax,%cx
mov    -0x48(%rbp),%rax
mov    %cx,0x4(%rax)
mov    -0x58(%rbp),%eax
mov    %ax,%cx
mov    -0x48(%rbp),%rax
mov    %cx,0x6(%rax)
mov    -0x38(%rbp),%rax
movzwl 0x4(%rax),%eax
mov    %eax,-0x74(%rbp)
mov    -0x58(%rbp),%eax
xor    -0x74(%rbp),%eax
shr    $0x1,%eax
and    $0x777,%eax
mov    -0x58(%rbp),%ecx
and    -0x74(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x6c(%rbp),%eax
xor    -0x5c(%rbp),%eax
shr    $0x1,%eax
and    $0x777,%eax
mov    -0x6c(%rbp),%ecx
and    -0x5c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    %ax,%cx
mov    -0x40(%rbp),%rax
mov    %cx,0x4(%rax)
mov    -0x5c(%rbp),%eax
mov    %ax,%cx
mov    -0x40(%rbp),%rax
mov    %cx,0x6(%rax)
mov    -0x50(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x38(%rbp)
mov    -0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x40(%rbp)
mov    -0x54(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x54(%rbp)
jmp    120f <RGB32toRGB444_ROW2X_STRETCH2X+0x10f>
cmpl   $0x0,-0x54(%rbp)
je     1517 <RGB32toRGB444_ROW2X_STRETCH2X+0x417>
mov    -0x50(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
and    $0xf0,%eax
shl    $0x4,%eax
mov    -0x80(%rbp),%ecx
shr    $0x8,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shl    $0x0,%ecx
or     %ecx,%eax
mov    -0x80(%rbp),%ecx
shr    $0x0,%ecx
and    $0xff,%ecx
and    $0xf0,%ecx
shr    $0x4,%ecx
or     %ecx,%eax
mov    %eax,-0x78(%rbp)
mov    -0x58(%rbp),%eax
xor    -0x78(%rbp),%eax
shr    $0x1,%eax
and    $0x777,%eax
mov    -0x58(%rbp),%ecx
and    -0x78(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    %ax,%cx
mov    -0x48(%rbp),%rax
mov    %cx,(%rax)
mov    -0x78(%rbp),%eax
mov    %ax,%cx
mov    -0x48(%rbp),%rax
mov    %cx,0x2(%rax)
mov    -0x78(%rbp),%eax
mov    %ax,%cx
mov    -0x48(%rbp),%rax
mov    %cx,0x4(%rax)
mov    -0x38(%rbp),%rax
movzwl (%rax),%eax
mov    %eax,-0x84(%rbp)
mov    -0x78(%rbp),%eax
xor    -0x84(%rbp),%eax
shr    $0x1,%eax
and    $0x777,%eax
mov    -0x78(%rbp),%ecx
and    -0x84(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x5c(%rbp),%eax
xor    -0x7c(%rbp),%eax
shr    $0x1,%eax
and    $0x777,%eax
mov    -0x5c(%rbp),%ecx
and    -0x7c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    %ax,%cx
mov    -0x40(%rbp),%rax
mov    %cx,(%rax)
mov    -0x7c(%rbp),%eax
mov    %ax,%cx
mov    -0x40(%rbp),%rax
mov    %cx,0x2(%rax)
mov    -0x7c(%rbp),%eax
mov    %ax,%cx
mov    -0x40(%rbp),%rax
mov    %cx,0x4(%rax)
jmp    1531 <RGB32toRGB444_ROW2X_STRETCH2X+0x431>
mov    -0x58(%rbp),%eax
mov    %ax,%cx
mov    -0x48(%rbp),%rax
mov    %cx,(%rax)
mov    -0x5c(%rbp),%eax
mov    %ax,%cx
mov    -0x40(%rbp),%rax
mov    %cx,(%rax)
jmp    1536 <RGB32toRGB444_ROW2X_STRETCH2X+0x436>
add    $0x8,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<RGB32toRGB444_ROW2X_STRETCH2X>:
test   %r9d,%r9d
je     1327 <RGB32toRGB444_ROW2X_STRETCH2X+0x227>
push   %rbp
push   %r14
push   %rbx
mov    (%r8),%r14d
mov    %r14d,%eax
shr    $0xc,%eax
and    $0xf00,%eax
mov    %r14d,%ebx
shr    $0x8,%ebx
and    $0xf0,%ebx
or     %eax,%ebx
shr    $0x4,%r14d
and    $0xf,%r14d
or     %ebx,%r14d
add    $0x4,%r8
movzwl (%rdi),%r11d
mov    %r14d,%eax
xor    %r11d,%eax
shr    %eax
and    $0x777,%eax
and    %r14d,%r11d
add    %eax,%r11d
add    $0x4,%rdi
mov    %r14w,(%rdx)
add    $0x2,%rdx
mov    %r11w,(%rsi)
add    $0x2,%rsi
cmp    $0x3,%r9d
jl     1310 <RGB32toRGB444_ROW2X_STRETCH2X+0x210>
add    $0x1,%r9d
xor    %r10d,%r10d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r8,%r10,1),%eax
mov    %eax,%ebx
shr    $0xc,%ebx
and    $0xf00,%ebx
mov    %eax,%ebp
shr    $0x8,%ebp
and    $0xf0,%ebp
or     %ebx,%ebp
shr    $0x4,%eax
and    $0xf,%eax
or     %ebp,%eax
mov    %eax,%ebx
xor    %r14d,%ebx
shr    %ebx
and    $0x777,%ebx
and    %eax,%r14d
add    %ebx,%r14d
mov    %r14w,(%rdx,%r10,1)
mov    %ax,0x2(%rdx,%r10,1)
movzwl (%rdi,%r10,1),%ebx
mov    %eax,%ecx
xor    %ebx,%ecx
shr    %ecx
and    $0x777,%ecx
and    %eax,%ebx
add    %ecx,%ebx
mov    %ebx,%ecx
xor    %r11d,%ecx
shr    %ecx
and    $0x777,%ecx
and    %ebx,%r11d
add    %ecx,%r11d
mov    %r11w,(%rsi,%r10,1)
mov    %bx,0x2(%rsi,%r10,1)
mov    0x4(%r8,%r10,1),%r14d
mov    %r14d,%ecx
shr    $0xc,%ecx
and    $0xf00,%ecx
mov    %r14d,%ebp
shr    $0x8,%ebp
and    $0xf0,%ebp
or     %ecx,%ebp
shr    $0x4,%r14d
and    $0xf,%r14d
or     %ebp,%r14d
mov    %r14d,%ecx
xor    %eax,%ecx
shr    %ecx
and    $0x777,%ecx
and    %r14d,%eax
add    %ecx,%eax
mov    %ax,0x4(%rdx,%r10,1)
mov    %r14w,0x6(%rdx,%r10,1)
movzwl 0x4(%rdi,%r10,1),%r11d
mov    %r14d,%eax
xor    %r11d,%eax
shr    %eax
and    $0x777,%eax
and    %r14d,%r11d
add    %eax,%r11d
mov    %r11d,%eax
xor    %ebx,%eax
shr    %eax
and    $0x777,%eax
and    %r11d,%ebx
add    %eax,%ebx
mov    %bx,0x4(%rsi,%r10,1)
mov    %r11w,0x6(%rsi,%r10,1)
add    $0x8,%r10
add    $0xfffffffe,%r9d
cmp    $0x3,%r9d
ja     1180 <RGB32toRGB444_ROW2X_STRETCH2X+0x80>
add    %r10,%rdi
add    %r10,%rsi
add    %r10,%rdx
add    %r10,%r8
add    $0xfffffffe,%r9d
test   %r9d,%r9d
je     1319 <RGB32toRGB444_ROW2X_STRETCH2X+0x219>
mov    (%r8),%eax
mov    %eax,%ecx
shr    $0xc,%ecx
and    $0xf00,%ecx
mov    %eax,%ebp
shr    $0x8,%ebp
and    $0xf0,%ebp
or     %ecx,%ebp
shr    $0x4,%eax
and    $0xf,%eax
or     %ebp,%eax
mov    %eax,%ecx
xor    %r14d,%ecx
shr    %ecx
and    $0x777,%ecx
and    %eax,%r14d
add    %ecx,%r14d
mov    %r14w,(%rdx)
mov    %ax,0x2(%rdx)
mov    %ax,0x4(%rdx)
movzwl (%rdi),%ecx
mov    %eax,%edx
xor    %ecx,%edx
shr    %edx
and    $0x777,%edx
and    %ecx,%eax
add    %edx,%eax
mov    %eax,%ecx
xor    %r11d,%ecx
shr    %ecx
and    $0x777,%ecx
and    %eax,%r11d
add    %ecx,%r11d
mov    %r11w,(%rsi)
mov    %ax,0x2(%rsi)
add    $0x4,%rsi
jmp    1320 <RGB32toRGB444_ROW2X_STRETCH2X+0x220>
add    $0xffffffff,%r9d
test   %r9d,%r9d
jne    129a <RGB32toRGB444_ROW2X_STRETCH2X+0x19a>
mov    %r14w,(%rdx)
mov    %r11d,%eax
mov    %ax,(%rsi)
pop    %rbx
pop    %r14
pop    %rbp
ret

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

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