void __imlib_AddBlendShapedSpanToRGB(unsigned char *src, unsigned int color,
                                     unsigned int *dst, int len) {
  if (((unsigned char *)(&color))[3] < 255) {
    while (len--) {
      unsigned int tmp;
      unsigned char a;
      switch (*src) {
      case 0:
        break;
      case 255: {
        tmp =
            (((unsigned char *)(&color))[2]) * (((unsigned char *)(&color))[3]);
        tmp = (((unsigned char *)(dst))[2]) + ((tmp + (tmp >> 8) + 0x80) >> 8);
        ((unsigned char *)(dst))[2] = (tmp | (-(tmp >> 8)));
        ;
        tmp =
            (((unsigned char *)(&color))[1]) * (((unsigned char *)(&color))[3]);
        tmp = (((unsigned char *)(dst))[1]) + ((tmp + (tmp >> 8) + 0x80) >> 8);
        ((unsigned char *)(dst))[1] = (tmp | (-(tmp >> 8)));
        ;
        tmp =
            (((unsigned char *)(&color))[0]) * (((unsigned char *)(&color))[3]);
        tmp = (((unsigned char *)(dst))[0]) + ((tmp + (tmp >> 8) + 0x80) >> 8);
        ((unsigned char *)(dst))[0] = (tmp | (-(tmp >> 8)));
        ;
        ;
        break;
      }
      default: {
        do {
          tmp = ((*src) * (((unsigned char *)(&color))[3])) + 0x80;
          a = (tmp + (tmp >> 8)) >> 8;
        } while (0);
        tmp = (((unsigned char *)(&color))[2]) * (a);
        tmp = (((unsigned char *)(dst))[2]) + ((tmp + (tmp >> 8) + 0x80) >> 8);
        ((unsigned char *)(dst))[2] = (tmp | (-(tmp >> 8)));
        ;
        tmp = (((unsigned char *)(&color))[1]) * (a);
        tmp = (((unsigned char *)(dst))[1]) + ((tmp + (tmp >> 8) + 0x80) >> 8);
        ((unsigned char *)(dst))[1] = (tmp | (-(tmp >> 8)));
        ;
        tmp = (((unsigned char *)(&color))[0]) * (a);
        tmp = (((unsigned char *)(dst))[0]) + ((tmp + (tmp >> 8) + 0x80) >> 8);
        ((unsigned char *)(dst))[0] = (tmp | (-(tmp >> 8)));
        ;
        ;
        break;
      }
      }
      src++;
      dst++;
    }
    return;
  }
  while (len--) {
    unsigned int tmp;
    switch (*src) {
    case 0:
      break;
    case 255: {
      do {
        tmp = (((unsigned char *)(dst))[2]) + (((unsigned char *)(&color))[2]);
        ((unsigned char *)(dst))[2] = (tmp | (-(tmp >> 8)));
        ;
        tmp = (((unsigned char *)(dst))[1]) + (((unsigned char *)(&color))[1]);
        ((unsigned char *)(dst))[1] = (tmp | (-(tmp >> 8)));
        ;
        tmp = (((unsigned char *)(dst))[0]) + (((unsigned char *)(&color))[0]);
        ((unsigned char *)(dst))[0] = (tmp | (-(tmp >> 8)));
        ;
      } while (0);
      break;
    }
    default: {
      tmp = (((unsigned char *)(&color))[2]) * (*src);
      tmp = (((unsigned char *)(dst))[2]) + ((tmp + (tmp >> 8) + 0x80) >> 8);
      ((unsigned char *)(dst))[2] = (tmp | (-(tmp >> 8)));
      ;
      tmp = (((unsigned char *)(&color))[1]) * (*src);
      tmp = (((unsigned char *)(dst))[1]) + ((tmp + (tmp >> 8) + 0x80) >> 8);
      ((unsigned char *)(dst))[1] = (tmp | (-(tmp >> 8)));
      ;
      tmp = (((unsigned char *)(&color))[0]) * (*src);
      tmp = (((unsigned char *)(dst))[0]) + ((tmp + (tmp >> 8) + 0x80) >> 8);
      ((unsigned char *)(dst))[0] = (tmp | (-(tmp >> 8)));
      ;
      ;
      break;
    }
    }
    src++;
    dst++;
  }
}


x86 assembly (clang, -O0):
<__imlib_AddBlendShapedSpanToRGB>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movzbl -0x9(%rbp),%eax
cmp    $0xff,%eax
jge    1362 <__imlib_AddBlendShapedSpanToRGB+0x262>
jmp    1126 <__imlib_AddBlendShapedSpanToRGB+0x26>
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x1c(%rbp)
cmp    $0x0,%eax
je     135d <__imlib_AddBlendShapedSpanToRGB+0x25d>
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x2c(%rbp)
test   %eax,%eax
je     1164 <__imlib_AddBlendShapedSpanToRGB+0x64>
jmp    1151 <__imlib_AddBlendShapedSpanToRGB+0x51>
mov    -0x2c(%rbp),%eax
sub    $0xff,%eax
je     1169 <__imlib_AddBlendShapedSpanToRGB+0x69>
jmp    1241 <__imlib_AddBlendShapedSpanToRGB+0x141>
jmp    1340 <__imlib_AddBlendShapedSpanToRGB+0x240>
movzbl -0xa(%rbp),%eax
movzbl -0x9(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x2(%rax),%eax
mov    -0x20(%rbp),%ecx
mov    -0x20(%rbp),%edx
shr    $0x8,%edx
add    %edx,%ecx
add    $0x80,%ecx
shr    $0x8,%ecx
add    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x20(%rbp),%edx
shr    $0x8,%edx
xor    %ecx,%ecx
sub    %edx,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x2(%rax)
movzbl -0xb(%rbp),%eax
movzbl -0x9(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    -0x20(%rbp),%ecx
mov    -0x20(%rbp),%edx
shr    $0x8,%edx
add    %edx,%ecx
add    $0x80,%ecx
shr    $0x8,%ecx
add    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x20(%rbp),%edx
shr    $0x8,%edx
xor    %ecx,%ecx
sub    %edx,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x1(%rax)
movzbl -0xc(%rbp),%eax
movzbl -0x9(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
movzbl (%rax),%eax
mov    -0x20(%rbp),%ecx
mov    -0x20(%rbp),%edx
shr    $0x8,%edx
add    %edx,%ecx
add    $0x80,%ecx
shr    $0x8,%ecx
add    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x20(%rbp),%edx
shr    $0x8,%edx
xor    %ecx,%ecx
sub    %edx,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
jmp    1340 <__imlib_AddBlendShapedSpanToRGB+0x240>
jmp    1246 <__imlib_AddBlendShapedSpanToRGB+0x146>
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
movzbl -0x9(%rbp),%ecx
imul   %ecx,%eax
add    $0x80,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x20(%rbp),%ecx
shr    $0x8,%ecx
add    %ecx,%eax
shr    $0x8,%eax
mov    %al,-0x21(%rbp)
movzbl -0xa(%rbp),%eax
movzbl -0x21(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x2(%rax),%eax
mov    -0x20(%rbp),%ecx
mov    -0x20(%rbp),%edx
shr    $0x8,%edx
add    %edx,%ecx
add    $0x80,%ecx
shr    $0x8,%ecx
add    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x20(%rbp),%edx
shr    $0x8,%edx
xor    %ecx,%ecx
sub    %edx,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x2(%rax)
movzbl -0xb(%rbp),%eax
movzbl -0x21(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    -0x20(%rbp),%ecx
mov    -0x20(%rbp),%edx
shr    $0x8,%edx
add    %edx,%ecx
add    $0x80,%ecx
shr    $0x8,%ecx
add    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x20(%rbp),%edx
shr    $0x8,%edx
xor    %ecx,%ecx
sub    %edx,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x1(%rax)
movzbl -0xc(%rbp),%eax
movzbl -0x21(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
movzbl (%rax),%eax
mov    -0x20(%rbp),%ecx
mov    -0x20(%rbp),%edx
shr    $0x8,%edx
add    %edx,%ecx
add    $0x80,%ecx
shr    $0x8,%ecx
add    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x20(%rbp),%edx
shr    $0x8,%edx
xor    %ecx,%ecx
sub    %edx,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
mov    -0x18(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x18(%rbp)
jmp    1126 <__imlib_AddBlendShapedSpanToRGB+0x26>
jmp    1526 <__imlib_AddBlendShapedSpanToRGB+0x426>
jmp    1367 <__imlib_AddBlendShapedSpanToRGB+0x267>
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x1c(%rbp)
cmp    $0x0,%eax
je     1526 <__imlib_AddBlendShapedSpanToRGB+0x426>
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x30(%rbp)
test   %eax,%eax
je     13a5 <__imlib_AddBlendShapedSpanToRGB+0x2a5>
jmp    1392 <__imlib_AddBlendShapedSpanToRGB+0x292>
mov    -0x30(%rbp),%eax
sub    $0xff,%eax
je     13aa <__imlib_AddBlendShapedSpanToRGB+0x2aa>
jmp    142d <__imlib_AddBlendShapedSpanToRGB+0x32d>
jmp    1509 <__imlib_AddBlendShapedSpanToRGB+0x409>
jmp    13af <__imlib_AddBlendShapedSpanToRGB+0x2af>
mov    -0x18(%rbp),%rax
movzbl 0x2(%rax),%eax
movzbl -0xa(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x28(%rbp),%edx
shr    $0x8,%edx
xor    %ecx,%ecx
sub    %edx,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x18(%rbp),%rax
movzbl 0x1(%rax),%eax
movzbl -0xb(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x28(%rbp),%edx
shr    $0x8,%edx
xor    %ecx,%ecx
sub    %edx,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x18(%rbp),%rax
movzbl (%rax),%eax
movzbl -0xc(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x28(%rbp),%edx
shr    $0x8,%edx
xor    %ecx,%ecx
sub    %edx,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
jmp    1509 <__imlib_AddBlendShapedSpanToRGB+0x409>
movzbl -0xa(%rbp),%eax
mov    -0x8(%rbp),%rcx
movzbl (%rcx),%ecx
imul   %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x2(%rax),%eax
mov    -0x28(%rbp),%ecx
mov    -0x28(%rbp),%edx
shr    $0x8,%edx
add    %edx,%ecx
add    $0x80,%ecx
shr    $0x8,%ecx
add    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x28(%rbp),%edx
shr    $0x8,%edx
xor    %ecx,%ecx
sub    %edx,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x2(%rax)
movzbl -0xb(%rbp),%eax
mov    -0x8(%rbp),%rcx
movzbl (%rcx),%ecx
imul   %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    -0x28(%rbp),%ecx
mov    -0x28(%rbp),%edx
shr    $0x8,%edx
add    %edx,%ecx
add    $0x80,%ecx
shr    $0x8,%ecx
add    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x28(%rbp),%edx
shr    $0x8,%edx
xor    %ecx,%ecx
sub    %edx,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x1(%rax)
movzbl -0xc(%rbp),%eax
mov    -0x8(%rbp),%rcx
movzbl (%rcx),%ecx
imul   %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl (%rax),%eax
mov    -0x28(%rbp),%ecx
mov    -0x28(%rbp),%edx
shr    $0x8,%edx
add    %edx,%ecx
add    $0x80,%ecx
shr    $0x8,%ecx
add    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x28(%rbp),%edx
shr    $0x8,%edx
xor    %ecx,%ecx
sub    %edx,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
mov    -0x18(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x18(%rbp)
jmp    1367 <__imlib_AddBlendShapedSpanToRGB+0x267>
pop    %rbp
ret

x86 assembly (clang, -O2):
<__imlib_AddBlendShapedSpanToRGB>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %esi,%ebp
shr    $0x8,%ebp
mov    %esi,%ebx
shr    $0x10,%ebx
mov    %esi,%r15d
shr    $0x18,%r15d
cmp    $0xff,%r15d
jne    121f <__imlib_AddBlendShapedSpanToRGB+0x11f>
test   %ecx,%ecx
je     136f <__imlib_AddBlendShapedSpanToRGB+0x26f>
movzbl %bl,%r8d
movzbl %bpl,%r9d
movzbl %sil,%r10d
mov    %ecx,%ecx
xor    %ebx,%ebx
jmp    11da <__imlib_AddBlendShapedSpanToRGB+0xda>
cs nopw 0x0(%rax,%rax,1)
nop
imul   %r8d,%esi
movzbl 0x2(%rdx,%rbx,4),%ebp
mov    %esi,%eax
shr    $0x8,%eax
add    %esi,%eax
add    $0x80,%eax
shr    $0x8,%eax
add    %ebp,%eax
mov    %eax,%esi
shr    $0x8,%esi
neg    %esi
or     %eax,%esi
mov    %sil,0x2(%rdx,%rbx,4)
movzbl (%rdi,%rbx,1),%ebp
imul   %r9d,%ebp
movzbl 0x1(%rdx,%rbx,4),%esi
mov    %ebp,%eax
shr    $0x8,%eax
add    %ebp,%eax
add    $0x80,%eax
shr    $0x8,%eax
add    %esi,%eax
mov    %eax,%esi
shr    $0x8,%esi
neg    %esi
or     %eax,%esi
mov    %sil,0x1(%rdx,%rbx,4)
movzbl (%rdi,%rbx,1),%ebp
imul   %r10d,%ebp
movzbl (%rdx,%rbx,4),%esi
mov    %ebp,%eax
shr    $0x8,%eax
add    %ebp,%eax
add    $0x80,%eax
shr    $0x8,%eax
add    %esi,%eax
mov    %eax,%esi
shr    $0x8,%esi
neg    %esi
or     %eax,%esi
mov    %sil,(%rdx,%rbx,4)
add    $0x1,%rbx
cmp    %ebx,%ecx
je     136f <__imlib_AddBlendShapedSpanToRGB+0x26f>
movzbl (%rdi,%rbx,1),%esi
test   %esi,%esi
je     11ce <__imlib_AddBlendShapedSpanToRGB+0xce>
cmp    $0xff,%sil
jne    1150 <__imlib_AddBlendShapedSpanToRGB+0x50>
movzbl 0x2(%rdx,%rbx,4),%ebp
add    %r8d,%ebp
mov    %ebp,%eax
shr    $0x8,%eax
neg    %eax
or     %ebp,%eax
mov    %al,0x2(%rdx,%rbx,4)
movzbl 0x1(%rdx,%rbx,4),%ebp
add    %r9d,%ebp
mov    %ebp,%eax
shr    $0x8,%eax
neg    %eax
or     %ebp,%eax
mov    %al,0x1(%rdx,%rbx,4)
movzbl (%rdx,%rbx,4),%eax
add    %r10d,%eax
jmp    11c1 <__imlib_AddBlendShapedSpanToRGB+0xc1>
test   %ecx,%ecx
je     136f <__imlib_AddBlendShapedSpanToRGB+0x26f>
movzbl %bl,%r8d
mov    %r8d,%eax
imul   %r15d,%eax
mov    %eax,%ebx
shr    $0x8,%ebx
lea    (%rax,%rbx,1),%r9d
add    $0x80,%r9d
shr    $0x8,%r9d
movzbl %bpl,%r10d
mov    %r10d,%ebp
imul   %r15d,%ebp
mov    %ebp,%eax
shr    $0x8,%eax
lea    (%rax,%rbp,1),%r11d
add    $0x80,%r11d
shr    $0x8,%r11d
movzbl %sil,%r14d
mov    %r14d,%eax
imul   %r15d,%eax
mov    %eax,%esi
shr    $0x8,%esi
lea    (%rax,%rsi,1),%r12d
add    $0x80,%r12d
shr    $0x8,%r12d
mov    %ecx,%r13d
xor    %esi,%esi
jmp    1328 <__imlib_AddBlendShapedSpanToRGB+0x228>
xchg   %ax,%ax
imul   %r15d,%ebp
lea    0x80(%rbp),%eax
shr    $0x8,%eax
add    %ebp,%eax
add    $0x80,%eax
movzbl %ah,%ebp
mov    %ebp,%ecx
imul   %r8d,%ecx
movzbl 0x2(%rdx,%rsi,4),%ebx
mov    %ecx,%eax
shr    $0x8,%eax
add    %ecx,%eax
add    $0x80,%eax
shr    $0x8,%eax
add    %ebx,%eax
mov    %eax,%ecx
shr    $0x8,%ecx
neg    %ecx
or     %eax,%ecx
mov    %cl,0x2(%rdx,%rsi,4)
mov    %ebp,%eax
imul   %r10d,%eax
movzbl 0x1(%rdx,%rsi,4),%ecx
mov    %eax,%ebx
shr    $0x8,%ebx
add    %ebx,%eax
add    $0x80,%eax
shr    $0x8,%eax
add    %ecx,%eax
mov    %eax,%ecx
shr    $0x8,%ecx
neg    %ecx
or     %eax,%ecx
mov    %cl,0x1(%rdx,%rsi,4)
imul   %r14d,%ebp
movzbl (%rdx,%rsi,4),%eax
mov    %ebp,%ecx
shr    $0x8,%ecx
add    %ecx,%ebp
add    $0x80,%ebp
shr    $0x8,%ebp
add    %eax,%ebp
mov    %ebp,%eax
shr    $0x8,%eax
neg    %eax
or     %ebp,%eax
mov    %al,(%rdx,%rsi,4)
add    $0x1,%rsi
cmp    %esi,%r13d
je     136f <__imlib_AddBlendShapedSpanToRGB+0x26f>
movzbl (%rdi,%rsi,1),%ebp
test   %ebp,%ebp
je     131f <__imlib_AddBlendShapedSpanToRGB+0x21f>
cmp    $0xff,%bpl
jne    1290 <__imlib_AddBlendShapedSpanToRGB+0x190>
movzbl 0x2(%rdx,%rsi,4),%eax
add    %r9d,%eax
mov    %eax,%ebp
shr    $0x8,%ebp
neg    %ebp
or     %eax,%ebp
mov    %bpl,0x2(%rdx,%rsi,4)
movzbl 0x1(%rdx,%rsi,4),%eax
add    %r11d,%eax
mov    %eax,%ebp
shr    $0x8,%ebp
neg    %ebp
or     %eax,%ebp
mov    %bpl,0x1(%rdx,%rsi,4)
movzbl (%rdx,%rsi,4),%ebp
add    %r12d,%ebp
jmp    1313 <__imlib_AddBlendShapedSpanToRGB+0x213>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @__imlib_AddBlendShapedSpanToRGB(i8* %0, i32 %1, i32* %2, i32 %3) {
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i32*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i8
%11 = alloca i32
store i8* %0, i8** %5
store i32 %1, i32* %6
store i32* %2, i32** %7
store i32 %3, i32* %8
%12 = bitcast i32* %6 to i8*
%13 = getelementptr inbounds i8, i8* %12, i64 3
%14 = load i8, i8* %13
%15 = zext i8 %14 to i32
%16 = icmp slt i32 %15, 255
br i1 %16, label %17, label %226
17: ; preds = %4
br label %18
18: ; preds = %220, %17
%19 = load i32, i32* %8
%20 = add nsw i32 %19, -1
store i32 %20, i32* %8
%21 = icmp ne i32 %19, 0
br i1 %21, label %22, label %225
22: ; preds = %18
%23 = load i8*, i8** %5
%24 = load i8, i8* %23
%25 = zext i8 %24 to i32
switch i32 %25, label %118 [
i32 0, label %26
i32 255, label %27
]
26: ; preds = %22
br label %220
27: ; preds = %22
%28 = bitcast i32* %6 to i8*
%29 = getelementptr inbounds i8, i8* %28, i64 2
%30 = load i8, i8* %29
%31 = zext i8 %30 to i32
%32 = bitcast i32* %6 to i8*
%33 = getelementptr inbounds i8, i8* %32, i64 3
%34 = load i8, i8* %33
%35 = zext i8 %34 to i32
%36 = mul nsw i32 %31, %35
store i32 %36, i32* %9
%37 = load i32*, i32** %7
%38 = bitcast i32* %37 to i8*
%39 = getelementptr inbounds i8, i8* %38, i64 2
%40 = load i8, i8* %39
%41 = zext i8 %40 to i32
%42 = load i32, i32* %9
%43 = load i32, i32* %9
%44 = lshr i32 %43, 8
%45 = add i32 %42, %44
%46 = add i32 %45, 128
%47 = lshr i32 %46, 8
%48 = add i32 %41, %47
store i32 %48, i32* %9
%49 = load i32, i32* %9
%50 = load i32, i32* %9
%51 = lshr i32 %50, 8
%52 = sub i32 0, %51
%53 = or i32 %49, %52
%54 = trunc i32 %53 to i8
%55 = load i32*, i32** %7
%56 = bitcast i32* %55 to i8*
%57 = getelementptr inbounds i8, i8* %56, i64 2
store i8 %54, i8* %57
%58 = bitcast i32* %6 to i8*
%59 = getelementptr inbounds i8, i8* %58, i64 1
%60 = load i8, i8* %59
%61 = zext i8 %60 to i32
%62 = bitcast i32* %6 to i8*
%63 = getelementptr inbounds i8, i8* %62, i64 3
%64 = load i8, i8* %63
%65 = zext i8 %64 to i32
%66 = mul nsw i32 %61, %65
store i32 %66, i32* %9
%67 = load i32*, i32** %7
%68 = bitcast i32* %67 to i8*
%69 = getelementptr inbounds i8, i8* %68, i64 1
%70 = load i8, i8* %69
%71 = zext i8 %70 to i32
%72 = load i32, i32* %9
%73 = load i32, i32* %9
%74 = lshr i32 %73, 8
%75 = add i32 %72, %74
%76 = add i32 %75, 128
%77 = lshr i32 %76, 8
%78 = add i32 %71, %77
store i32 %78, i32* %9
%79 = load i32, i32* %9
%80 = load i32, i32* %9
%81 = lshr i32 %80, 8
%82 = sub i32 0, %81
%83 = or i32 %79, %82
%84 = trunc i32 %83 to i8
%85 = load i32*, i32** %7
%86 = bitcast i32* %85 to i8*
%87 = getelementptr inbounds i8, i8* %86, i64 1
store i8 %84, i8* %87
%88 = bitcast i32* %6 to i8*
%89 = getelementptr inbounds i8, i8* %88, i64 0
%90 = load i8, i8* %89
%91 = zext i8 %90 to i32
%92 = bitcast i32* %6 to i8*
%93 = getelementptr inbounds i8, i8* %92, i64 3
%94 = load i8, i8* %93
%95 = zext i8 %94 to i32
%96 = mul nsw i32 %91, %95
store i32 %96, i32* %9
%97 = load i32*, i32** %7
%98 = bitcast i32* %97 to i8*
%99 = getelementptr inbounds i8, i8* %98, i64 0
%100 = load i8, i8* %99
%101 = zext i8 %100 to i32
%102 = load i32, i32* %9
%103 = load i32, i32* %9
%104 = lshr i32 %103, 8
%105 = add i32 %102, %104
%106 = add i32 %105, 128
%107 = lshr i32 %106, 8
%108 = add i32 %101, %107
store i32 %108, i32* %9
%109 = load i32, i32* %9
%110 = load i32, i32* %9
%111 = lshr i32 %110, 8
%112 = sub i32 0, %111
%113 = or i32 %109, %112
%114 = trunc i32 %113 to i8
%115 = load i32*, i32** %7
%116 = bitcast i32* %115 to i8*
%117 = getelementptr inbounds i8, i8* %116, i64 0
store i8 %114, i8* %117
br label %220
118: ; preds = %22
br label %119
119: ; preds = %118
%120 = load i8*, i8** %5
%121 = load i8, i8* %120
%122 = zext i8 %121 to i32
%123 = bitcast i32* %6 to i8*
%124 = getelementptr inbounds i8, i8* %123, i64 3
%125 = load i8, i8* %124
%126 = zext i8 %125 to i32
%127 = mul nsw i32 %122, %126
%128 = add nsw i32 %127, 128
store i32 %128, i32* %9
%129 = load i32, i32* %9
%130 = load i32, i32* %9
%131 = lshr i32 %130, 8
%132 = add i32 %129, %131
%133 = lshr i32 %132, 8
%134 = trunc i32 %133 to i8
store i8 %134, i8* %10
br label %135
135: ; preds = %119
%136 = bitcast i32* %6 to i8*
%137 = getelementptr inbounds i8, i8* %136, i64 2
%138 = load i8, i8* %137
%139 = zext i8 %138 to i32
%140 = load i8, i8* %10
%141 = zext i8 %140 to i32
%142 = mul nsw i32 %139, %141
store i32 %142, i32* %9
%143 = load i32*, i32** %7
%144 = bitcast i32* %143 to i8*
%145 = getelementptr inbounds i8, i8* %144, i64 2
%146 = load i8, i8* %145
%147 = zext i8 %146 to i32
%148 = load i32, i32* %9
%149 = load i32, i32* %9
%150 = lshr i32 %149, 8
%151 = add i32 %148, %150
%152 = add i32 %151, 128
%153 = lshr i32 %152, 8
%154 = add i32 %147, %153
store i32 %154, i32* %9
%155 = load i32, i32* %9
%156 = load i32, i32* %9
%157 = lshr i32 %156, 8
%158 = sub i32 0, %157
%159 = or i32 %155, %158
%160 = trunc i32 %159 to i8
%161 = load i32*, i32** %7
%162 = bitcast i32* %161 to i8*
%163 = getelementptr inbounds i8, i8* %162, i64 2
store i8 %160, i8* %163
%164 = bitcast i32* %6 to i8*
%165 = getelementptr inbounds i8, i8* %164, i64 1
%166 = load i8, i8* %165
%167 = zext i8 %166 to i32
%168 = load i8, i8* %10
%169 = zext i8 %168 to i32
%170 = mul nsw i32 %167, %169
store i32 %170, i32* %9
%171 = load i32*, i32** %7
%172 = bitcast i32* %171 to i8*
%173 = getelementptr inbounds i8, i8* %172, i64 1
%174 = load i8, i8* %173
%175 = zext i8 %174 to i32
%176 = load i32, i32* %9
%177 = load i32, i32* %9
%178 = lshr i32 %177, 8
%179 = add i32 %176, %178
%180 = add i32 %179, 128
%181 = lshr i32 %180, 8
%182 = add i32 %175, %181
store i32 %182, i32* %9
%183 = load i32, i32* %9
%184 = load i32, i32* %9
%185 = lshr i32 %184, 8
%186 = sub i32 0, %185
%187 = or i32 %183, %186
%188 = trunc i32 %187 to i8
%189 = load i32*, i32** %7
%190 = bitcast i32* %189 to i8*
%191 = getelementptr inbounds i8, i8* %190, i64 1
store i8 %188, i8* %191
%192 = bitcast i32* %6 to i8*
%193 = getelementptr inbounds i8, i8* %192, i64 0
%194 = load i8, i8* %193
%195 = zext i8 %194 to i32
%196 = load i8, i8* %10
%197 = zext i8 %196 to i32
%198 = mul nsw i32 %195, %197
store i32 %198, i32* %9
%199 = load i32*, i32** %7
%200 = bitcast i32* %199 to i8*
%201 = getelementptr inbounds i8, i8* %200, i64 0
%202 = load i8, i8* %201
%203 = zext i8 %202 to i32
%204 = load i32, i32* %9
%205 = load i32, i32* %9
%206 = lshr i32 %205, 8
%207 = add i32 %204, %206
%208 = add i32 %207, 128
%209 = lshr i32 %208, 8
%210 = add i32 %203, %209
store i32 %210, i32* %9
%211 = load i32, i32* %9
%212 = load i32, i32* %9
%213 = lshr i32 %212, 8
%214 = sub i32 0, %213
%215 = or i32 %211, %214
%216 = trunc i32 %215 to i8
%217 = load i32*, i32** %7
%218 = bitcast i32* %217 to i8*
%219 = getelementptr inbounds i8, i8* %218, i64 0
store i8 %216, i8* %219
br label %220
220: ; preds = %135, %27, %26
%221 = load i8*, i8** %5
%222 = getelementptr inbounds i8, i8* %221, i32 1
store i8* %222, i8** %5
%223 = load i32*, i32** %7
%224 = getelementptr inbounds i32, i32* %223, i32 1
store i32* %224, i32** %7
br label %18
225: ; preds = %18
br label %389
226: ; preds = %4
br label %227
227: ; preds = %384, %226
%228 = load i32, i32* %8
%229 = add nsw i32 %228, -1
store i32 %229, i32* %8
%230 = icmp ne i32 %228, 0
br i1 %230, label %231, label %389
231: ; preds = %227
%232 = load i8*, i8** %5
%233 = load i8, i8* %232
%234 = zext i8 %233 to i32
switch i32 %234, label %296 [
i32 0, label %235
i32 255, label %236
]
235: ; preds = %231
br label %384
236: ; preds = %231
br label %237
237: ; preds = %236
%238 = load i32*, i32** %7
%239 = bitcast i32* %238 to i8*
%240 = getelementptr inbounds i8, i8* %239, i64 2
%241 = load i8, i8* %240
%242 = zext i8 %241 to i32
%243 = bitcast i32* %6 to i8*
%244 = getelementptr inbounds i8, i8* %243, i64 2
%245 = load i8, i8* %244
%246 = zext i8 %245 to i32
%247 = add nsw i32 %242, %246
store i32 %247, i32* %11
%248 = load i32, i32* %11
%249 = load i32, i32* %11
%250 = lshr i32 %249, 8
%251 = sub i32 0, %250
%252 = or i32 %248, %251
%253 = trunc i32 %252 to i8
%254 = load i32*, i32** %7
%255 = bitcast i32* %254 to i8*
%256 = getelementptr inbounds i8, i8* %255, i64 2
store i8 %253, i8* %256
%257 = load i32*, i32** %7
%258 = bitcast i32* %257 to i8*
%259 = getelementptr inbounds i8, i8* %258, i64 1
%260 = load i8, i8* %259
%261 = zext i8 %260 to i32
%262 = bitcast i32* %6 to i8*
%263 = getelementptr inbounds i8, i8* %262, i64 1
%264 = load i8, i8* %263
%265 = zext i8 %264 to i32
%266 = add nsw i32 %261, %265
store i32 %266, i32* %11
%267 = load i32, i32* %11
%268 = load i32, i32* %11
%269 = lshr i32 %268, 8
%270 = sub i32 0, %269
%271 = or i32 %267, %270
%272 = trunc i32 %271 to i8
%273 = load i32*, i32** %7
%274 = bitcast i32* %273 to i8*
%275 = getelementptr inbounds i8, i8* %274, i64 1
store i8 %272, i8* %275
%276 = load i32*, i32** %7
%277 = bitcast i32* %276 to i8*
%278 = getelementptr inbounds i8, i8* %277, i64 0
%279 = load i8, i8* %278
%280 = zext i8 %279 to i32
%281 = bitcast i32* %6 to i8*
%282 = getelementptr inbounds i8, i8* %281, i64 0
%283 = load i8, i8* %282
%284 = zext i8 %283 to i32
%285 = add nsw i32 %280, %284
store i32 %285, i32* %11
%286 = load i32, i32* %11
%287 = load i32, i32* %11
%288 = lshr i32 %287, 8
%289 = sub i32 0, %288
%290 = or i32 %286, %289
%291 = trunc i32 %290 to i8
%292 = load i32*, i32** %7
%293 = bitcast i32* %292 to i8*
%294 = getelementptr inbounds i8, i8* %293, i64 0
store i8 %291, i8* %294
br label %295
295: ; preds = %237
br label %384
296: ; preds = %231
%297 = bitcast i32* %6 to i8*
%298 = getelementptr inbounds i8, i8* %297, i64 2
%299 = load i8, i8* %298
%300 = zext i8 %299 to i32
%301 = load i8*, i8** %5
%302 = load i8, i8* %301
%303 = zext i8 %302 to i32
%304 = mul nsw i32 %300, %303
store i32 %304, i32* %11
%305 = load i32*, i32** %7
%306 = bitcast i32* %305 to i8*
%307 = getelementptr inbounds i8, i8* %306, i64 2
%308 = load i8, i8* %307
%309 = zext i8 %308 to i32
%310 = load i32, i32* %11
%311 = load i32, i32* %11
%312 = lshr i32 %311, 8
%313 = add i32 %310, %312
%314 = add i32 %313, 128
%315 = lshr i32 %314, 8
%316 = add i32 %309, %315
store i32 %316, i32* %11
%317 = load i32, i32* %11
%318 = load i32, i32* %11
%319 = lshr i32 %318, 8
%320 = sub i32 0, %319
%321 = or i32 %317, %320
%322 = trunc i32 %321 to i8
%323 = load i32*, i32** %7
%324 = bitcast i32* %323 to i8*
%325 = getelementptr inbounds i8, i8* %324, i64 2
store i8 %322, i8* %325
%326 = bitcast i32* %6 to i8*
%327 = getelementptr inbounds i8, i8* %326, i64 1
%328 = load i8, i8* %327
%329 = zext i8 %328 to i32
%330 = load i8*, i8** %5
%331 = load i8, i8* %330
%332 = zext i8 %331 to i32
%333 = mul nsw i32 %329, %332
store i32 %333, i32* %11
%334 = load i32*, i32** %7
%335 = bitcast i32* %334 to i8*
%336 = getelementptr inbounds i8, i8* %335, i64 1
%337 = load i8, i8* %336
%338 = zext i8 %337 to i32
%339 = load i32, i32* %11
%340 = load i32, i32* %11
%341 = lshr i32 %340, 8
%342 = add i32 %339, %341
%343 = add i32 %342, 128
%344 = lshr i32 %343, 8
%345 = add i32 %338, %344
store i32 %345, i32* %11
%346 = load i32, i32* %11
%347 = load i32, i32* %11
%348 = lshr i32 %347, 8
%349 = sub i32 0, %348
%350 = or i32 %346, %349
%351 = trunc i32 %350 to i8
%352 = load i32*, i32** %7
%353 = bitcast i32* %352 to i8*
%354 = getelementptr inbounds i8, i8* %353, i64 1
store i8 %351, i8* %354
%355 = bitcast i32* %6 to i8*
%356 = getelementptr inbounds i8, i8* %355, i64 0
%357 = load i8, i8* %356
%358 = zext i8 %357 to i32
%359 = load i8*, i8** %5
%360 = load i8, i8* %359
%361 = zext i8 %360 to i32
%362 = mul nsw i32 %358, %361
store i32 %362, i32* %11
%363 = load i32*, i32** %7
%364 = bitcast i32* %363 to i8*
%365 = getelementptr inbounds i8, i8* %364, i64 0
%366 = load i8, i8* %365
%367 = zext i8 %366 to i32
%368 = load i32, i32* %11
%369 = load i32, i32* %11
%370 = lshr i32 %369, 8
%371 = add i32 %368, %370
%372 = add i32 %371, 128
%373 = lshr i32 %372, 8
%374 = add i32 %367, %373
store i32 %374, i32* %11
%375 = load i32, i32* %11
%376 = load i32, i32* %11
%377 = lshr i32 %376, 8
%378 = sub i32 0, %377
%379 = or i32 %375, %378
%380 = trunc i32 %379 to i8
%381 = load i32*, i32** %7
%382 = bitcast i32* %381 to i8*
%383 = getelementptr inbounds i8, i8* %382, i64 0
store i8 %380, i8* %383
br label %384
384: ; preds = %296, %295, %235
%385 = load i8*, i8** %5
%386 = getelementptr inbounds i8, i8* %385, i32 1
store i8* %386, i8** %5
%387 = load i32*, i32** %7
%388 = getelementptr inbounds i32, i32* %387, i32 1
store i32* %388, i32** %7
br label %227
389: ; preds = %225, %227
ret void
}

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