void blend(unsigned char *src0[3], unsigned char *src1[3],
           unsigned char *matte[3], unsigned int width, unsigned int height,
           unsigned char *dst[3]) {
  register unsigned int i, j;
  register unsigned int len = width * height;
  for (i = 0; i < len; i += 4) {
    dst[0][i] =
        ((235 - matte[0][i]) * src0[0][i] + (matte[0][i] - 16) * src1[0][i]) /
        219;
    dst[0][i + 1] = ((235 - matte[0][i + 1]) * src0[0][i + 1] +
                     (matte[0][i + 1] - 16) * src1[0][i + 1]) /
                    219;
    dst[0][i + 2] = ((235 - matte[0][i + 2]) * src0[0][i + 2] +
                     (matte[0][i + 2] - 16) * src1[0][i + 2]) /
                    219;
    dst[0][i + 3] = ((235 - matte[0][i + 3]) * src0[0][i + 3] +
                     (matte[0][i + 3] - 16) * src1[0][i + 3]) /
                    219;
  }
  len >>= 2;
  for (i = 0, j = 0; i < len; i++, j += 2) {
    int m = (matte[0][j] + matte[0][j + 1] + matte[0][j + width] +
             matte[0][j + width + 1]) >>
            2;
    if ((j % width) == (width - 2))
      j += width;
    dst[1][i] = ((235 - m) * src0[1][i] + (m - 16) * src1[1][i]) / 219;
    dst[2][i] = ((235 - m) * src0[2][i] + (m - 16) * src1[2][i]) / 219;
  }
}


x86 assembly (clang, -O0):
<blend>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
imul   -0x20(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jae    1315 <blend+0x215>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    -0x2c(%rbp),%ecx
movzbl (%rax,%rcx,1),%ecx
mov    $0xeb,%eax
sub    %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%rcx
mov    -0x2c(%rbp),%edx
movzbl (%rcx,%rdx,1),%ecx
imul   %ecx,%eax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rcx
mov    -0x2c(%rbp),%edx
movzbl (%rcx,%rdx,1),%ecx
sub    $0x10,%ecx
mov    -0x10(%rbp),%rdx
mov    (%rdx),%rdx
mov    -0x2c(%rbp),%esi
movzbl (%rdx,%rsi,1),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    $0xdb,%ecx
cltd
idiv   %ecx
mov    %al,%dl
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x2c(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%ecx
mov    $0xeb,%eax
sub    %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%rcx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
imul   %ecx,%eax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rcx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
sub    $0x10,%ecx
mov    -0x10(%rbp),%rdx
mov    (%rdx),%rdx
mov    -0x2c(%rbp),%esi
add    $0x1,%esi
mov    %esi,%esi
movzbl (%rdx,%rsi,1),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    $0xdb,%ecx
cltd
idiv   %ecx
mov    %al,%dl
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%ecx
mov    $0xeb,%eax
sub    %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%rcx
mov    -0x2c(%rbp),%edx
add    $0x2,%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
imul   %ecx,%eax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rcx
mov    -0x2c(%rbp),%edx
add    $0x2,%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
sub    $0x10,%ecx
mov    -0x10(%rbp),%rdx
mov    (%rdx),%rdx
mov    -0x2c(%rbp),%esi
add    $0x2,%esi
mov    %esi,%esi
movzbl (%rdx,%rsi,1),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    $0xdb,%ecx
cltd
idiv   %ecx
mov    %al,%dl
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%ecx
mov    $0xeb,%eax
sub    %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%rcx
mov    -0x2c(%rbp),%edx
add    $0x3,%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
imul   %ecx,%eax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rcx
mov    -0x2c(%rbp),%edx
add    $0x3,%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
sub    $0x10,%ecx
mov    -0x10(%rbp),%rdx
mov    (%rdx),%rdx
mov    -0x2c(%rbp),%esi
add    $0x3,%esi
mov    %esi,%esi
movzbl (%rdx,%rsi,1),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    $0xdb,%ecx
cltd
idiv   %ecx
mov    %al,%dl
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x2c(%rbp)
jmp    112c <blend+0x2c>
mov    -0x34(%rbp),%eax
shr    $0x2,%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jae    145c <blend+0x35c>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    -0x30(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rcx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rcx
mov    -0x30(%rbp),%edx
add    -0x1c(%rbp),%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rcx
mov    -0x30(%rbp),%edx
add    -0x1c(%rbp),%edx
add    $0x1,%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
sar    $0x2,%eax
mov    %eax,-0x38(%rbp)
mov    -0x30(%rbp),%eax
xor    %edx,%edx
divl   -0x1c(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x2,%eax
cmp    %eax,%edx
jne    13ad <blend+0x2ad>
mov    -0x1c(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    $0xeb,%eax
sub    -0x38(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    0x8(%rcx),%rcx
mov    -0x2c(%rbp),%edx
movzbl (%rcx,%rdx,1),%ecx
imul   %ecx,%eax
mov    -0x38(%rbp),%ecx
sub    $0x10,%ecx
mov    -0x10(%rbp),%rdx
mov    0x8(%rdx),%rdx
mov    -0x2c(%rbp),%esi
movzbl (%rdx,%rsi,1),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    $0xdb,%ecx
cltd
idiv   %ecx
mov    %al,%dl
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0x2c(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    $0xeb,%eax
sub    -0x38(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    0x10(%rcx),%rcx
mov    -0x2c(%rbp),%edx
movzbl (%rcx,%rdx,1),%ecx
imul   %ecx,%eax
mov    -0x38(%rbp),%ecx
sub    $0x10,%ecx
mov    -0x10(%rbp),%rdx
mov    0x10(%rdx),%rdx
mov    -0x2c(%rbp),%esi
movzbl (%rdx,%rsi,1),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    $0xdb,%ecx
cltd
idiv   %ecx
mov    %al,%dl
mov    -0x28(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x2c(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x30(%rbp)
jmp    132c <blend+0x22c>
pop    %rbp
ret

x86 assembly (clang, -O2):
<blend>:
push   %rbp
push   %r15
push   %r14
push   %rbx
imul   %ecx,%r8d
test   %r8d,%r8d
je     125c <blend+0x15c>
mov    %rdx,%r10
mov    %r8d,%r11d
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
mov    (%r10),%rbp
movzbl 0x0(%rbp,%rdx,1),%ebp
mov    $0xeb,%ebx
sub    %ebp,%ebx
mov    (%rdi),%rax
movzbl (%rax,%rdx,1),%eax
imul   %ebx,%eax
add    $0xfffffff0,%ebp
mov    (%rsi),%rbx
movzbl (%rbx,%rdx,1),%ebx
imul   %ebp,%ebx
add    %eax,%ebx
movslq %ebx,%rax
imul   $0xffffffff95a02569,%rax,%rbx
shr    $0x20,%rbx
add    %ebx,%eax
mov    %eax,%ebx
shr    $0x1f,%ebx
shr    $0x7,%eax
add    %ebx,%eax
mov    (%r9),%rbx
mov    %al,(%rbx,%rdx,1)
mov    (%r10),%rax
movzbl 0x1(%rax,%rdx,1),%eax
mov    $0xeb,%ebx
sub    %eax,%ebx
mov    (%rdi),%rbp
movzbl 0x1(%rbp,%rdx,1),%ebp
imul   %ebx,%ebp
add    $0xfffffff0,%eax
mov    (%rsi),%rbx
movzbl 0x1(%rbx,%rdx,1),%ebx
imul   %eax,%ebx
add    %ebp,%ebx
movslq %ebx,%rax
imul   $0xffffffff95a02569,%rax,%rbx
shr    $0x20,%rbx
add    %ebx,%eax
mov    %eax,%ebx
shr    $0x1f,%ebx
shr    $0x7,%eax
add    %ebx,%eax
mov    (%r9),%rbx
mov    %al,0x1(%rbx,%rdx,1)
mov    (%r10),%rax
movzbl 0x2(%rax,%rdx,1),%eax
mov    $0xeb,%ebx
sub    %eax,%ebx
mov    (%rdi),%rbp
movzbl 0x2(%rbp,%rdx,1),%ebp
imul   %ebx,%ebp
add    $0xfffffff0,%eax
mov    (%rsi),%rbx
movzbl 0x2(%rbx,%rdx,1),%ebx
imul   %eax,%ebx
add    %ebp,%ebx
movslq %ebx,%rax
imul   $0xffffffff95a02569,%rax,%rbx
shr    $0x20,%rbx
add    %ebx,%eax
mov    %eax,%ebx
shr    $0x1f,%ebx
shr    $0x7,%eax
add    %ebx,%eax
mov    (%r9),%rbx
mov    %al,0x2(%rbx,%rdx,1)
mov    (%r10),%rax
movzbl 0x3(%rax,%rdx,1),%eax
mov    $0xeb,%ebx
sub    %eax,%ebx
mov    (%rdi),%rbp
movzbl 0x3(%rbp,%rdx,1),%ebp
imul   %ebx,%ebp
add    $0xfffffff0,%eax
mov    (%rsi),%rbx
movzbl 0x3(%rbx,%rdx,1),%ebx
imul   %eax,%ebx
add    %ebp,%ebx
movslq %ebx,%rax
imul   $0xffffffff95a02569,%rax,%rbx
shr    $0x20,%rbx
add    %ebx,%eax
mov    %eax,%ebx
shr    $0x1f,%ebx
shr    $0x7,%eax
add    %ebx,%eax
mov    (%r9),%rbx
mov    %al,0x3(%rbx,%rdx,1)
add    $0x4,%rdx
cmp    %r11,%rdx
jb     1120 <blend+0x20>
cmp    $0x4,%r8d
jae    1263 <blend+0x163>
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
shr    $0x2,%r8d
lea    -0x2(%rcx),%r14d
xor    %ebx,%ebx
xor    %r11d,%r11d
jmp    1313 <blend+0x213>
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0xeb,%r11d
sub    %ebp,%r11d
mov    0x8(%rdi),%rdx
movzbl (%rdx,%rbx,1),%edx
imul   %r11d,%edx
add    $0xfffffff0,%ebp
mov    0x8(%rsi),%rax
movzbl (%rax,%rbx,1),%eax
imul   %ebp,%eax
add    %edx,%eax
cltq
imul   $0xffffffff95a02569,%rax,%rdx
shr    $0x20,%rdx
add    %edx,%eax
mov    %eax,%edx
shr    $0x1f,%edx
shr    $0x7,%eax
add    %edx,%eax
mov    0x8(%r9),%rdx
mov    %al,(%rdx,%rbx,1)
mov    0x10(%rdi),%rax
movzbl (%rax,%rbx,1),%eax
imul   %r11d,%eax
mov    0x10(%rsi),%rdx
movzbl (%rdx,%rbx,1),%edx
imul   %ebp,%edx
add    %eax,%edx
movslq %edx,%rax
imul   $0xffffffff95a02569,%rax,%rdx
shr    $0x20,%rdx
add    %edx,%eax
mov    %eax,%edx
shr    $0x1f,%edx
shr    $0x7,%eax
add    %edx,%eax
mov    0x10(%r9),%rdx
mov    %al,(%rdx,%rbx,1)
add    $0x1,%rbx
add    $0x2,%r15d
mov    %r15d,%r11d
cmp    %rbx,%r8
je     125c <blend+0x15c>
mov    (%r10),%rax
mov    %r11d,%edx
movzbl (%rax,%rdx,1),%edx
lea    0x1(%r11),%ebp
movzbl (%rax,%rbp,1),%ebp
add    %edx,%ebp
lea    (%r11,%rcx,1),%r15d
movzbl (%rax,%r15,1),%edx
add    %ebp,%edx
lea    (%r11,%rcx,1),%ebp
add    $0x1,%ebp
movzbl (%rax,%rbp,1),%ebp
add    %edx,%ebp
shr    $0x2,%ebp
mov    %r11d,%eax
xor    %edx,%edx
div    %ecx
cmp    %r14d,%edx
je     1280 <blend+0x180>
mov    %r11d,%r15d
jmp    1280 <blend+0x180>

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

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