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


x86 assembly (clang, -O0):
<__imlib_BlendShapedSpanToRGB>:
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    1330 <__imlib_BlendShapedSpanToRGB+0x230>
jmp    1126 <__imlib_BlendShapedSpanToRGB+0x26>
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x1c(%rbp)
cmp    $0x0,%eax
je     132b <__imlib_BlendShapedSpanToRGB+0x22b>
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x2c(%rbp)
test   %eax,%eax
je     1164 <__imlib_BlendShapedSpanToRGB+0x64>
jmp    1151 <__imlib_BlendShapedSpanToRGB+0x51>
mov    -0x2c(%rbp),%eax
sub    $0xff,%eax
je     1169 <__imlib_BlendShapedSpanToRGB+0x69>
jmp    1228 <__imlib_BlendShapedSpanToRGB+0x128>
jmp    130e <__imlib_BlendShapedSpanToRGB+0x20e>
movzbl -0xa(%rbp),%eax
mov    -0x18(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
sub    %ecx,%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    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x2(%rax)
movzbl -0xb(%rbp),%eax
mov    -0x18(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
sub    %ecx,%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    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x1(%rax)
movzbl -0xc(%rbp),%eax
mov    -0x18(%rbp),%rcx
movzbl (%rcx),%ecx
sub    %ecx,%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    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
jmp    130e <__imlib_BlendShapedSpanToRGB+0x20e>
jmp    122d <__imlib_BlendShapedSpanToRGB+0x12d>
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
mov    -0x18(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
sub    %ecx,%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    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x2(%rax)
movzbl -0xb(%rbp),%eax
mov    -0x18(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
sub    %ecx,%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    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x1(%rax)
movzbl -0xc(%rbp),%eax
mov    -0x18(%rbp),%rcx
movzbl (%rcx),%ecx
sub    %ecx,%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    %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_BlendShapedSpanToRGB+0x26>
jmp    1479 <__imlib_BlendShapedSpanToRGB+0x379>
jmp    1335 <__imlib_BlendShapedSpanToRGB+0x235>
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x1c(%rbp)
cmp    $0x0,%eax
je     1479 <__imlib_BlendShapedSpanToRGB+0x379>
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x30(%rbp)
test   %eax,%eax
je     1373 <__imlib_BlendShapedSpanToRGB+0x273>
jmp    1360 <__imlib_BlendShapedSpanToRGB+0x260>
mov    -0x30(%rbp),%eax
sub    $0xff,%eax
je     1378 <__imlib_BlendShapedSpanToRGB+0x278>
jmp    1399 <__imlib_BlendShapedSpanToRGB+0x299>
jmp    145c <__imlib_BlendShapedSpanToRGB+0x35c>
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
and    $0xff000000,%ecx
mov    -0xc(%rbp),%eax
and    $0xffffff,%eax
or     %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
jmp    145c <__imlib_BlendShapedSpanToRGB+0x35c>
movzbl -0xa(%rbp),%eax
mov    -0x18(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
sub    %ecx,%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    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x2(%rax)
movzbl -0xb(%rbp),%eax
mov    -0x18(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
sub    %ecx,%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    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x1(%rax)
movzbl -0xc(%rbp),%eax
mov    -0x18(%rbp),%rcx
movzbl (%rcx),%ecx
sub    %ecx,%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    %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    1335 <__imlib_BlendShapedSpanToRGB+0x235>
pop    %rbp
ret

x86 assembly (clang, -O2):
<__imlib_BlendShapedSpanToRGB>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %ecx,%r12d
mov    %esi,%ebp
shr    $0x8,%ebp
mov    %esi,%ebx
shr    $0x10,%ebx
mov    %esi,%r11d
shr    $0x18,%r11d
cmp    $0xff,%r11d
jne    11fd <__imlib_BlendShapedSpanToRGB+0xfd>
test   %r12d,%r12d
je     12dd <__imlib_BlendShapedSpanToRGB+0x1dd>
mov    %esi,%r11d
and    $0xffffff,%r11d
movzbl %bl,%r8d
movzbl %bpl,%r9d
movzbl %sil,%r10d
mov    %r12d,%r14d
xor    %esi,%esi
jmp    11db <__imlib_BlendShapedSpanToRGB+0xdb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl 0x2(%rdx,%rsi,4),%ebx
mov    %r8d,%ecx
sub    %ebx,%ecx
imul   %ebp,%ecx
mov    %ecx,%eax
shr    $0x8,%eax
add    %ecx,%eax
add    $0x80,%eax
shr    $0x8,%eax
add    %bl,%al
mov    %al,0x2(%rdx,%rsi,4)
movzbl 0x1(%rdx,%rsi,4),%eax
mov    %r9d,%ecx
sub    %eax,%ecx
movzbl (%rdi,%rsi,1),%ebx
imul   %ecx,%ebx
mov    %ebx,%ecx
shr    $0x8,%ecx
add    %ebx,%ecx
add    $0x80,%ecx
shr    $0x8,%ecx
add    %al,%cl
mov    %cl,0x1(%rdx,%rsi,4)
movzbl (%rdx,%rsi,4),%eax
mov    %r10d,%ecx
sub    %eax,%ecx
movzbl (%rdi,%rsi,1),%ebx
imul   %ecx,%ebx
mov    %ebx,%ecx
shr    $0x8,%ecx
add    %ebx,%ecx
add    $0x80,%ecx
shr    $0x8,%ecx
add    %al,%cl
mov    %cl,(%rdx,%rsi,4)
add    $0x1,%rsi
cmp    %esi,%r14d
je     12dd <__imlib_BlendShapedSpanToRGB+0x1dd>
movzbl (%rdi,%rsi,1),%ebp
test   %ebp,%ebp
je     11ce <__imlib_BlendShapedSpanToRGB+0xce>
cmp    $0xff,%bpl
jne    1160 <__imlib_BlendShapedSpanToRGB+0x60>
movzbl 0x3(%rdx,%rsi,4),%ebp
shl    $0x18,%ebp
or     %r11d,%ebp
mov    %ebp,(%rdx,%rsi,4)
jmp    11ce <__imlib_BlendShapedSpanToRGB+0xce>
test   %r12d,%r12d
je     12dd <__imlib_BlendShapedSpanToRGB+0x1dd>
movzbl %bl,%r8d
movzbl %bpl,%r9d
movzbl %sil,%r10d
lea    0x2(%rdx),%rsi
jmp    12b0 <__imlib_BlendShapedSpanToRGB+0x1b0>
nopl   0x0(%rax,%rax,1)
imul   %r11d,%eax
lea    0x80(%rax),%ebx
shr    $0x8,%ebx
add    %eax,%ebx
add    $0x80,%ebx
movzbl (%rsi),%r15d
mov    %r8d,%ebp
sub    %r15d,%ebp
movzbl %bh,%ecx
imul   %ecx,%ebp
mov    %rsi,%r14
mov    %ebp,%eax
shr    $0x8,%eax
add    %ebp,%eax
add    $0x80,%eax
shr    $0x8,%eax
add    %r15b,%al
mov    %al,(%r14)
movzbl -0x1(%rsi),%eax
mov    %r9d,%ebx
sub    %eax,%ebx
imul   %ecx,%ebx
mov    %ebx,%ebp
shr    $0x8,%ebp
add    %ebp,%ebx
add    $0x80,%ebx
shr    $0x8,%ebx
add    %al,%bl
mov    %bl,-0x1(%rsi)
movzbl -0x2(%rsi),%eax
mov    %r10d,%ebx
sub    %eax,%ebx
imul   %ecx,%ebx
mov    %ebx,%ecx
shr    $0x8,%ecx
add    %ebx,%ecx
add    $0x80,%ecx
shr    $0x8,%ecx
add    %al,%cl
mov    %cl,-0x2(%rsi)
add    $0x1,%rdi
add    $0x4,%rdx
add    $0x4,%rsi
test   %r12d,%r12d
je     12dd <__imlib_BlendShapedSpanToRGB+0x1dd>
add    $0xffffffff,%r12d
movzbl (%rdi),%eax
test   %eax,%eax
je     129f <__imlib_BlendShapedSpanToRGB+0x19f>
cmp    $0xff,%al
jne    1220 <__imlib_BlendShapedSpanToRGB+0x120>
lea    0x2(%rdx),%r14
movzbl (%rsi),%r15d
mov    %r8d,%ebp
sub    %r15d,%ebp
imul   %r11d,%ebp
mov    %r11d,%ecx
jmp    1248 <__imlib_BlendShapedSpanToRGB+0x148>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

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