void c_convert_16_24(char *buf16, unsigned int size16, char *buf24,
                     unsigned char color_order) {
  unsigned int loc16 = 0;
  unsigned int loc24 = 0;
  unsigned char r5;
  unsigned char g6;
  unsigned char b5;
  while (loc16 < size16) {
    unsigned short rgb565 = *((unsigned short *)(buf16 + loc16));
    loc16 += 2;
    if (color_order == 0) {
      b5 = (rgb565 & 0xf800) >> 11;
      r5 = (rgb565 & 0x001f);
    } else {
      r5 = (rgb565 & 0xf800) >> 11;
      b5 = (rgb565 & 0x001f);
    }
    g6 = (rgb565 & 0x07e0) >> 5;
    unsigned char r8 = (r5 * 527 + 23) >> 6;
    unsigned char g8 = (g6 * 259 + 33) >> 6;
    unsigned char b8 = (b5 * 527 + 23) >> 6;
    *((unsigned char *)(buf24 + loc24++)) = r8;
    *((unsigned char *)(buf24 + loc24++)) = g8;
    *((unsigned char *)(buf24 + loc24++)) = b8;
  }
}


x86 assembly (clang, -O0):
<c_convert_16_24>:
push   %rbp
mov    %rsp,%rbp
mov    %cl,%al
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %al,-0x19(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    121c <c_convert_16_24+0x11c>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    (%rax,%rcx,1),%ax
mov    %ax,-0x2a(%rbp)
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x20(%rbp)
movzbl -0x19(%rbp),%eax
cmp    $0x0,%eax
jne    1171 <c_convert_16_24+0x71>
movzwl -0x2a(%rbp),%eax
and    $0xf800,%eax
sar    $0xb,%eax
mov    %al,-0x27(%rbp)
movzwl -0x2a(%rbp),%eax
and    $0x1f,%eax
mov    %al,-0x25(%rbp)
jmp    118a <c_convert_16_24+0x8a>
movzwl -0x2a(%rbp),%eax
and    $0xf800,%eax
sar    $0xb,%eax
mov    %al,-0x25(%rbp)
movzwl -0x2a(%rbp),%eax
and    $0x1f,%eax
mov    %al,-0x27(%rbp)
movzwl -0x2a(%rbp),%eax
and    $0x7e0,%eax
sar    $0x5,%eax
mov    %al,-0x26(%rbp)
movzbl -0x25(%rbp),%eax
imul   $0x20f,%eax,%eax
add    $0x17,%eax
sar    $0x6,%eax
mov    %al,-0x2b(%rbp)
movzbl -0x26(%rbp),%eax
imul   $0x103,%eax,%eax
add    $0x21,%eax
sar    $0x6,%eax
mov    %al,-0x2c(%rbp)
movzbl -0x27(%rbp),%eax
imul   $0x20f,%eax,%eax
add    $0x17,%eax
sar    $0x6,%eax
mov    %al,-0x2d(%rbp)
mov    -0x2b(%rbp),%dl
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%dl
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x2d(%rbp),%dl
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
jmp    1122 <c_convert_16_24+0x22>
pop    %rbp
ret

x86 assembly (clang, -O2):
<c_convert_16_24>:
push   %rbp
push   %r15
push   %r14
push   %rbx
test   %esi,%esi
je     14a7 <c_convert_16_24+0x3a7>
mov    %rdx,%r8
mov    %esi,%r11d
lea    -0x1(%r11),%rbx
cmp    $0xe,%rbx
jae    1128 <c_convert_16_24+0x28>
xor    %edx,%edx
xor    %r14d,%r14d
jmp    1558 <c_convert_16_24+0x458>
mov    %rbx,%r9
shr    %r9
mov    $0x3,%edx
mov    %r9d,%eax
mul    %edx
mov    %eax,%r10d
seto   %r14b
mov    $0x3,%edx
mov    %r9,%rax
mul    %rdx
seto   %r15b
xor    %edx,%edx
cmp    $0xffffffff,%r10d
je     14e3 <c_convert_16_24+0x3e3>
test   %r14b,%r14b
jne    14e8 <c_convert_16_24+0x3e8>
movabs $0x1ffffffff,%rsi
cmp    %rsi,%rbx
ja     14d6 <c_convert_16_24+0x3d6>
cmp    $0xfffffffd,%r10d
ja     14ed <c_convert_16_24+0x3ed>
test   %r14b,%r14b
jne    14f2 <c_convert_16_24+0x3f2>
cmp    %rsi,%rbx
ja     14de <c_convert_16_24+0x3de>
lea    0x1(%r8),%rbx
lea    (%r8,%rax,1),%rbp
add    $0x1,%rbp
cmp    %rbx,%rbp
jb     14c6 <c_convert_16_24+0x3c6>
test   %r15b,%r15b
jne    14ce <c_convert_16_24+0x3ce>
lea    0x2(%r8),%rbp
lea    (%r8,%rax,1),%rbx
add    $0x2,%rbx
cmp    %rbp,%rbx
jb     14b6 <c_convert_16_24+0x3b6>
test   %r15b,%r15b
jne    14be <c_convert_16_24+0x3be>
add    %r8,%rax
cmp    %r8,%rax
jb     14ae <c_convert_16_24+0x3ae>
mov    $0x0,%r14d
test   %r15b,%r15b
jne    1558 <c_convert_16_24+0x458>
lea    (%r9,%r9,2),%rax
add    %r8,%rax
add    $0x3,%rax
cmp    %rdi,%rax
jbe    1210 <c_convert_16_24+0x110>
lea    0x1(%r11),%rax
add    $0xffffffffffffffff,%rsi
and    %rax,%rsi
add    %rdi,%rsi
cmp    %r8,%rsi
ja     111e <c_convert_16_24+0x1e>
add    $0x1,%r9
xor    %esi,%esi
test   %cl,%cl
setne  %sil
mov    %r9,%r10
and    $0xfffffffffffffff8,%r10
lea    (%r10,%r10,1),%rdx
lea    (%r10,%r10,2),%r14d
movd   %esi,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm14
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
movdqa %xmm14,%xmm13
punpcklwd %xmm13,%xmm13
pslld  $0x1f,%xmm13
psrad  $0x1f,%xmm13
punpckhwd %xmm14,%xmm14
pslld  $0x1f,%xmm14
psrad  $0x1f,%xmm14
movdqa 0xde0(%rip),%xmm15
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu (%rdi,%rbx,2),%xmm4
movdqa %xmm4,%xmm9
pand   0xd6d(%rip),%xmm9
movdqa %xmm9,%xmm10
punpckhwd %xmm1,%xmm9
movdqa %xmm4,%xmm3
punpckhwd %xmm1,%xmm3
movdqa %xmm4,%xmm12
punpcklwd %xmm1,%xmm12
movdqa %xmm14,%xmm8
pandn  %xmm3,%xmm8
psrld  $0xb,%xmm3
movdqa %xmm14,%xmm11
pandn  %xmm3,%xmm11
movdqa %xmm13,%xmm3
pandn  %xmm12,%xmm3
psrld  $0xb,%xmm12
pand   %xmm14,%xmm9
por    %xmm11,%xmm9
movdqa %xmm13,%xmm0
pandn  %xmm12,%xmm0
movdqa %xmm4,%xmm5
psrlw  $0xb,%xmm5
punpcklwd %xmm1,%xmm10
pand   %xmm13,%xmm10
por    %xmm0,%xmm10
movdqa %xmm5,%xmm0
punpckhwd %xmm1,%xmm5
pand   %xmm14,%xmm5
movdqa 0xcf7(%rip),%xmm6
pand   %xmm6,%xmm8
por    %xmm5,%xmm8
punpcklwd %xmm1,%xmm0
pand   %xmm13,%xmm0
pand   %xmm6,%xmm3
por    %xmm0,%xmm3
psrlw  $0x5,%xmm4
pand   0xcdf(%rip),%xmm4
pmullw 0xd17(%rip),%xmm4
paddw  0xd1f(%rip),%xmm4
movdqa 0xcd7(%rip),%xmm0
pmaddwd %xmm0,%xmm3
pmaddwd %xmm0,%xmm8
movdqa 0xcd6(%rip),%xmm2
paddd  %xmm2,%xmm8
paddd  %xmm2,%xmm3
psrld  $0x6,%xmm3
psrld  $0x6,%xmm8
pand   %xmm15,%xmm8
pand   %xmm15,%xmm3
packuswb %xmm8,%xmm3
psrlw  $0x6,%xmm4
pand   0xce6(%rip),%xmm4
packuswb %xmm4,%xmm3
pmaddwd %xmm0,%xmm10
pmaddwd %xmm0,%xmm9
paddd  %xmm2,%xmm9
paddd  %xmm2,%xmm10
psrld  $0x6,%xmm10
psrld  $0x6,%xmm9
pand   %xmm15,%xmm9
pand   %xmm15,%xmm10
packuswb %xmm9,%xmm10
movdqa %xmm10,%xmm4
movdqa %xmm3,%xmm0
punpcklbw %xmm1,%xmm0
punpckhbw %xmm1,%xmm3
pshuflw $0xff,%xmm3,%xmm5
pshufhw $0x0,%xmm5,%xmm5
movdqa 0xca0(%rip),%xmm7
movdqa %xmm7,%xmm6
pandn  %xmm5,%xmm6
pshufd $0xa5,%xmm0,%xmm5
pand   %xmm7,%xmm5
por    %xmm5,%xmm6
movdqa %xmm0,%xmm5
punpcklwd %xmm3,%xmm5
pshufd $0x64,%xmm5,%xmm5
pshuflw $0xa4,%xmm5,%xmm5
pshufhw $0x47,%xmm5,%xmm5
packuswb %xmm6,%xmm5
packuswb %xmm10,%xmm10
pshuflw $0x0,%xmm10,%xmm6
pshufhw $0xa5,%xmm6,%xmm6
movdqa 0xc68(%rip),%xmm2
movdqa %xmm2,%xmm7
pandn  %xmm6,%xmm7
pand   %xmm2,%xmm5
por    %xmm5,%xmm7
packuswb %xmm4,%xmm4
punpckhwd %xmm0,%xmm3
pshuflw $0xf6,%xmm4,%xmm0
movdqa 0xc53(%rip),%xmm2
movdqa %xmm2,%xmm4
pandn  %xmm0,%xmm4
pshufd $0xf6,%xmm3,%xmm0
pshuflw $0x16,%xmm0,%xmm0
packuswb %xmm0,%xmm0
pand   %xmm2,%xmm0
por    %xmm0,%xmm4
mov    %ebp,%esi
and    $0xfffffff8,%esi
movq   %xmm4,0x10(%r8,%rsi,1)
movdqu %xmm7,(%r8,%rsi,1)
add    $0x8,%rbx
add    $0x18,%rbp
cmp    %rbx,%r10
jne    1280 <c_convert_16_24+0x180>
cmp    %r10,%r9
jne    1558 <c_convert_16_24+0x458>
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %r14d,%r14d
jmp    1558 <c_convert_16_24+0x458>
xor    %r14d,%r14d
jmp    1558 <c_convert_16_24+0x458>
xor    %r14d,%r14d
jmp    1558 <c_convert_16_24+0x458>
xor    %r14d,%r14d
jmp    1558 <c_convert_16_24+0x458>
xor    %r14d,%r14d
jmp    1558 <c_convert_16_24+0x458>
xor    %r14d,%r14d
jmp    1558 <c_convert_16_24+0x458>
xor    %r14d,%r14d
jmp    1558 <c_convert_16_24+0x458>
xor    %r14d,%r14d
jmp    1558 <c_convert_16_24+0x458>
xor    %r14d,%r14d
jmp    1558 <c_convert_16_24+0x458>
xor    %r14d,%r14d
jmp    1558 <c_convert_16_24+0x458>
xor    %r14d,%r14d
jmp    1558 <c_convert_16_24+0x458>
nopw   0x0(%rax,%rax,1)
mov    %esi,%ebx
shr    $0xb,%ebx
mov    %esi,%ebp
and    $0x1f,%ebp
shr    $0x5,%esi
and    $0x3f,%esi
imul   $0x20f,%ebx,%ebx
add    $0x17,%ebx
shr    $0x6,%ebx
imul   $0x103,%esi,%esi
add    $0x21,%esi
shr    $0x6,%esi
imul   $0x20f,%ebp,%ebp
add    $0x17,%ebp
shr    $0x6,%ebp
lea    0x1(%r14),%r9d
mov    %r14d,%eax
mov    %bl,(%r8,%rax,1)
lea    0x2(%r14),%eax
mov    %sil,(%r8,%r9,1)
add    $0x3,%r14d
mov    %bpl,(%r8,%rax,1)
cmp    %r11,%rdx
jae    14a7 <c_convert_16_24+0x3a7>
movzwl (%rdi,%rdx,1),%esi
add    $0x2,%rdx
test   %cl,%cl
jne    1500 <c_convert_16_24+0x400>
mov    %esi,%ebp
shr    $0xb,%ebp
mov    %esi,%ebx
and    $0x1f,%ebx
jmp    150a <c_convert_16_24+0x40a>

LLVM IR (-O0):
define void @c_convert_16_24(i8* %0, i32 %1, i8* %2, i8 zeroext %3) {
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i8
%9 = alloca i32
%10 = alloca i32
%11 = alloca i8
%12 = alloca i8
%13 = alloca i8
%14 = alloca i16
%15 = alloca i8
%16 = alloca i8
%17 = alloca i8
store i8* %0, i8** %5
store i32 %1, i32* %6
store i8* %2, i8** %7
store i8 %3, i8* %8
store i32 0, i32* %9
store i32 0, i32* %10
br label %18
18: ; preds = %54, %4
%19 = load i32, i32* %9
%20 = load i32, i32* %6
%21 = icmp ult i32 %19, %20
br i1 %21, label %22, label %96
22: ; preds = %18
%23 = load i8*, i8** %5
%24 = load i32, i32* %9
%25 = zext i32 %24 to i64
%26 = getelementptr inbounds i8, i8* %23, i64 %25
%27 = bitcast i8* %26 to i16*
%28 = load i16, i16* %27
store i16 %28, i16* %14
%29 = load i32, i32* %9
%30 = add i32 %29, 2
store i32 %30, i32* %9
%31 = load i8, i8* %8
%32 = zext i8 %31 to i32
%33 = icmp eq i32 %32, 0
br i1 %33, label %34, label %44
34: ; preds = %22
%35 = load i16, i16* %14
%36 = zext i16 %35 to i32
%37 = and i32 %36, 63488
%38 = ashr i32 %37, 11
%39 = trunc i32 %38 to i8
store i8 %39, i8* %13
%40 = load i16, i16* %14
%41 = zext i16 %40 to i32
%42 = and i32 %41, 31
%43 = trunc i32 %42 to i8
store i8 %43, i8* %11
br label %54
44: ; preds = %22
%45 = load i16, i16* %14
%46 = zext i16 %45 to i32
%47 = and i32 %46, 63488
%48 = ashr i32 %47, 11
%49 = trunc i32 %48 to i8
store i8 %49, i8* %11
%50 = load i16, i16* %14
%51 = zext i16 %50 to i32
%52 = and i32 %51, 31
%53 = trunc i32 %52 to i8
store i8 %53, i8* %13
br label %54
54: ; preds = %44, %34
%55 = load i16, i16* %14
%56 = zext i16 %55 to i32
%57 = and i32 %56, 2016
%58 = ashr i32 %57, 5
%59 = trunc i32 %58 to i8
store i8 %59, i8* %12
%60 = load i8, i8* %11
%61 = zext i8 %60 to i32
%62 = mul nsw i32 %61, 527
%63 = add nsw i32 %62, 23
%64 = ashr i32 %63, 6
%65 = trunc i32 %64 to i8
store i8 %65, i8* %15
%66 = load i8, i8* %12
%67 = zext i8 %66 to i32
%68 = mul nsw i32 %67, 259
%69 = add nsw i32 %68, 33
%70 = ashr i32 %69, 6
%71 = trunc i32 %70 to i8
store i8 %71, i8* %16
%72 = load i8, i8* %13
%73 = zext i8 %72 to i32
%74 = mul nsw i32 %73, 527
%75 = add nsw i32 %74, 23
%76 = ashr i32 %75, 6
%77 = trunc i32 %76 to i8
store i8 %77, i8* %17
%78 = load i8, i8* %15
%79 = load i8*, i8** %7
%80 = load i32, i32* %10
%81 = add i32 %80, 1
store i32 %81, i32* %10
%82 = zext i32 %80 to i64
%83 = getelementptr inbounds i8, i8* %79, i64 %82
store i8 %78, i8* %83
%84 = load i8, i8* %16
%85 = load i8*, i8** %7
%86 = load i32, i32* %10
%87 = add i32 %86, 1
store i32 %87, i32* %10
%88 = zext i32 %86 to i64
%89 = getelementptr inbounds i8, i8* %85, i64 %88
store i8 %84, i8* %89
%90 = load i8, i8* %17
%91 = load i8*, i8** %7
%92 = load i32, i32* %10
%93 = add i32 %92, 1
store i32 %93, i32* %10
%94 = zext i32 %92 to i64
%95 = getelementptr inbounds i8, i8* %91, i64 %94
store i8 %90, i8* %95
br label %18
96: ; preds = %18
ret void
}

LLVM IR (-O2):
define void @c_convert_16_24(i8* nocapture %0, i32 %1, i8* nocapture writeonly %2, i8 zeroext %3) {
%5 = icmp eq i32 %1, 0
br i1 %5, label %164, label %6
6: ; preds = %4
%7 = icmp eq i8 %3, 0
%8 = zext i32 %1 to i64
%9 = add nsw i64 %8, -1
%10 = lshr i64 %9, 1
%11 = add nuw i64 %10, 1
%12 = icmp ult i64 %9, 14
br i1 %12, label %118, label %13
13: ; preds = %6
%14 = add nsw i64 %8, -1
%15 = lshr i64 %14, 1
%16 = icmp ugt i64 %14, 8589934591
%17 = trunc i64 %15 to i32
%18 = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 %17, i32 3)
%19 = extractvalue { i32, i1 } %18, 0
%20 = extractvalue { i32, i1 } %18, 1
%21 = icmp eq i32 %19, -1
%22 = or i1 %21, %20
%23 = trunc i64 %15 to i32
%24 = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 %23, i32 3)
%25 = extractvalue { i32, i1 } %24, 0
%26 = extractvalue { i32, i1 } %24, 1
%27 = icmp ugt i32 %25, -3
%28 = or i1 %27, %26
%29 = icmp ugt i64 %14, 8589934591
%30 = or i1 %28, %29
%31 = getelementptr i8, i8* %2, i64 1
%32 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %15, i64 3)
%33 = extractvalue { i64, i1 } %32, 0
%34 = extractvalue { i64, i1 } %32, 1
%35 = getelementptr i8, i8* %31, i64 %33
%36 = icmp ult i8* %35, %31
%37 = or i1 %36, %34
%38 = getelementptr i8, i8* %2, i64 2
%39 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %15, i64 3)
%40 = extractvalue { i64, i1 } %39, 0
%41 = extractvalue { i64, i1 } %39, 1
%42 = getelementptr i8, i8* %38, i64 %40
%43 = icmp ult i8* %42, %38
%44 = or i1 %43, %41
%45 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %15, i64 3)
%46 = extractvalue { i64, i1 } %45, 0
%47 = extractvalue { i64, i1 } %45, 1
%48 = getelementptr i8, i8* %2, i64 %46
%49 = icmp ult i8* %48, %2
%50 = or i1 %49, %47
%51 = or i1 %22, %16
%52 = or i1 %51, %30
%53 = or i1 %52, %37
%54 = or i1 %53, %44
%55 = or i1 %54, %50
br i1 %55, label %118, label %56
56: ; preds = %13
%57 = add nsw i64 %8, -1
%58 = lshr i64 %57, 1
%59 = add nuw nsw i64 %8, 1
%60 = and i64 %59, 8589934590
%61 = getelementptr i8, i8* %0, i64 %60
%62 = mul i64 %58, 3
%63 = add i64 %62, 3
%64 = getelementptr i8, i8* %2, i64 %63
%65 = icmp ugt i8* %64, %0
%66 = icmp ugt i8* %61, %2
%67 = and i1 %65, %66
br i1 %67, label %118, label %68
68: ; preds = %56
%69 = and i64 %11, -8
%70 = shl i64 %69, 1
%71 = trunc i64 %69 to i32
%72 = mul i32 %71, 3
%73 = xor i1 %7, true
%74 = insertelement <8 x i1> poison, i1 %73, i64 0
%75 = shufflevector <8 x i1> %74, <8 x i1> poison, <8 x i32> zeroinitializer
%76 = getelementptr inbounds i8, i8* %2, i64 -2
br label %77
77: ; preds = %77, %68
%78 = phi i64 [ 0, %68 ], [ %114, %77 ]
%79 = shl i64 %78, 1
%80 = mul i64 %78, 3
%81 = getelementptr inbounds i8, i8* %0, i64 %79
%82 = bitcast i8* %81 to <8 x i16>*
%83 = load <8 x i16>, <8 x i16>* %82
%84 = lshr <8 x i16> %83, <i16 11, i16 11, i16 11, i16 11, i16 11, i16 11, i16 11, i16 11>
%85 = zext <8 x i16> %84 to <8 x i32>
%86 = and <8 x i16> %83, <i16 31, i16 31, i16 31, i16 31, i16 31, i16 31, i16 31, i16 31>
%87 = zext <8 x i16> %86 to <8 x i32>
%88 = zext <8 x i16> %83 to <8 x i32>
%89 = lshr <8 x i32> %88, <i32 11, i32 11, i32 11, i32 11, i32 11, i32 11, i32 11, i32 11>
%90 = and <8 x i32> %88, <i32 31, i32 31, i32 31, i32 31, i32 31, i32 31, i32 31, i32 31>
%91 = select <8 x i1> %75, <8 x i32> %87, <8 x i32> %89
%92 = select <8 x i1> %75, <8 x i32> %85, <8 x i32> %90
%93 = lshr <8 x i16> %83, <i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5>
%94 = and <8 x i16> %93, <i16 63, i16 63, i16 63, i16 63, i16 63, i16 63, i16 63, i16 63>
%95 = mul nuw nsw <8 x i32> %92, <i32 527, i32 527, i32 527, i32 527, i32 527, i32 527, i32 527, i32 527>
%96 = add nuw nsw <8 x i32> %95, <i32 23, i32 23, i32 23, i32 23, i32 23, i32 23, i32 23, i32 23>
%97 = lshr <8 x i32> %96, <i32 6, i32 6, i32 6, i32 6, i32 6, i32 6, i32 6, i32 6>
%98 = trunc <8 x i32> %97 to <8 x i8>
%99 = mul nuw nsw <8 x i16> %94, <i16 259, i16 259, i16 259, i16 259, i16 259, i16 259, i16 259, i16 259>
%100 = add nuw nsw <8 x i16> %99, <i16 33, i16 33, i16 33, i16 33, i16 33, i16 33, i16 33, i16 33>
%101 = lshr <8 x i16> %100, <i16 6, i16 6, i16 6, i16 6, i16 6, i16 6, i16 6, i16 6>
%102 = trunc <8 x i16> %101 to <8 x i8>
%103 = mul nuw nsw <8 x i32> %91, <i32 527, i32 527, i32 527, i32 527, i32 527, i32 527, i32 527, i32 527>
%104 = add nuw nsw <8 x i32> %103, <i32 23, i32 23, i32 23, i32 23, i32 23, i32 23, i32 23, i32 23>
%105 = lshr <8 x i32> %104, <i32 6, i32 6, i32 6, i32 6, i32 6, i32 6, i32 6, i32 6>
%106 = trunc <8 x i32> %105 to <8 x i8>
%107 = and i64 %80, 4294967288
%108 = or i64 %107, 2
%109 = getelementptr inbounds i8, i8* %76, i64 %108
%110 = bitcast i8* %109 to <24 x i8>*
%111 = shufflevector <8 x i8> %98, <8 x i8> %102, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
%112 = shufflevector <8 x i8> %106, <8 x i8> poison, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%113 = shufflevector <16 x i8> %111, <16 x i8> %112, <24 x i32> <i32 0, i32 8, i32 16, i32 1, i32 9, i32 17, i32 2, i32 10, i32 18, i32 3, i32 11, i32 19, i32 4, i32 12, i32 20, i32 5, i32 13, i32 21, i32 6, i32 14, i32 22, i32 7, i32 15, i32 23>
store <24 x i8> %113, <24 x i8>* %110
%114 = add nuw i64 %78, 8
%115 = icmp eq i64 %114, %69
br i1 %115, label %116, label %77
116: ; preds = %77
%117 = icmp eq i64 %11, %69
br i1 %117, label %164, label %118
118: ; preds = %56, %13, %6, %116
%119 = phi i64 [ 0, %56 ], [ 0, %13 ], [ 0, %6 ], [ %70, %116 ]
%120 = phi i32 [ 0, %56 ], [ 0, %13 ], [ 0, %6 ], [ %72, %116 ]
br label %121
121: ; preds = %118, %137
%122 = phi i64 [ %127, %137 ], [ %119, %118 ]
%123 = phi i32 [ %160, %137 ], [ %120, %118 ]
%124 = getelementptr inbounds i8, i8* %0, i64 %122
%125 = bitcast i8* %124 to i16*
%126 = load i16, i16* %125
%127 = add nuw nsw i64 %122, 2
br i1 %7, label %128, label %132
128: ; preds = %121
%129 = zext i16 %126 to i32
%130 = lshr i32 %129, 11
%131 = and i32 %129, 31
br label %137
132: ; preds = %121
%133 = lshr i16 %126, 11
%134 = zext i16 %133 to i32
%135 = and i16 %126, 31
%136 = zext i16 %135 to i32
br label %137
137: ; preds = %132, %128
%138 = phi i32 [ %130, %128 ], [ %136, %132 ]
%139 = phi i32 [ %131, %128 ], [ %134, %132 ]
%140 = lshr i16 %126, 5
%141 = and i16 %140, 63
%142 = mul nuw nsw i32 %139, 527
%143 = add nuw nsw i32 %142, 23
%144 = lshr i32 %143, 6
%145 = trunc i32 %144 to i8
%146 = mul nuw nsw i16 %141, 259
%147 = add nuw nsw i16 %146, 33
%148 = lshr i16 %147, 6
%149 = trunc i16 %148 to i8
%150 = mul nuw nsw i32 %138, 527
%151 = add nuw nsw i32 %150, 23
%152 = lshr i32 %151, 6
%153 = trunc i32 %152 to i8
%154 = add i32 %123, 1
%155 = zext i32 %123 to i64
%156 = getelementptr inbounds i8, i8* %2, i64 %155
store i8 %145, i8* %156
%157 = add i32 %123, 2
%158 = zext i32 %154 to i64
%159 = getelementptr inbounds i8, i8* %2, i64 %158
store i8 %149, i8* %159
%160 = add i32 %123, 3
%161 = zext i32 %157 to i64
%162 = getelementptr inbounds i8, i8* %2, i64 %161
store i8 %153, i8* %162
%163 = icmp ult i64 %127, %8
br i1 %163, label %121, label %164
164: ; preds = %137, %116, %4
ret void
}