#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 int uint32_t;
typedef int uint16_t;

/* Variables and functions */
char *malloc(int);
int rgb565interp(int, int);
int rgb565interp2(int, int);
char *DXT1toRGB565(char *dataIn, unsigned short width, unsigned short height) {
  int x, y;
  uint16_t colors[4];
  uint32_t pixels;
  int chunkIdx;
  char *dataOut = malloc(2 * width * height);
  for (y = 0; y < height; y += 4) {
    for (x = 0; x < width; x += 4) {
      chunkIdx = ((y * width / 2) + x * 2);
      colors[0] = (((uint32_t)(dataIn[chunkIdx + 1])) << 8) |
                  (((uint32_t)(dataIn[chunkIdx + 0])));
      colors[1] = (((uint32_t)(dataIn[chunkIdx + 3])) << 8) |
                  (((uint32_t)(dataIn[chunkIdx + 2])));
      pixels = (dataIn[chunkIdx + 4]) << 24;
      pixels |= (dataIn[chunkIdx + 4 + 1]) << 16;
      pixels |= (dataIn[chunkIdx + 4 + 2]) << 8;
      pixels |= (dataIn[chunkIdx + 4 + 3]);
      if (colors[0] > colors[1]) {
        colors[2] = rgb565interp(colors[0], colors[1]);
        colors[3] = rgb565interp(colors[1], colors[0]);
      } else {
        colors[2] = rgb565interp2(colors[0], colors[1]);
        colors[3] = 0;
      }
      int xs, ys;
      for (ys = 0; ys < 4; ys++) {
        for (xs = 0; xs < 4; xs++) {
          int shamt = (((3 - ys) * 4) + xs) * 2;
          uint32_t pixel = colors[(pixels & (3 << shamt)) >> shamt];
          char *outp = dataOut + (((y + ys) * width) + (x + xs)) * 4;
          *(dataOut + (x + (y * width)) * 2) = pixel;
          *(dataOut + (x + (y * width)) * 2 + 1) = pixel >> 8;
        }
      }
    }
  }
  return dataOut;
}


x86 assembly (clang, -O0):
<DXT1toRGB565>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %dx,%ax
mov    %si,%cx
mov    %rdi,-0x8(%rbp)
mov    %cx,-0xa(%rbp)
mov    %ax,-0xc(%rbp)
movzwl -0xa(%rbp),%edi
shl    $0x1,%edi
movzwl -0xc(%rbp),%eax
imul   %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
movzwl -0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    13b3 <DXT1toRGB565+0x283>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
movzwl -0xa(%rbp),%ecx
cmp    %ecx,%eax
jge    13a0 <DXT1toRGB565+0x270>
mov    -0x14(%rbp),%eax
movzwl -0xa(%rbp),%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
mov    -0x8(%rbp),%rcx
mov    -0x38(%rbp),%edx
add    $0x0,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
or     %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
mov    -0x8(%rbp),%rcx
mov    -0x38(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
or     %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
shl    $0x18,%eax
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x4,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
shl    $0x10,%eax
or     -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x4,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
or     -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x4,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
or     -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jle    1296 <DXT1toRGB565+0x166>
mov    -0x30(%rbp),%edi
mov    -0x2c(%rbp),%esi
call   1050 <rgb565interp@plt>
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%edi
mov    -0x30(%rbp),%esi
call   1050 <rgb565interp@plt>
mov    %eax,-0x24(%rbp)
jmp    12ab <DXT1toRGB565+0x17b>
mov    -0x30(%rbp),%edi
mov    -0x2c(%rbp),%esi
call   1040 <rgb565interp2@plt>
mov    %eax,-0x28(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x48(%rbp)
cmpl   $0x4,-0x48(%rbp)
jge    138d <DXT1toRGB565+0x25d>
movl   $0x0,-0x44(%rbp)
cmpl   $0x4,-0x44(%rbp)
jge    137a <DXT1toRGB565+0x24a>
mov    $0x3,%eax
sub    -0x48(%rbp),%eax
shl    $0x2,%eax
add    -0x44(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x4c(%rbp),%ecx
mov    $0x3,%edx
shl    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
mov    -0x4c(%rbp),%ecx
sar    %cl,%eax
cltq
mov    -0x30(%rbp,%rax,4),%eax
mov    %eax,-0x50(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x48(%rbp),%ecx
movzwl -0xa(%rbp),%edx
imul   %edx,%ecx
mov    -0x10(%rbp),%edx
add    -0x44(%rbp),%edx
add    %edx,%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x50(%rbp),%eax
mov    %al,%dl
mov    -0x40(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    -0x14(%rbp),%esi
movzwl -0xa(%rbp),%edi
imul   %edi,%esi
add    %esi,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x50(%rbp),%eax
sar    $0x8,%eax
mov    %al,%dl
mov    -0x40(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    -0x14(%rbp),%esi
movzwl -0xa(%rbp),%edi
imul   %edi,%esi
add    %esi,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,0x1(%rax,%rcx,1)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12c3 <DXT1toRGB565+0x193>
jmp    137f <DXT1toRGB565+0x24f>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    12b2 <DXT1toRGB565+0x182>
jmp    1392 <DXT1toRGB565+0x262>
mov    -0x10(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x10(%rbp)
jmp    117e <DXT1toRGB565+0x4e>
jmp    13a5 <DXT1toRGB565+0x275>
mov    -0x14(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x14(%rbp)
jmp    1168 <DXT1toRGB565+0x38>
mov    -0x40(%rbp),%rax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<DXT1toRGB565>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %edx,%ebp
mov    %rdi,0x38(%rsp)
mov    %esi,0xc(%rsp)
mov    %esi,%edi
imul   %edx,%edi
add    %edi,%edi
call   1030 <malloc@plt>
mov    %rax,0x30(%rsp)
test   %ebp,%ebp
je     128a <DXT1toRGB565+0x15a>
movzwl 0xc(%rsp),%eax
movzwl %bp,%ecx
mov    %rcx,0x50(%rsp)
lea    0x0(,%rax,8),%rcx
mov    %rcx,0x48(%rsp)
mov    %rax,0x60(%rsp)
lea    0x0(,%rax,4),%rax
mov    %rax,0x40(%rsp)
xor    %eax,%eax
mov    %rax,0x18(%rsp)
xor    %eax,%eax
mov    %rax,0x10(%rsp)
xor    %ecx,%ecx
jmp    11d2 <DXT1toRGB565+0xa2>
mov    0x58(%rsp),%rcx
add    $0x4,%rcx
mov    0x10(%rsp),%rax
add    0x48(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    0x18(%rsp),%rax
add    0x40(%rsp),%rax
mov    %rax,0x18(%rsp)
cmp    0x50(%rsp),%rcx
jae    128a <DXT1toRGB565+0x15a>
mov    %rcx,0x58(%rsp)
cmpw   $0x0,0xc(%rsp)
je     11a0 <DXT1toRGB565+0x70>
mov    0x18(%rsp),%rax
shr    $0x2,%rax
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,2),%r14
mov    0x10(%rsp),%r15
xor    %r12d,%r12d
jmp    123f <DXT1toRGB565+0x10f>
nopl   0x0(%rax,%rax,1)
mov    %ebp,%edi
mov    %ebx,%esi
call   1040 <rgb565interp2@plt>
mov    %eax,0x28(%rsp)
xor    %eax,%eax
mov    %eax,0x2c(%rsp)
mov    %r15d,%eax
and    $0xfffffff8,%eax
shr    $0x6,%r13
movzwl 0x20(%rsp,%r13,4),%ecx
mov    0x30(%rsp),%rdx
mov    %cx,(%rdx,%rax,1)
add    $0x4,%r12
add    $0x8,%r15
cmp    0x60(%rsp),%r12
jae    11a0 <DXT1toRGB565+0x70>
movsbl 0x1(%r14,%r12,2),%eax
shl    $0x8,%eax
movsbl (%r14,%r12,2),%ebp
or     %eax,%ebp
mov    %ebp,0x20(%rsp)
movsbl 0x3(%r14,%r12,2),%eax
shl    $0x8,%eax
movsbl 0x2(%r14,%r12,2),%ebx
or     %eax,%ebx
mov    %ebx,0x24(%rsp)
movzbl 0x7(%r14,%r12,2),%r13d
cmp    %ebx,%ebp
jle    1200 <DXT1toRGB565+0xd0>
mov    %ebp,%edi
mov    %ebx,%esi
call   1050 <rgb565interp@plt>
mov    %eax,0x28(%rsp)
mov    %ebx,%edi
mov    %ebp,%esi
call   1050 <rgb565interp@plt>
jmp    120f <DXT1toRGB565+0xdf>
mov    0x30(%rsp),%rax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define noalias i8* @DXT1toRGB565(i8* nocapture %0, i16 zeroext %1, i16 zeroext %2) {
%4 = alloca [4 x i32]
%5 = bitcast [4 x i32]* %4 to i8*
%6 = zext i16 %1 to i32
%7 = shl nuw nsw i32 %6, 1
%8 = zext i16 %2 to i32
%9 = mul nsw i32 %7, %8
%10 = tail call i8* @malloc(i32 %9)
%11 = icmp eq i16 %2, 0
br i1 %11, label %78, label %12
12: ; preds = %3
%13 = icmp eq i16 %1, 0
%14 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 0
%15 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 1
%16 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 2
%17 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 3
%18 = zext i16 %1 to i64
%19 = zext i16 %2 to i64
br label %20
20: ; preds = %12, %75
%21 = phi i64 [ 0, %12 ], [ %76, %75 ]
br i1 %13, label %75, label %22
22: ; preds = %20
%23 = mul nuw nsw i64 %21, %18
%24 = lshr exact i64 %23, 1
%25 = and i64 %24, 2147483646
br label %26
26: ; preds = %22, %59
%27 = phi i64 [ 0, %22 ], [ %73, %59 ]
%28 = shl nuw nsw i64 %27, 1
%29 = add nuw nsw i64 %28, %25
%30 = and i64 %29, 4294967294
%31 = or i64 %30, 1
%32 = getelementptr inbounds i8, i8* %0, i64 %31
%33 = load i8, i8* %32
%34 = sext i8 %33 to i32
%35 = shl nsw i32 %34, 8
%36 = getelementptr inbounds i8, i8* %0, i64 %29
%37 = load i8, i8* %36
%38 = sext i8 %37 to i32
%39 = or i32 %35, %38
store i32 %39, i32* %14
%40 = add nuw nsw i64 %29, 3
%41 = getelementptr inbounds i8, i8* %0, i64 %40
%42 = load i8, i8* %41
%43 = sext i8 %42 to i32
%44 = shl nsw i32 %43, 8
%45 = add nuw nsw i64 %29, 2
%46 = getelementptr inbounds i8, i8* %0, i64 %45
%47 = load i8, i8* %46
%48 = sext i8 %47 to i32
%49 = or i32 %44, %48
store i32 %49, i32* %15
%50 = add nuw nsw i64 %29, 7
%51 = getelementptr inbounds i8, i8* %0, i64 %50
%52 = load i8, i8* %51
%53 = icmp sgt i32 %39, %49
br i1 %53, label %54, label %57
54: ; preds = %26
%55 = tail call i32 @rgb565interp(i32 %39, i32 %49)
store i32 %55, i32* %16
%56 = tail call i32 @rgb565interp(i32 %49, i32 %39)
br label %59
57: ; preds = %26
%58 = tail call i32 @rgb565interp2(i32 %39, i32 %49)
store i32 %58, i32* %16
br label %59
59: ; preds = %57, %54
%60 = phi i32 [ 0, %57 ], [ %56, %54 ]
store i32 %60, i32* %17
%61 = add nuw nsw i64 %27, %23
%62 = shl nuw i64 %61, 1
%63 = and i64 %62, 4294967288
%64 = getelementptr inbounds i8, i8* %10, i64 %63
%65 = getelementptr inbounds i8, i8* %64, i64 1
%66 = lshr i8 %52, 6
%67 = zext i8 %66 to i64
%68 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 %67
%69 = load i32, i32* %68
%70 = trunc i32 %69 to i8
%71 = lshr i32 %69, 8
%72 = trunc i32 %71 to i8
store i8 %70, i8* %64
store i8 %72, i8* %65
%73 = add nuw nsw i64 %27, 4
%74 = icmp ult i64 %73, %18
br i1 %74, label %26, label %75
75: ; preds = %59, %20
%76 = add nuw nsw i64 %21, 4
%77 = icmp ult i64 %76, %19
br i1 %77, label %20, label %78
78: ; preds = %75, %3
ret i8* %10
}