#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef unsigned char u_int8_t;
typedef unsigned char u_int32_t;
typedef unsigned short u_int16_t;

/* Variables and functions */
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, int);
unsigned short make15color(unsigned char, unsigned char, unsigned char);
unsigned short make16color(unsigned char, unsigned char, unsigned char);
unsigned char make8color(unsigned char, unsigned char, unsigned char);
scalar_t__ malloc(unsigned long);
int /*<<< orphan*/ stderr;
void *convertRGB2FB(int fh, unsigned char *rgbbuff, unsigned long count,
                    int bpp, int *cpp) {
  unsigned long i;
  void *fbbuff = NULL;
  u_int8_t *c_fbbuff;
  u_int16_t *s_fbbuff;
  u_int32_t *i_fbbuff;
  switch (bpp) {
  case 8:
    *cpp = 1;
    c_fbbuff = (unsigned char *)malloc(count * sizeof(unsigned char));
    for (i = 0; i < count; i++)
      c_fbbuff[i] =
          make8color(rgbbuff[i * 3], rgbbuff[i * 3 + 1], rgbbuff[i * 3 + 2]);
    fbbuff = (void *)c_fbbuff;
    break;
  case 15:
    *cpp = 2;
    s_fbbuff = (unsigned short *)malloc(count * sizeof(unsigned short));
    for (i = 0; i < count; i++)
      s_fbbuff[i] =
          make15color(rgbbuff[i * 3], rgbbuff[i * 3 + 1], rgbbuff[i * 3 + 2]);
    fbbuff = (void *)s_fbbuff;
    break;
  case 16:
    *cpp = 2;
    s_fbbuff = (unsigned short *)malloc(count * sizeof(unsigned short));
    for (i = 0; i < count; i++)
      s_fbbuff[i] =
          make16color(rgbbuff[i * 3], rgbbuff[i * 3 + 1], rgbbuff[i * 3 + 2]);
    fbbuff = (void *)s_fbbuff;
    break;
  case 24:
    *cpp = 3;
    c_fbbuff = (unsigned char *)malloc(3 * count * sizeof(unsigned char));
    for (i = 0; i < count; i++) {
      c_fbbuff[3 * i] = (unsigned char)(rgbbuff[i * 3 + 2] & 0xFF);
      c_fbbuff[3 * i + 1] = (unsigned char)(rgbbuff[i * 3 + 1] & 0xFF);
      c_fbbuff[3 * i + 2] = (unsigned char)(rgbbuff[i * 3] & 0xFF);
    }
    fbbuff = (void *)c_fbbuff;
    break;
  case 32:
    *cpp = 4;
    i_fbbuff = (unsigned int *)malloc(count * sizeof(unsigned int));
    for (i = 0; i < count; i++)
      i_fbbuff[i] = ((rgbbuff[i * 3] << 16) & 0xFF0000) |
                    ((rgbbuff[i * 3 + 1] << 8) & 0xFF00) |
                    (rgbbuff[i * 3 + 2] & 0xFF);
    fbbuff = (void *)i_fbbuff;
    break;
  default:
    fprintf(stderr, "Unsupported video mode! You've got: %dbpp\n", bpp);
    exit(1);
  }
  return fbbuff;
}


x86 assembly (clang, -O0):
<convertRGB2FB>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xfffffff8,%eax
mov    %eax,%ecx
mov    %rcx,-0x58(%rbp)
sub    $0x18,%eax
ja     14b3 <convertRGB2FB+0x353>
mov    -0x58(%rbp),%rax
lea    0xe5e(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x28(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x18(%rbp),%rdi
shl    $0x0,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x40(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    122e <convertRGB2FB+0xce>
mov    -0x10(%rbp),%rax
imul   $0x3,-0x30(%rbp),%rcx
mov    (%rax,%rcx,1),%sil
mov    -0x10(%rbp),%rax
imul   $0x3,-0x30(%rbp),%rcx
mov    0x1(%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
imul   $0x3,-0x30(%rbp),%rcx
movzbl %sil,%edi
movzbl %dl,%esi
movzbl 0x2(%rax,%rcx,1),%edx
call   1070 <make8color@plt>
mov    %al,%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    11ce <convertRGB2FB+0x6e>
mov    -0x40(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    14d5 <convertRGB2FB+0x375>
mov    -0x28(%rbp),%rax
movl   $0x2,(%rax)
mov    -0x18(%rbp),%rdi
shl    $0x1,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x48(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    12c0 <convertRGB2FB+0x160>
mov    -0x10(%rbp),%rax
imul   $0x3,-0x30(%rbp),%rcx
mov    (%rax,%rcx,1),%sil
mov    -0x10(%rbp),%rax
imul   $0x3,-0x30(%rbp),%rcx
mov    0x1(%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
imul   $0x3,-0x30(%rbp),%rcx
movzbl %sil,%edi
movzbl %dl,%esi
movzbl 0x2(%rax,%rcx,1),%edx
call   1040 <make15color@plt>
mov    %ax,%dx
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    125e <convertRGB2FB+0xfe>
mov    -0x48(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    14d5 <convertRGB2FB+0x375>
mov    -0x28(%rbp),%rax
movl   $0x2,(%rax)
mov    -0x18(%rbp),%rdi
shl    $0x1,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x48(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1352 <convertRGB2FB+0x1f2>
mov    -0x10(%rbp),%rax
imul   $0x3,-0x30(%rbp),%rcx
mov    (%rax,%rcx,1),%sil
mov    -0x10(%rbp),%rax
imul   $0x3,-0x30(%rbp),%rcx
mov    0x1(%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
imul   $0x3,-0x30(%rbp),%rcx
movzbl %sil,%edi
movzbl %dl,%esi
movzbl 0x2(%rax,%rcx,1),%edx
call   1060 <make16color@plt>
mov    %ax,%dx
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    12f0 <convertRGB2FB+0x190>
mov    -0x48(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    14d5 <convertRGB2FB+0x375>
mov    -0x28(%rbp),%rax
movl   $0x3,(%rax)
imul   $0x3,-0x18(%rbp),%rdi
shl    $0x0,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x40(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1406 <convertRGB2FB+0x2a6>
mov    -0x10(%rbp),%rax
imul   $0x3,-0x30(%rbp),%rcx
movzbl 0x2(%rax,%rcx,1),%eax
and    $0xff,%eax
mov    %al,%dl
mov    -0x40(%rbp),%rax
imul   $0x3,-0x30(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
imul   $0x3,-0x30(%rbp),%rcx
movzbl 0x1(%rax,%rcx,1),%eax
and    $0xff,%eax
mov    %al,%dl
mov    -0x40(%rbp),%rax
imul   $0x3,-0x30(%rbp),%rcx
mov    %dl,0x1(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
imul   $0x3,-0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
and    $0xff,%eax
mov    %al,%dl
mov    -0x40(%rbp),%rax
imul   $0x3,-0x30(%rbp),%rcx
mov    %dl,0x2(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1383 <convertRGB2FB+0x223>
mov    -0x40(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    14d5 <convertRGB2FB+0x375>
mov    -0x28(%rbp),%rax
movl   $0x4,(%rax)
mov    -0x18(%rbp),%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x50(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    14a6 <convertRGB2FB+0x346>
mov    -0x10(%rbp),%rax
imul   $0x3,-0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x10,%eax
and    $0xff0000,%eax
mov    -0x10(%rbp),%rcx
imul   $0x3,-0x30(%rbp),%rdx
movzbl 0x1(%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
and    $0xff00,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
imul   $0x3,-0x30(%rbp),%rdx
movzbl 0x2(%rcx,%rdx,1),%ecx
and    $0xff,%ecx
or     %ecx,%eax
mov    %al,%dl
mov    -0x50(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1436 <convertRGB2FB+0x2d6>
mov    -0x50(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    14d5 <convertRGB2FB+0x375>
mov    0x2b26(%rip),%rax
mov    (%rax),%edi
mov    -0x1c(%rbp),%edx
lea    0xb9e(%rip),%rsi
call   1030 <fprintf@plt>
mov    $0x1,%edi
call   1080 <exit@plt>
mov    -0x38(%rbp),%rax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<convertRGB2FB>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
lea    -0x8(%rcx),%eax
cmp    $0x18,%eax
ja     13f2 <convertRGB2FB+0x292>
mov    %rdx,%r15
mov    %rsi,%r12
lea    0xe7f(%rip),%rdx
movslq (%rdx,%rax,4),%rax
add    %rdx,%rax
jmp    *%rax
movl   $0x1,(%r8)
mov    %r15,%rdi
call   1050 <malloc@plt>
mov    %rax,%r14
test   %r15,%r15
je     13e3 <convertRGB2FB+0x283>
add    $0x2,%r12
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movzbl -0x2(%r12),%edi
movzbl -0x1(%r12),%esi
movzbl (%r12),%edx
call   1070 <make8color@plt>
mov    %al,(%r14,%rbx,1)
add    $0x1,%rbx
add    $0x3,%r12
cmp    %rbx,%r15
jne    11b0 <convertRGB2FB+0x50>
jmp    13e3 <convertRGB2FB+0x283>
movl   $0x2,(%r8)
lea    (%r15,%r15,1),%rdi
call   1050 <malloc@plt>
mov    %rax,%r14
test   %r15,%r15
je     13e3 <convertRGB2FB+0x283>
add    $0x2,%r12
xor    %ebx,%ebx
xchg   %ax,%ax
movzbl -0x2(%r12),%edi
movzbl -0x1(%r12),%esi
movzbl (%r12),%edx
call   1040 <make15color@plt>
mov    %ax,(%r14,%rbx,2)
add    $0x1,%rbx
add    $0x3,%r12
cmp    %rbx,%r15
jne    1200 <convertRGB2FB+0xa0>
jmp    13e3 <convertRGB2FB+0x283>
movl   $0x2,(%r8)
lea    (%r15,%r15,1),%rdi
call   1050 <malloc@plt>
mov    %rax,%r14
test   %r15,%r15
je     13e3 <convertRGB2FB+0x283>
add    $0x2,%r12
xor    %ebx,%ebx
nop
movzbl -0x2(%r12),%edi
movzbl -0x1(%r12),%esi
movzbl (%r12),%edx
call   1060 <make16color@plt>
mov    %ax,(%r14,%rbx,2)
add    $0x1,%rbx
add    $0x3,%r12
cmp    %rbx,%r15
jne    1250 <convertRGB2FB+0xf0>
jmp    13e3 <convertRGB2FB+0x283>
movl   $0x3,(%r8)
lea    (%r15,%r15,2),%rdi
call   1050 <malloc@plt>
mov    %rax,%r14
test   %r15,%r15
je     13e3 <convertRGB2FB+0x283>
cmp    $0x1,%r15
jne    12e1 <convertRGB2FB+0x181>
xor    %eax,%eax
jmp    133a <convertRGB2FB+0x1da>
movl   $0x4,(%r8)
lea    0x0(,%r15,4),%rdi
call   1050 <malloc@plt>
mov    %rax,%r14
test   %r15,%r15
je     13e3 <convertRGB2FB+0x283>
lea    -0x1(%r15),%rcx
mov    %r15d,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    1365 <convertRGB2FB+0x205>
xor    %ecx,%ecx
jmp    13ae <convertRGB2FB+0x24e>
mov    %r15,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movzbl 0x2(%r12,%rax,1),%edx
mov    %dl,(%r14,%rax,1)
movzbl 0x1(%r12,%rax,1),%edx
mov    %dl,0x1(%r14,%rax,1)
movzbl (%r12,%rax,1),%edx
mov    %dl,0x2(%r14,%rax,1)
movzbl 0x5(%r12,%rax,1),%edx
mov    %dl,0x3(%r14,%rax,1)
movzbl 0x4(%r12,%rax,1),%edx
mov    %dl,0x4(%r14,%rax,1)
movzbl 0x3(%r12,%rax,1),%edx
mov    %dl,0x5(%r14,%rax,1)
add    $0x6,%rax
add    $0xfffffffffffffffe,%rcx
jne    12f0 <convertRGB2FB+0x190>
test   $0x1,%r15b
je     13e3 <convertRGB2FB+0x283>
mov    0x2(%r12,%rax,1),%cl
mov    %cl,(%r14,%rax,1)
mov    0x1(%r12,%rax,1),%cl
mov    %cl,0x1(%r14,%rax,1)
mov    (%r12,%rax,1),%cl
mov    %cl,0x2(%r14,%rax,1)
jmp    13e3 <convertRGB2FB+0x283>
and    $0xfffffffffffffffc,%r15
mov    $0x9,%edx
xor    %ecx,%ecx
movzbl -0x7(%r12,%rdx,1),%ebx
mov    %bl,(%r14,%rcx,1)
movzbl -0x4(%r12,%rdx,1),%ebx
mov    %bl,0x1(%r14,%rcx,1)
movzbl -0x1(%r12,%rdx,1),%ebx
mov    %bl,0x2(%r14,%rcx,1)
mov    %rdx,%rsi
or     $0x2,%rsi
movzbl (%r12,%rsi,1),%ebx
mov    %bl,0x3(%r14,%rcx,1)
add    $0x4,%rcx
add    $0xc,%rdx
cmp    %rcx,%r15
jne    1370 <convertRGB2FB+0x210>
test   %rax,%rax
je     13e3 <convertRGB2FB+0x283>
mov    %r14,%rdx
add    %rcx,%rdx
lea    (%rcx,%rcx,2),%rcx
add    %r12,%rcx
add    $0x2,%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movzbl (%rcx),%ebx
mov    %bl,(%rdx,%rsi,1)
add    $0x1,%rsi
add    $0x3,%rcx
cmp    %rsi,%rax
jne    13d0 <convertRGB2FB+0x270>
mov    %r14,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
mov    0x2be7(%rip),%rax
mov    (%rax),%edi
lea    0xc62(%rip),%rsi
mov    %ecx,%edx
call   1030 <fprintf@plt>
mov    $0x1,%edi
call   1080 <exit@plt>

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

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