void True24PixelDriverC(short *diffp, void *colorTable, short rowBytes,
                        void *baseAddr, short rowCount, short rightEdge) {
  long *colors;
  short theColor;
  long pixels;
  short x1;
  char *addr;
  long *dest;
  long *endAddr;
  colors = *(long **)colorTable;
  addr = (char *)baseAddr;
  while (rowCount--) {
    x1 = *diffp++;
    while (x1 < rightEdge) {
      theColor = *diffp++;
      if (theColor < 0) {
        x1 = *diffp++;
      } else {
        pixels = colors[theColor];
        dest = x1 + (long *)addr;
        x1 = *diffp++;
        endAddr = x1 + (long *)addr;
        while (dest < endAddr) {
          *dest++ = pixels;
        }
      }
    }
    addr += rowBytes;
  }
}


x86 assembly (clang, -O0):
<True24PixelDriverC>:
push   %rbp
mov    %rsp,%rbp
mov    %r8d,-0x7c(%rbp)
mov    %rcx,%rax
mov    -0x7c(%rbp),%ecx
mov    %rax,-0x78(%rbp)
mov    %edx,%eax
mov    -0x78(%rbp),%rdx
mov    %eax,-0x6c(%rbp)
mov    %rsi,%rax
mov    -0x6c(%rbp),%esi
mov    %rax,-0x68(%rbp)
mov    %rdi,%r8
mov    -0x68(%rbp),%rdi
mov    %r9w,%ax
mov    %r8,-0x8(%rbp)
mov    %rdi,-0x10(%rbp)
mov    %si,-0x12(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %cx,-0x22(%rbp)
mov    %ax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x22(%rbp),%ax
mov    %ax,%cx
add    $0xffff,%cx
mov    %cx,-0x22(%rbp)
cmp    $0x0,%ax
je     1275 <True24PixelDriverC+0x175>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x8(%rbp)
mov    (%rax),%ax
mov    %ax,-0x42(%rbp)
movswl -0x42(%rbp),%eax
movswl -0x24(%rbp),%ecx
cmp    %ecx,%eax
jge    125e <True24PixelDriverC+0x15e>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x8(%rbp)
mov    (%rax),%ax
mov    %ax,-0x32(%rbp)
movswl -0x32(%rbp),%eax
cmp    $0x0,%eax
jge    11d8 <True24PixelDriverC+0xd8>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x8(%rbp)
mov    (%rax),%ax
mov    %ax,-0x42(%rbp)
jmp    1259 <True24PixelDriverC+0x159>
mov    -0x30(%rbp),%rax
movswq -0x32(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x40(%rbp)
movswl -0x42(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x8(%rbp)
mov    (%rax),%ax
mov    %ax,-0x42(%rbp)
movswl -0x42(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x60(%rbp),%rax
jae    1254 <True24PixelDriverC+0x154>
mov    -0x40(%rbp),%rcx
mov    -0x58(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x58(%rbp)
mov    %rcx,(%rax)
jmp    122b <True24PixelDriverC+0x12b>
jmp    1259 <True24PixelDriverC+0x159>
jmp    118a <True24PixelDriverC+0x8a>
movswl -0x12(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    115b <True24PixelDriverC+0x5b>
pop    %rbp
ret

x86 assembly (clang, -O2):
<True24PixelDriverC>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rcx,-0x58(%rsp)
test   %r8w,%r8w
je     1421 <True24PixelDriverC+0x321>
mov    (%rsi),%r12
movswq %dx,%rax
mov    %rax,-0x48(%rsp)
mov    -0x58(%rsp),%rbp
mov    %rbp,%rdx
not    %rdx
lea    0x8(%rbp),%rax
lea    0x80(%rbp),%rcx
mov    %rcx,-0x40(%rsp)
lea    0x10(%rbp),%rcx
mov    %rcx,-0x28(%rsp)
xor    %ecx,%ecx
mov    %rcx,-0x50(%rsp)
mov    %rax,-0x18(%rsp)
mov    %rax,-0x68(%rsp)
mov    %rbp,-0x70(%rsp)
mov    %rdx,%rax
mov    %rdx,-0x78(%rsp)
mov    %r12,-0x30(%rsp)
mov    %rdx,-0x38(%rsp)
jmp    11b6 <True24PixelDriverC+0xb6>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0x48(%rsp),%rax
add    %rax,%rbp
addq   $0x1,-0x50(%rsp)
sub    %rax,-0x78(%rsp)
add    %rax,-0x70(%rsp)
add    %rax,-0x68(%rsp)
add    %rax,-0x40(%rsp)
add    %rax,-0x28(%rsp)
mov    -0x5c(%rsp),%r8d
test   %r8w,%r8w
je     1421 <True24PixelDriverC+0x321>
add    $0xffffffff,%r8d
mov    %r8d,-0x5c(%rsp)
movzwl (%rdi),%eax
add    $0x2,%rdi
cmp    %r9w,%ax
jge    1180 <True24PixelDriverC+0x80>
mov    -0x50(%rsp),%rbx
imul   -0x48(%rsp),%rbx
mov    -0x58(%rsp),%rcx
lea    (%rbx,%rcx,1),%rsi
mov    -0x18(%rsp),%rcx
add    %rbx,%rcx
mov    %rcx,-0x8(%rsp)
mov    %rsi,-0x10(%rsp)
mov    %rbx,-0x20(%rsp)
jmp    1216 <True24PixelDriverC+0x116>
nopl   0x0(%rax)
movzwl 0x2(%rdi),%r8d
add    $0x4,%rdi
mov    %r8d,%eax
cmp    %r9w,%r8w
jge    1180 <True24PixelDriverC+0x80>
movzwl (%rdi),%ecx
test   %cx,%cx
js     1200 <True24PixelDriverC+0x100>
movzwl 0x2(%rdi),%r8d
cmp    %r8w,%ax
jge    1205 <True24PixelDriverC+0x105>
mov    (%r12,%rcx,8),%r14
movswq %r8w,%r10
movswq %ax,%r13
lea    0x0(,%r13,8),%r15
add    %rbp,%r15
lea    (%rsi,%r10,8),%rax
mov    -0x8(%rsp),%rcx
lea    (%rcx,%r13,8),%r11
cmp    %r11,%rax
cmova  %rax,%r11
add    %rdx,%r11
lea    (%rbx,%r13,8),%rax
sub    %rax,%r11
cmp    $0x18,%r11
jb     1404 <True24PixelDriverC+0x304>
lea    0x0(,%r10,8),%rbx
shl    $0x3,%r13
shr    $0x3,%r11
add    $0x1,%r11
mov    %r11,%rcx
and    $0xfffffffffffffffc,%rcx
movq   %r14,%xmm0
pshufd $0x44,%xmm0,%xmm0
lea    -0x4(%rcx),%rax
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
cmp    $0x1c,%rax
jae    12a9 <True24PixelDriverC+0x1a9>
xor    %eax,%eax
jmp    1369 <True24PixelDriverC+0x269>
mov    -0x70(%rsp),%rax
add    %rbx,%rax
mov    -0x68(%rsp),%rsi
add    %r13,%rsi
cmp    %rsi,%rax
cmova  %rax,%rsi
add    -0x78(%rsp),%rsi
sub    %r13,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
and    $0xfffffffffffffffc,%rsi
add    $0xfffffffffffffffc,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
and    $0xfffffffffffffff8,%rsi
mov    -0x40(%rsp),%rax
lea    (%rax,%r13,1),%r12
xor    %eax,%eax
nop
movdqu %xmm0,-0x80(%r12,%rax,8)
movdqu %xmm0,-0x70(%r12,%rax,8)
movdqu %xmm0,-0x60(%r12,%rax,8)
movdqu %xmm0,-0x50(%r12,%rax,8)
movdqu %xmm0,-0x40(%r12,%rax,8)
movdqu %xmm0,-0x30(%r12,%rax,8)
movdqu %xmm0,-0x20(%r12,%rax,8)
movdqu %xmm0,-0x10(%r12,%rax,8)
movdqu %xmm0,(%r12,%rax,8)
movdqu %xmm0,0x10(%r12,%rax,8)
movdqu %xmm0,0x20(%r12,%rax,8)
movdqu %xmm0,0x30(%r12,%rax,8)
movdqu %xmm0,0x40(%r12,%rax,8)
movdqu %xmm0,0x50(%r12,%rax,8)
movdqu %xmm0,0x60(%r12,%rax,8)
movdqu %xmm0,0x70(%r12,%rax,8)
add    $0x20,%rax
add    $0xfffffffffffffff8,%rsi
jne    12f0 <True24PixelDriverC+0x1f0>
test   $0x7,%dl
je     13d3 <True24PixelDriverC+0x2d3>
lea    0x0(,%rax,8),%rdx
add    %r13,%rdx
mov    -0x28(%rsp),%rax
lea    (%rax,%rdx,1),%rsi
add    %rbp,%rdx
add    -0x70(%rsp),%rbx
mov    -0x68(%rsp),%rax
add    %r13,%rax
cmp    %rax,%rbx
cmovbe %rax,%rbx
add    -0x78(%rsp),%ebx
sub    %r13d,%ebx
shr    $0x3,%bl
add    $0x1,%bl
and    $0x1c,%bl
add    $0xfc,%bl
shr    $0x2,%bl
add    $0x1,%bl
movzbl %bl,%eax
and    $0x7,%eax
shl    $0x5,%rax
xor    %ebx,%ebx
xchg   %ax,%ax
movdqu %xmm0,(%rdx,%rbx,1)
movdqu %xmm0,(%rsi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rax
jne    13c0 <True24PixelDriverC+0x2c0>
cmp    %rcx,%r11
mov    -0x10(%rsp),%rsi
jne    13f1 <True24PixelDriverC+0x2f1>
mov    -0x30(%rsp),%r12
mov    -0x38(%rsp),%rdx
mov    -0x20(%rsp),%rbx
jmp    1205 <True24PixelDriverC+0x105>
lea    (%r15,%rcx,8),%r15
mov    -0x30(%rsp),%r12
mov    -0x38(%rsp),%rdx
mov    -0x20(%rsp),%rbx
lea    0x0(,%r10,8),%rax
add    %rbp,%rax
nop
mov    %r14,(%r15)
add    $0x8,%r15
cmp    %rax,%r15
jb     1410 <True24PixelDriverC+0x310>
jmp    1205 <True24PixelDriverC+0x105>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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