void GrOffScreen1BPPLineDrawH(void *pvDisplayData, int lX1, int lX2, int lY,
                              unsigned int ulValue) {
  int lBytesPerRow, lMask;
  unsigned char *pucData;
  ;
  pucData = (unsigned char *)pvDisplayData;
  lBytesPerRow = (*(unsigned short *)(pucData + 1) + 7) / 8;
  pucData += (lBytesPerRow * lY) + (lX1 / 8) + 5;
  if (ulValue) {
    ulValue = 0xffffffff;
  }
  if (lX1 & 7) {
    lMask = 8 - (lX1 & 7);
    if (lMask > (lX2 - lX1 + 1)) {
      lMask = lX2 - lX1 + 1;
    }
    lMask = ((1 << lMask) - 1) << (8 - (lX1 & 7) - lMask);
    *pucData = (*pucData & ~lMask) | (ulValue & lMask);
    pucData++;
    lX1 = (lX1 + 7) & ~7;
  }
  if (((unsigned int)pucData & 1) && ((lX2 - lX1) > 6)) {
    *pucData++ = ulValue & 0xff;
    lX1 += 8;
  }
  if (((unsigned int)pucData & 2) && ((lX2 - lX1) > 14)) {
    *(unsigned short *)pucData = ulValue & 0xffff;
    pucData += 2;
    lX1 += 16;
  }
  while ((lX1 + 31) <= lX2) {
    *(unsigned int *)pucData = ulValue;
    pucData += 4;
    lX1 += 32;
  }
  if ((lX1 + 15) <= lX2) {
    *(unsigned short *)pucData = ulValue & 0xffff;
    pucData += 2;
    lX1 += 16;
  }
  if ((lX1 + 7) <= lX2) {
    *pucData++ = ulValue & 0xff;
    lX1 += 8;
  }
  if (lX1 <= lX2) {
    lMask = 0xff >> (lX2 - lX1 + 1);
    *pucData = (*pucData & lMask) | (ulValue & ~lMask);
  }
}


x86 assembly (clang, -O0):
<GrOffScreen1BPPLineDrawH>:
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,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movzwl 0x1(%rax),%eax
add    $0x7,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0xc(%rbp),%eax
mov    $0x8,%esi
cltd
idiv   %esi
add    %eax,%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
cmpl   $0x0,-0x18(%rbp)
je     1169 <GrOffScreen1BPPLineDrawH+0x69>
movl   $0xffffffff,-0x18(%rbp)
mov    -0xc(%rbp),%eax
and    $0x7,%eax
cmp    $0x0,%eax
je     1201 <GrOffScreen1BPPLineDrawH+0x101>
mov    -0xc(%rbp),%ecx
and    $0x7,%ecx
mov    $0x8,%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    -0xc(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jle    11a8 <GrOffScreen1BPPLineDrawH+0xa8>
mov    -0x10(%rbp),%eax
sub    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
sub    $0x1,%eax
mov    -0xc(%rbp),%edx
and    $0x7,%edx
mov    $0x8,%ecx
sub    %edx,%ecx
sub    -0x20(%rbp),%ecx
shl    %cl,%eax
mov    %eax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
mov    -0x20(%rbp),%ecx
xor    $0xffffffff,%ecx
and    %ecx,%eax
mov    -0x18(%rbp),%ecx
and    -0x20(%rbp),%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,(%rax)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0xc(%rbp),%eax
add    $0x7,%eax
and    $0xfffffff8,%eax
mov    %eax,-0xc(%rbp)
mov    -0x28(%rbp),%rax
and    $0x1,%eax
cmp    $0x0,%eax
je     1244 <GrOffScreen1BPPLineDrawH+0x144>
mov    -0x10(%rbp),%eax
sub    -0xc(%rbp),%eax
cmp    $0x6,%eax
jle    1244 <GrOffScreen1BPPLineDrawH+0x144>
mov    -0x18(%rbp),%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0xc(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0xc(%rbp)
mov    -0x28(%rbp),%rax
and    $0x2,%eax
cmp    $0x0,%eax
je     128a <GrOffScreen1BPPLineDrawH+0x18a>
mov    -0x10(%rbp),%eax
sub    -0xc(%rbp),%eax
cmp    $0xe,%eax
jle    128a <GrOffScreen1BPPLineDrawH+0x18a>
mov    -0x18(%rbp),%eax
and    $0xffff,%eax
mov    %ax,%cx
mov    -0x28(%rbp),%rax
mov    %cx,(%rax)
mov    -0x28(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x28(%rbp)
mov    -0xc(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0xc(%rbp)
jmp    128f <GrOffScreen1BPPLineDrawH+0x18f>
mov    -0xc(%rbp),%eax
add    $0x1f,%eax
cmp    -0x10(%rbp),%eax
jg     12c1 <GrOffScreen1BPPLineDrawH+0x1c1>
mov    -0x18(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
mov    -0xc(%rbp),%eax
add    $0x20,%eax
mov    %eax,-0xc(%rbp)
jmp    128f <GrOffScreen1BPPLineDrawH+0x18f>
mov    -0xc(%rbp),%eax
add    $0xf,%eax
cmp    -0x10(%rbp),%eax
jg     12f7 <GrOffScreen1BPPLineDrawH+0x1f7>
mov    -0x18(%rbp),%eax
and    $0xffff,%eax
mov    %ax,%cx
mov    -0x28(%rbp),%rax
mov    %cx,(%rax)
mov    -0x28(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x28(%rbp)
mov    -0xc(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
add    $0x7,%eax
cmp    -0x10(%rbp),%eax
jg     132a <GrOffScreen1BPPLineDrawH+0x22a>
mov    -0x18(%rbp),%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0xc(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1368 <GrOffScreen1BPPLineDrawH+0x268>
mov    -0x10(%rbp),%ecx
sub    -0xc(%rbp),%ecx
add    $0x1,%ecx
mov    $0xff,%eax
sar    %cl,%eax
mov    %eax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
and    -0x20(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    $0xffffffff,%edx
and    %edx,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<GrOffScreen1BPPLineDrawH>:
push   %rbp
push   %rbx
mov    %edx,%r9d
movzwl 0x1(%rdi),%eax
add    $0x7,%eax
shr    $0x3,%eax
imul   %ecx,%eax
lea    0x7(%rsi),%r10d
test   %esi,%esi
mov    %esi,%ecx
cmovs  %r10d,%ecx
sar    $0x3,%ecx
add    %ecx,%eax
add    $0x5,%eax
movslq %eax,%rdx
add    %rdi,%rdx
mov    %r8d,%eax
neg    %eax
sbb    %ebp,%ebp
mov    %esi,%ecx
and    $0x7,%ecx
je     1175 <GrOffScreen1BPPLineDrawH+0x75>
mov    $0x8,%eax
sub    %ecx,%eax
mov    %r9d,%ecx
sub    %esi,%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
cmovle %eax,%ecx
mov    $0xffffffff,%esi
shl    %cl,%esi
not    %esi
sub    %ecx,%eax
mov    %eax,%ecx
shl    %cl,%esi
movzbl (%rdx),%eax
mov    %ebp,%ecx
xor    %eax,%ecx
and    %esi,%ecx
xor    %eax,%ecx
mov    %cl,(%rdx)
add    $0x1,%rdx
and    $0xfffffff8,%r10d
mov    %r10d,%esi
mov    %r9d,%eax
sub    %esi,%eax
test   $0x1,%dl
je     1199 <GrOffScreen1BPPLineDrawH+0x99>
cmp    $0x7,%eax
jl     1199 <GrOffScreen1BPPLineDrawH+0x99>
mov    %r8d,%eax
neg    %eax
sbb    %eax,%eax
mov    %al,(%rdx)
add    $0x1,%rdx
add    $0x8,%esi
mov    %r9d,%eax
sub    %esi,%eax
test   $0x2,%dl
je     11b4 <GrOffScreen1BPPLineDrawH+0xb4>
cmp    $0xf,%eax
jl     11b4 <GrOffScreen1BPPLineDrawH+0xb4>
mov    %r8d,%eax
neg    %eax
sbb    %eax,%eax
mov    %ax,(%rdx)
add    $0x2,%rdx
add    $0x10,%esi
lea    0x1f(%rsi),%eax
cmp    %r9d,%eax
jg     12b3 <GrOffScreen1BPPLineDrawH+0x1b3>
lea    0x3f(%rsi),%ecx
lea    0x1(%r9),%eax
cmp    %eax,%ecx
cmovg  %ecx,%eax
sub    %esi,%eax
add    $0xffffffe0,%eax
cmp    $0xe0,%eax
jb     1290 <GrOffScreen1BPPLineDrawH+0x190>
shr    $0x5,%eax
add    $0x1,%eax
mov    %eax,%r11d
and    $0xfffffff8,%r11d
mov    %r11d,%r10d
movd   %ebp,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%r11),%rdi
mov    %rdi,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
mov    %ebx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rdi
jae    1213 <GrOffScreen1BPPLineDrawH+0x113>
xor    %edi,%edi
jmp    1259 <GrOffScreen1BPPLineDrawH+0x159>
and    $0xfffffffffffffffc,%rbx
xor    %edi,%edi
nopl   0x0(%rax)
movdqu %xmm0,(%rdx,%rdi,4)
movdqu %xmm0,0x10(%rdx,%rdi,4)
movdqu %xmm0,0x20(%rdx,%rdi,4)
movdqu %xmm0,0x30(%rdx,%rdi,4)
movdqu %xmm0,0x40(%rdx,%rdi,4)
movdqu %xmm0,0x50(%rdx,%rdi,4)
movdqu %xmm0,0x60(%rdx,%rdi,4)
movdqu %xmm0,0x70(%rdx,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rbx
jne    1220 <GrOffScreen1BPPLineDrawH+0x120>
shl    $0x5,%r10d
test   %rcx,%rcx
je     1284 <GrOffScreen1BPPLineDrawH+0x184>
lea    (%rdx,%rdi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rcx
xor    %ebx,%ebx
movdqu %xmm0,-0x10(%rdi,%rbx,1)
movdqu %xmm0,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rcx
jne    1270 <GrOffScreen1BPPLineDrawH+0x170>
lea    (%rdx,%r11,4),%rdx
add    %r10d,%esi
cmp    %rax,%r11
je     12b3 <GrOffScreen1BPPLineDrawH+0x1b3>
mov    %esi,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ebp,(%rdx)
add    $0x4,%rdx
lea    0x20(%rax),%esi
add    $0x3f,%eax
cmp    %r9d,%eax
mov    %esi,%eax
jle    12a0 <GrOffScreen1BPPLineDrawH+0x1a0>
lea    0xf(%rsi),%eax
cmp    %r9d,%eax
jg     12cc <GrOffScreen1BPPLineDrawH+0x1cc>
mov    %r8d,%eax
neg    %eax
sbb    %eax,%eax
mov    %ax,(%rdx)
add    $0x2,%rdx
add    $0x10,%esi
lea    0x7(%rsi),%eax
cmp    %r9d,%eax
jg     12e2 <GrOffScreen1BPPLineDrawH+0x1e2>
neg    %r8d
sbb    %eax,%eax
mov    %al,(%rdx)
add    $0x1,%rdx
add    $0x8,%esi
cmp    %r9d,%esi
jg     130b <GrOffScreen1BPPLineDrawH+0x20b>
sub    %esi,%r9d
add    $0x1,%r9b
mov    $0xff,%eax
mov    %r9d,%ecx
shr    %cl,%eax
movzbl (%rdx),%esi
mov    $0xffffff00,%edi
sar    %cl,%edi
and    %eax,%esi
and    %ebp,%edi
or     %esi,%edi
mov    %dil,(%rdx)
pop    %rbx
pop    %rbp
ret

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

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