void GrOffScreen4BPPLineDrawH(void *pvDisplayData, int lX1, int lX2, int lY,
                              unsigned int ulValue) {
  unsigned char *pucData;
  int lBytesPerRow;
  ;
  pucData = (unsigned char *)pvDisplayData;
  lBytesPerRow = (*(unsigned short *)(pucData + 1) + 1) / 2;
  pucData += (lBytesPerRow * lY) + (lX1 / 2) + 6 + (16 * 3);
  ulValue =
      ((ulValue << 28) | (ulValue << 24) | (ulValue << 20) | (ulValue << 16) |
       (ulValue << 12) | (ulValue << 8) | (ulValue << 4) | ulValue);
  if (lX1 & 1) {
    *pucData = (*pucData & 0xf0) | (ulValue & 0x0f);
    pucData++;
    lX1++;
  }
  if (((unsigned int)pucData & 1) && ((lX2 - lX1) > 0)) {
    *pucData++ = ulValue & 0xff;
    lX1 += 2;
  }
  if (((unsigned int)pucData & 2) && ((lX2 - lX1) > 2)) {
    *(unsigned short *)pucData = ulValue & 0xffff;
    pucData += 2;
    lX1 += 4;
  }
  while ((lX1 + 7) <= lX2) {
    *(unsigned int *)pucData = ulValue;
    pucData += 4;
    lX1 += 8;
  }
  if ((lX1 + 3) <= lX2) {
    *(unsigned short *)pucData = ulValue & 0xffff;
    pucData += 2;
    lX1 += 4;
  }
  if ((lX1 + 1) <= lX2) {
    *pucData++ = ulValue & 0xff;
    lX1 += 2;
  }
  if (lX1 == lX2) {
    *pucData = (*pucData & 0x0f) | (ulValue & 0xf0);
  }
}


x86 assembly (clang, -O0):
<GrOffScreen4BPPLineDrawH>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movzwl 0x1(%rax),%eax
add    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0xc(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
add    %eax,%ecx
add    $0x6,%ecx
add    $0x30,%ecx
mov    -0x20(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x1c,%eax
mov    -0x18(%rbp),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
mov    -0x18(%rbp),%ecx
shl    $0x14,%ecx
or     %ecx,%eax
mov    -0x18(%rbp),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x18(%rbp),%ecx
shl    $0xc,%ecx
or     %ecx,%eax
mov    -0x18(%rbp),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x18(%rbp),%ecx
shl    $0x4,%ecx
or     %ecx,%eax
or     -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     11d7 <GrOffScreen4BPPLineDrawH+0xd7>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
and    $0xf0,%eax
mov    -0x18(%rbp),%ecx
and    $0xf,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
mov    -0x20(%rbp),%rax
and    $0x1,%eax
cmp    $0x0,%eax
je     121a <GrOffScreen4BPPLineDrawH+0x11a>
mov    -0x10(%rbp),%eax
sub    -0xc(%rbp),%eax
cmp    $0x0,%eax
jle    121a <GrOffScreen4BPPLineDrawH+0x11a>
mov    -0x18(%rbp),%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
mov    -0xc(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0xc(%rbp)
mov    -0x20(%rbp),%rax
and    $0x2,%eax
cmp    $0x0,%eax
je     1260 <GrOffScreen4BPPLineDrawH+0x160>
mov    -0x10(%rbp),%eax
sub    -0xc(%rbp),%eax
cmp    $0x2,%eax
jle    1260 <GrOffScreen4BPPLineDrawH+0x160>
mov    -0x18(%rbp),%eax
and    $0xffff,%eax
mov    %ax,%cx
mov    -0x20(%rbp),%rax
mov    %cx,(%rax)
mov    -0x20(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x20(%rbp)
mov    -0xc(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0xc(%rbp)
jmp    1265 <GrOffScreen4BPPLineDrawH+0x165>
mov    -0xc(%rbp),%eax
add    $0x7,%eax
cmp    -0x10(%rbp),%eax
jg     1297 <GrOffScreen4BPPLineDrawH+0x197>
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0xc(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0xc(%rbp)
jmp    1265 <GrOffScreen4BPPLineDrawH+0x165>
mov    -0xc(%rbp),%eax
add    $0x3,%eax
cmp    -0x10(%rbp),%eax
jg     12cd <GrOffScreen4BPPLineDrawH+0x1cd>
mov    -0x18(%rbp),%eax
and    $0xffff,%eax
mov    %ax,%cx
mov    -0x20(%rbp),%rax
mov    %cx,(%rax)
mov    -0x20(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x20(%rbp)
mov    -0xc(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
cmp    -0x10(%rbp),%eax
jg     1300 <GrOffScreen4BPPLineDrawH+0x200>
mov    -0x18(%rbp),%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
mov    -0xc(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jne    1329 <GrOffScreen4BPPLineDrawH+0x229>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
and    $0xf,%eax
mov    -0x18(%rbp),%ecx
and    $0xf0,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<GrOffScreen4BPPLineDrawH>:
movzwl 0x1(%rdi),%eax
add    $0x1,%eax
shr    %eax
imul   %ecx,%eax
mov    %esi,%ecx
shr    $0x1f,%ecx
add    %esi,%ecx
sar    %ecx
add    %ecx,%eax
add    $0x36,%eax
cltq
add    %rdi,%rax
mov    %r8d,%ecx
shl    $0x1c,%ecx
mov    %r8d,%r11d
shl    $0x18,%r11d
mov    %r8d,%r10d
shl    $0x14,%r10d
or     %ecx,%r10d
mov    %r8d,%r9d
shl    $0x10,%r9d
mov    %r8d,%ecx
shl    $0xc,%ecx
or     %r9d,%ecx
mov    %r8d,%edi
shl    $0x8,%edi
or     %ecx,%edi
mov    %r8d,%ecx
shl    $0x4,%ecx
or     %r8d,%r11d
or     %r10d,%r11d
or     %edi,%r11d
test   $0x1,%sil
je     117b <GrOffScreen4BPPLineDrawH+0x7b>
mov    (%rax),%dil
and    $0xf0,%dil
and    $0xf,%r8b
or     %dil,%r8b
mov    %r8b,(%rax)
add    $0x1,%rax
add    $0x1,%esi
or     %ecx,%r11d
test   $0x1,%al
je     1190 <GrOffScreen4BPPLineDrawH+0x90>
cmp    %edx,%esi
jge    1190 <GrOffScreen4BPPLineDrawH+0x90>
mov    %r11b,(%rax)
add    $0x1,%rax
add    $0x2,%esi
test   $0x2,%al
je     11a8 <GrOffScreen4BPPLineDrawH+0xa8>
mov    %edx,%ecx
sub    %esi,%ecx
cmp    $0x3,%ecx
jl     11a8 <GrOffScreen4BPPLineDrawH+0xa8>
mov    %r11w,(%rax)
add    $0x2,%rax
add    $0x4,%esi
lea    0x7(%rsi),%ecx
cmp    %edx,%ecx
jg     12b3 <GrOffScreen4BPPLineDrawH+0x1b3>
lea    0xf(%rsi),%ecx
lea    0x1(%rdx),%r9d
cmp    %r9d,%ecx
cmovg  %ecx,%r9d
sub    %esi,%r9d
add    $0xfffffff8,%r9d
cmp    $0x38,%r9d
jb     1291 <GrOffScreen4BPPLineDrawH+0x191>
shr    $0x3,%r9d
add    $0x1,%r9d
mov    %r9d,%r8d
and    $0xfffffff8,%r8d
movd   %r11d,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%r8),%rcx
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r10d
and    $0x3,%r10d
cmp    $0x18,%rcx
jae    120b <GrOffScreen4BPPLineDrawH+0x10b>
xor    %ecx,%ecx
jmp    1259 <GrOffScreen4BPPLineDrawH+0x159>
and    $0xfffffffffffffffc,%rdi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu %xmm0,(%rax,%rcx,4)
movdqu %xmm0,0x10(%rax,%rcx,4)
movdqu %xmm0,0x20(%rax,%rcx,4)
movdqu %xmm0,0x30(%rax,%rcx,4)
movdqu %xmm0,0x40(%rax,%rcx,4)
movdqu %xmm0,0x50(%rax,%rcx,4)
movdqu %xmm0,0x60(%rax,%rcx,4)
movdqu %xmm0,0x70(%rax,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rdi
jne    1220 <GrOffScreen4BPPLineDrawH+0x120>
test   %r10,%r10
je     1284 <GrOffScreen4BPPLineDrawH+0x184>
lea    (%rax,%rcx,4),%rcx
add    $0x10,%rcx
shl    $0x5,%r10
xor    %edi,%edi
nopl   0x0(%rax)
movdqu %xmm0,-0x10(%rcx,%rdi,1)
movdqu %xmm0,(%rcx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r10
jne    1270 <GrOffScreen4BPPLineDrawH+0x170>
lea    (%rsi,%r8,8),%esi
lea    (%rax,%r8,4),%rax
cmp    %r9,%r8
je     12b3 <GrOffScreen4BPPLineDrawH+0x1b3>
mov    %esi,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r11d,(%rax)
add    $0x4,%rax
lea    0x8(%rcx),%esi
add    $0xf,%ecx
cmp    %edx,%ecx
mov    %esi,%ecx
jle    12a0 <GrOffScreen4BPPLineDrawH+0x1a0>
lea    0x3(%rsi),%ecx
cmp    %edx,%ecx
jle    12c3 <GrOffScreen4BPPLineDrawH+0x1c3>
cmp    %edx,%esi
jl     12d2 <GrOffScreen4BPPLineDrawH+0x1d2>
cmp    %edx,%esi
je     12e0 <GrOffScreen4BPPLineDrawH+0x1e0>
ret
mov    %r11w,(%rax)
add    $0x2,%rax
add    $0x4,%esi
cmp    %edx,%esi
jge    12be <GrOffScreen4BPPLineDrawH+0x1be>
mov    %r11b,(%rax)
add    $0x1,%rax
add    $0x2,%esi
cmp    %edx,%esi
jne    12c2 <GrOffScreen4BPPLineDrawH+0x1c2>
mov    (%rax),%cl
and    $0xf,%cl
and    $0xf0,%r11b
or     %cl,%r11b
mov    %r11b,(%rax)
ret

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

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