void __imlib_ReCopySpanToRGBA(unsigned int color, unsigned int *dst, int len) {
  while (len--) {
    unsigned int tmp;
    ((unsigned char *)(dst))[3] = ((unsigned char *)(&color))[3];
    do {
      tmp = (((unsigned char *)(dst))[2]) +
            (((((unsigned char *)(&color))[2]) - 127) << 1);
      ((unsigned char *)(dst))[2] = (tmp | (-(tmp >> 8))) & (~(tmp >> 9));
      ;
      tmp = (((unsigned char *)(dst))[1]) +
            (((((unsigned char *)(&color))[1]) - 127) << 1);
      ((unsigned char *)(dst))[1] = (tmp | (-(tmp >> 8))) & (~(tmp >> 9));
      ;
      tmp = (((unsigned char *)(dst))[0]) +
            (((((unsigned char *)(&color))[0]) - 127) << 1);
      ((unsigned char *)(dst))[0] = (tmp | (-(tmp >> 8))) & (~(tmp >> 9));
      ;
    } while (0);
    dst++;
  }
}


x86 assembly (clang, -O0):
<__imlib_ReCopySpanToRGBA>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
je     11e9 <__imlib_ReCopySpanToRGBA+0xe9>
mov    -0x1(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x3(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
movzbl -0x2(%rbp),%ecx
sub    $0x7f,%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x18(%rbp),%edx
shr    $0x8,%edx
xor    %ecx,%ecx
sub    %edx,%ecx
or     %ecx,%eax
mov    -0x18(%rbp),%ecx
shr    $0x9,%ecx
xor    $0xffffffff,%ecx
and    %ecx,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
movzbl -0x3(%rbp),%ecx
sub    $0x7f,%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x18(%rbp),%edx
shr    $0x8,%edx
xor    %ecx,%ecx
sub    %edx,%ecx
or     %ecx,%eax
mov    -0x18(%rbp),%ecx
shr    $0x9,%ecx
xor    $0xffffffff,%ecx
and    %ecx,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
movzbl -0x4(%rbp),%ecx
sub    $0x7f,%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x18(%rbp),%edx
shr    $0x8,%edx
xor    %ecx,%ecx
sub    %edx,%ecx
or     %ecx,%eax
mov    -0x18(%rbp),%ecx
shr    $0x9,%ecx
xor    $0xffffffff,%ecx
and    %ecx,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    -0x10(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x10(%rbp)
jmp    110e <__imlib_ReCopySpanToRGBA+0xe>
pop    %rbp
ret

x86 assembly (clang, -O2):
<__imlib_ReCopySpanToRGBA>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
test   %edx,%edx
je     1b3e <__imlib_ReCopySpanToRGBA+0xa3e>
mov    %edi,%ecx
mov    %edi,%r13d
shr    $0x18,%r13d
mov    %edi,%ebp
shr    $0xf,%ebp
and    $0x1fe,%ebp
add    $0xffffff02,%ebp
movzbl %ch,%edi
lea    (%rdi,%rdi,1),%r9d
add    $0xffffff02,%r9d
movzbl %cl,%ecx
lea    (%rcx,%rcx,1),%r10d
add    $0xffffff02,%r10d
lea    -0x1(%rdx),%r14d
cmp    $0x4,%r14d
jb     1acd <__imlib_ReCopySpanToRGBA+0x9cd>
movd   %ebp,%xmm0
movd   %r9d,%xmm9
movd   %r10d,%xmm10
cmp    $0x10,%r14d
jae    1175 <__imlib_ReCopySpanToRGBA+0x75>
xor    %edi,%edi
jmp    18da <__imlib_ReCopySpanToRGBA+0x7da>
mov    %rdx,-0x38(%rsp)
mov    %r10d,-0x4c(%rsp)
mov    %r9d,-0x48(%rsp)
mov    %ebp,-0x44(%rsp)
lea    0x1(%r14),%rax
mov    %eax,%ecx
and    $0xf,%ecx
test   %rcx,%rcx
mov    $0x10,%edx
cmovne %rcx,%rdx
sub    %rdx,%rax
mov    %rax,-0x40(%rsp)
movdqa %xmm0,0x20(%rsp)
pshufd $0x0,%xmm0,%xmm11
pshufd $0x0,%xmm9,%xmm12
pshufd $0x0,%xmm10,%xmm13
lea    0x3f(%rsi),%rbx
mov    %r14,0x8(%rsp)
mov    %rdx,%rax
mov    %rdx,0x10(%rsp)
sub    %rdx,%r14
mov    %r14,0x18(%rsp)
mov    $0xffffffffffffffff,%rdi
pxor   %xmm15,%xmm15
movdqa 0xe15(%rip),%xmm14
nopl   0x0(%rax,%rax,1)
mov    %r13b,-0x38(%rbx,%rdi,4)
mov    %r13b,-0x34(%rbx,%rdi,4)
mov    %r13b,-0x30(%rbx,%rdi,4)
mov    %r13b,-0x2c(%rbx,%rdi,4)
mov    %r13b,-0x28(%rbx,%rdi,4)
mov    %r13b,-0x24(%rbx,%rdi,4)
mov    %r13b,-0x20(%rbx,%rdi,4)
mov    %r13b,-0x1c(%rbx,%rdi,4)
mov    %r13b,-0x18(%rbx,%rdi,4)
mov    %r13b,-0x14(%rbx,%rdi,4)
mov    %r13b,-0x10(%rbx,%rdi,4)
mov    %r13b,-0xc(%rbx,%rdi,4)
mov    %r13b,-0x8(%rbx,%rdi,4)
mov    %r13b,-0x4(%rbx,%rdi,4)
mov    %r13b,(%rbx,%rdi,4)
mov    %r13b,0x4(%rbx,%rdi,4)
movzbl -0x39(%rbx,%rdi,4),%r10d
movzbl -0x31(%rbx,%rdi,4),%r14d
movzbl -0x29(%rbx,%rdi,4),%eax
movzbl -0x21(%rbx,%rdi,4),%r15d
movzbl -0x19(%rbx,%rdi,4),%r12d
movzbl -0x11(%rbx,%rdi,4),%r11d
movzbl -0x9(%rbx,%rdi,4),%edx
movzbl -0x1(%rbx,%rdi,4),%r9d
movzbl -0x2d(%rbx,%rdi,4),%r8d
shl    $0x8,%r8d
or     %r14d,%r8d
movzbl -0x35(%rbx,%rdi,4),%ecx
shl    $0x8,%ecx
or     %r10d,%ecx
movd   %ecx,%xmm0
pinsrw $0x1,%r8d,%xmm0
movzbl 0x3(%rbx,%rdi,4),%ecx
shl    $0x8,%ecx
or     %r9d,%ecx
movzbl -0x5(%rbx,%rdi,4),%ebp
shl    $0x8,%ebp
or     %edx,%ebp
movd   %ebp,%xmm1
pinsrw $0x1,%ecx,%xmm1
punpcklbw %xmm15,%xmm1
punpcklwd %xmm15,%xmm1
movzbl -0xd(%rbx,%rdi,4),%ecx
shl    $0x8,%ecx
or     %r11d,%ecx
movzbl -0x15(%rbx,%rdi,4),%edx
shl    $0x8,%edx
or     %r12d,%edx
movd   %edx,%xmm2
pinsrw $0x1,%ecx,%xmm2
punpcklbw %xmm15,%xmm2
punpcklwd %xmm15,%xmm2
movzbl -0x1d(%rbx,%rdi,4),%ecx
shl    $0x8,%ecx
or     %r15d,%ecx
movzbl -0x25(%rbx,%rdi,4),%edx
shl    $0x8,%edx
or     %eax,%edx
movd   %edx,%xmm3
pinsrw $0x1,%ecx,%xmm3
punpcklbw %xmm15,%xmm3
punpcklwd %xmm15,%xmm3
punpcklbw %xmm15,%xmm0
punpcklwd %xmm15,%xmm0
paddd  %xmm11,%xmm0
paddd  %xmm11,%xmm3
paddd  %xmm11,%xmm2
paddd  %xmm11,%xmm1
movdqa %xmm1,%xmm4
psrld  $0x8,%xmm4
movdqa %xmm2,%xmm5
psrld  $0x8,%xmm5
movdqa %xmm3,%xmm7
psrld  $0x8,%xmm7
movdqa %xmm0,%xmm6
psrld  $0x8,%xmm6
pxor   %xmm8,%xmm8
psubd  %xmm6,%xmm8
pxor   %xmm6,%xmm6
psubd  %xmm7,%xmm6
pxor   %xmm7,%xmm7
psubd  %xmm5,%xmm7
pxor   %xmm5,%xmm5
psubd  %xmm4,%xmm5
por    %xmm1,%xmm5
por    %xmm2,%xmm7
por    %xmm3,%xmm6
por    %xmm0,%xmm8
psrld  $0x9,%xmm1
pandn  %xmm5,%xmm1
psrld  $0x9,%xmm2
pandn  %xmm7,%xmm2
psrld  $0x9,%xmm3
pandn  %xmm6,%xmm3
psrld  $0x9,%xmm0
pandn  %xmm8,%xmm0
pand   %xmm14,%xmm1
pand   %xmm14,%xmm2
packuswb %xmm1,%xmm2
pand   %xmm14,%xmm3
pand   %xmm14,%xmm0
packuswb %xmm3,%xmm0
packuswb %xmm2,%xmm0
movdqa %xmm0,-0x80(%rsp)
movzbl -0x80(%rsp),%ecx
movzbl -0x7f(%rsp),%edx
mov    %cl,-0x39(%rbx,%rdi,4)
mov    %dl,-0x35(%rbx,%rdi,4)
movzbl -0x7e(%rsp),%ecx
mov    %cl,-0x31(%rbx,%rdi,4)
movzbl -0x7d(%rsp),%ecx
mov    %cl,-0x2d(%rbx,%rdi,4)
movzbl -0x7c(%rsp),%ecx
mov    %cl,-0x29(%rbx,%rdi,4)
movzbl -0x7b(%rsp),%ecx
mov    %cl,-0x25(%rbx,%rdi,4)
movzbl -0x7a(%rsp),%ecx
mov    %cl,-0x21(%rbx,%rdi,4)
movzbl -0x79(%rsp),%ecx
mov    %cl,-0x1d(%rbx,%rdi,4)
movzbl -0x78(%rsp),%ecx
mov    %cl,-0x19(%rbx,%rdi,4)
movzbl -0x77(%rsp),%ecx
mov    %cl,-0x15(%rbx,%rdi,4)
movzbl -0x76(%rsp),%ecx
mov    %cl,-0x11(%rbx,%rdi,4)
movzbl -0x75(%rsp),%ecx
mov    %cl,-0xd(%rbx,%rdi,4)
movzbl -0x74(%rsp),%ecx
mov    %cl,-0x9(%rbx,%rdi,4)
movzbl -0x73(%rsp),%ecx
mov    %cl,-0x5(%rbx,%rdi,4)
movzbl -0x72(%rsp),%ecx
mov    %cl,-0x1(%rbx,%rdi,4)
movzbl -0x71(%rsp),%ecx
mov    %cl,0x3(%rbx,%rdi,4)
movzbl -0x3a(%rbx,%rdi,4),%edx
movzbl -0x32(%rbx,%rdi,4),%ebp
movzbl -0x2a(%rbx,%rdi,4),%r9d
movzbl -0x22(%rbx,%rdi,4),%r11d
movzbl -0x1a(%rbx,%rdi,4),%r8d
movzbl -0x12(%rbx,%rdi,4),%r10d
movzbl -0xa(%rbx,%rdi,4),%r14d
movzbl -0x2(%rbx,%rdi,4),%ecx
movzbl -0x2e(%rbx,%rdi,4),%eax
shl    $0x8,%eax
or     %ebp,%eax
movzbl -0x36(%rbx,%rdi,4),%ebp
shl    $0x8,%ebp
or     %edx,%ebp
movd   %ebp,%xmm0
pinsrw $0x1,%eax,%xmm0
movzbl 0x2(%rbx,%rdi,4),%eax
shl    $0x8,%eax
or     %ecx,%eax
movzbl -0x6(%rbx,%rdi,4),%ecx
shl    $0x8,%ecx
or     %r14d,%ecx
movd   %ecx,%xmm1
pinsrw $0x1,%eax,%xmm1
punpcklbw %xmm15,%xmm1
punpcklwd %xmm15,%xmm1
movzbl -0xe(%rbx,%rdi,4),%eax
shl    $0x8,%eax
or     %r10d,%eax
movzbl -0x16(%rbx,%rdi,4),%ecx
shl    $0x8,%ecx
or     %r8d,%ecx
movd   %ecx,%xmm2
pinsrw $0x1,%eax,%xmm2
punpcklbw %xmm15,%xmm2
punpcklwd %xmm15,%xmm2
movzbl -0x1e(%rbx,%rdi,4),%eax
shl    $0x8,%eax
or     %r11d,%eax
movzbl -0x26(%rbx,%rdi,4),%ecx
shl    $0x8,%ecx
or     %r9d,%ecx
movd   %ecx,%xmm3
pinsrw $0x1,%eax,%xmm3
punpcklbw %xmm15,%xmm3
punpcklwd %xmm15,%xmm3
punpcklbw %xmm15,%xmm0
punpcklwd %xmm15,%xmm0
paddd  %xmm12,%xmm0
paddd  %xmm12,%xmm3
paddd  %xmm12,%xmm2
paddd  %xmm12,%xmm1
movdqa %xmm1,%xmm8
psrld  $0x8,%xmm8
movdqa %xmm2,%xmm5
psrld  $0x8,%xmm5
movdqa %xmm3,%xmm6
psrld  $0x8,%xmm6
movdqa %xmm0,%xmm7
psrld  $0x8,%xmm7
pxor   %xmm4,%xmm4
psubd  %xmm7,%xmm4
pxor   %xmm7,%xmm7
psubd  %xmm6,%xmm7
pxor   %xmm6,%xmm6
psubd  %xmm5,%xmm6
pxor   %xmm5,%xmm5
psubd  %xmm8,%xmm5
por    %xmm1,%xmm5
por    %xmm2,%xmm6
por    %xmm3,%xmm7
por    %xmm0,%xmm4
psrld  $0x9,%xmm1
pandn  %xmm5,%xmm1
psrld  $0x9,%xmm2
pandn  %xmm6,%xmm2
psrld  $0x9,%xmm3
pandn  %xmm7,%xmm3
psrld  $0x9,%xmm0
pandn  %xmm4,%xmm0
pand   %xmm14,%xmm1
pand   %xmm14,%xmm2
packuswb %xmm1,%xmm2
pand   %xmm14,%xmm3
pand   %xmm14,%xmm0
packuswb %xmm3,%xmm0
packuswb %xmm2,%xmm0
movdqa %xmm0,-0x70(%rsp)
movzbl -0x70(%rsp),%eax
movzbl -0x6f(%rsp),%ecx
mov    %al,-0x3a(%rbx,%rdi,4)
mov    %cl,-0x36(%rbx,%rdi,4)
movzbl -0x6e(%rsp),%eax
mov    %al,-0x32(%rbx,%rdi,4)
movzbl -0x6d(%rsp),%eax
mov    %al,-0x2e(%rbx,%rdi,4)
movzbl -0x6c(%rsp),%eax
mov    %al,-0x2a(%rbx,%rdi,4)
movzbl -0x6b(%rsp),%eax
mov    %al,-0x26(%rbx,%rdi,4)
movzbl -0x6a(%rsp),%eax
mov    %al,-0x22(%rbx,%rdi,4)
movzbl -0x69(%rsp),%eax
mov    %al,-0x1e(%rbx,%rdi,4)
movzbl -0x68(%rsp),%eax
mov    %al,-0x1a(%rbx,%rdi,4)
movzbl -0x67(%rsp),%eax
mov    %al,-0x16(%rbx,%rdi,4)
movzbl -0x66(%rsp),%eax
mov    %al,-0x12(%rbx,%rdi,4)
movzbl -0x65(%rsp),%eax
mov    %al,-0xe(%rbx,%rdi,4)
movzbl -0x64(%rsp),%eax
mov    %al,-0xa(%rbx,%rdi,4)
movzbl -0x63(%rsp),%eax
mov    %al,-0x6(%rbx,%rdi,4)
movzbl -0x62(%rsp),%eax
mov    %al,-0x2(%rbx,%rdi,4)
movzbl -0x61(%rsp),%eax
mov    %al,0x2(%rbx,%rdi,4)
movzbl -0x3b(%rbx,%rdi,4),%edx
movzbl -0x33(%rbx,%rdi,4),%eax
movzbl -0x2b(%rbx,%rdi,4),%r8d
movzbl -0x23(%rbx,%rdi,4),%r11d
movzbl -0x1b(%rbx,%rdi,4),%r9d
movzbl -0x13(%rbx,%rdi,4),%r10d
movzbl -0xb(%rbx,%rdi,4),%r14d
movzbl -0x3(%rbx,%rdi,4),%ecx
movzbl -0x2f(%rbx,%rdi,4),%ebp
shl    $0x8,%ebp
or     %eax,%ebp
movzbl -0x37(%rbx,%rdi,4),%eax
shl    $0x8,%eax
or     %edx,%eax
movd   %eax,%xmm0
pinsrw $0x1,%ebp,%xmm0
movzbl 0x1(%rbx,%rdi,4),%eax
shl    $0x8,%eax
or     %ecx,%eax
movzbl -0x7(%rbx,%rdi,4),%ecx
shl    $0x8,%ecx
or     %r14d,%ecx
movd   %ecx,%xmm1
pinsrw $0x1,%eax,%xmm1
punpcklbw %xmm15,%xmm1
punpcklwd %xmm15,%xmm1
movzbl -0xf(%rbx,%rdi,4),%eax
shl    $0x8,%eax
or     %r10d,%eax
movzbl -0x17(%rbx,%rdi,4),%ecx
shl    $0x8,%ecx
or     %r9d,%ecx
movd   %ecx,%xmm2
pinsrw $0x1,%eax,%xmm2
punpcklbw %xmm15,%xmm2
punpcklwd %xmm15,%xmm2
movzbl -0x1f(%rbx,%rdi,4),%eax
shl    $0x8,%eax
or     %r11d,%eax
movzbl -0x27(%rbx,%rdi,4),%ecx
shl    $0x8,%ecx
or     %r8d,%ecx
movd   %ecx,%xmm3
pinsrw $0x1,%eax,%xmm3
punpcklbw %xmm15,%xmm3
punpcklwd %xmm15,%xmm3
punpcklbw %xmm15,%xmm0
punpcklwd %xmm15,%xmm0
paddd  %xmm13,%xmm0
paddd  %xmm13,%xmm3
paddd  %xmm13,%xmm2
paddd  %xmm13,%xmm1
movdqa %xmm1,%xmm8
psrld  $0x8,%xmm8
movdqa %xmm2,%xmm5
psrld  $0x8,%xmm5
movdqa %xmm3,%xmm6
psrld  $0x8,%xmm6
movdqa %xmm0,%xmm7
psrld  $0x8,%xmm7
pxor   %xmm4,%xmm4
psubd  %xmm7,%xmm4
pxor   %xmm7,%xmm7
psubd  %xmm6,%xmm7
pxor   %xmm6,%xmm6
psubd  %xmm5,%xmm6
pxor   %xmm5,%xmm5
psubd  %xmm8,%xmm5
por    %xmm1,%xmm5
por    %xmm2,%xmm6
por    %xmm3,%xmm7
por    %xmm0,%xmm4
psrld  $0x9,%xmm1
pandn  %xmm5,%xmm1
psrld  $0x9,%xmm2
pandn  %xmm6,%xmm2
psrld  $0x9,%xmm3
pandn  %xmm7,%xmm3
psrld  $0x9,%xmm0
pandn  %xmm4,%xmm0
pand   %xmm14,%xmm1
pand   %xmm14,%xmm2
packuswb %xmm1,%xmm2
pand   %xmm14,%xmm3
pand   %xmm14,%xmm0
packuswb %xmm3,%xmm0
packuswb %xmm2,%xmm0
movdqa %xmm0,-0x60(%rsp)
movzbl -0x60(%rsp),%eax
movzbl -0x5f(%rsp),%ecx
mov    %al,-0x3b(%rbx,%rdi,4)
mov    %cl,-0x37(%rbx,%rdi,4)
movzbl -0x5e(%rsp),%eax
mov    %al,-0x33(%rbx,%rdi,4)
movzbl -0x5d(%rsp),%eax
mov    %al,-0x2f(%rbx,%rdi,4)
movzbl -0x5c(%rsp),%eax
mov    %al,-0x2b(%rbx,%rdi,4)
movzbl -0x5b(%rsp),%eax
mov    %al,-0x27(%rbx,%rdi,4)
movzbl -0x5a(%rsp),%eax
mov    %al,-0x23(%rbx,%rdi,4)
movzbl -0x59(%rsp),%eax
mov    %al,-0x1f(%rbx,%rdi,4)
movzbl -0x58(%rsp),%eax
mov    %al,-0x1b(%rbx,%rdi,4)
movzbl -0x57(%rsp),%eax
mov    %al,-0x17(%rbx,%rdi,4)
movzbl -0x56(%rsp),%eax
mov    %al,-0x13(%rbx,%rdi,4)
movzbl -0x55(%rsp),%eax
mov    %al,-0xf(%rbx,%rdi,4)
movzbl -0x54(%rsp),%eax
mov    %al,-0xb(%rbx,%rdi,4)
movzbl -0x53(%rsp),%eax
mov    %al,-0x7(%rbx,%rdi,4)
movzbl -0x52(%rsp),%eax
mov    %al,-0x3(%rbx,%rdi,4)
movzbl -0x51(%rsp),%eax
mov    %al,0x1(%rbx,%rdi,4)
add    $0x10,%rdi
cmp    %rdi,0x18(%rsp)
jne    11f0 <__imlib_ReCopySpanToRGBA+0xf0>
cmpl   $0x5,0x10(%rsp)
jae    18b7 <__imlib_ReCopySpanToRGBA+0x7b7>
mov    -0x38(%rsp),%rdx
mov    -0x40(%rsp),%rax
sub    %eax,%edx
lea    (%rsi,%rax,4),%rsi
mov    -0x44(%rsp),%ebp
mov    -0x48(%rsp),%r9d
mov    -0x4c(%rsp),%r10d
jmp    1acd <__imlib_ReCopySpanToRGBA+0x9cd>
mov    -0x44(%rsp),%ebp
mov    -0x48(%rsp),%r9d
mov    -0x4c(%rsp),%r10d
mov    -0x38(%rsp),%rdx
mov    0x8(%rsp),%r14
mov    -0x40(%rsp),%rdi
movdqa 0x20(%rsp),%xmm0
mov    %r14,%rax
add    $0x1,%rax
mov    %eax,%ecx
and    $0x3,%ecx
test   %rcx,%rcx
mov    $0x4,%ebx
cmovne %rcx,%rbx
sub    %rbx,%rax
lea    (%rsi,%rax,4),%r11
sub    %eax,%edx
pshufd $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm9,%xmm1
pshufd $0x0,%xmm10,%xmm2
lea    (%rsi,%rdi,4),%rsi
add    $0xf,%rsi
sub    %rbx,%r14
sub    %rdi,%r14
mov    $0xffffffffffffffff,%rbx
pxor   %xmm3,%xmm3
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r13b,-0x8(%rsi,%rbx,4)
mov    %r13b,-0x4(%rsi,%rbx,4)
mov    %r13b,(%rsi,%rbx,4)
mov    %r13b,0x4(%rsi,%rbx,4)
movzbl -0x9(%rsi,%rbx,4),%eax
movzbl -0x1(%rsi,%rbx,4),%ecx
movzbl 0x3(%rsi,%rbx,4),%edi
shl    $0x8,%edi
or     %ecx,%edi
movzbl -0x5(%rsi,%rbx,4),%ecx
shl    $0x8,%ecx
or     %eax,%ecx
movd   %ecx,%xmm4
pinsrw $0x1,%edi,%xmm4
punpcklbw %xmm3,%xmm4
punpcklwd %xmm3,%xmm4
paddd  %xmm0,%xmm4
movdqa %xmm4,%xmm5
psrld  $0x8,%xmm5
pxor   %xmm6,%xmm6
psubd  %xmm5,%xmm6
por    %xmm4,%xmm6
psrld  $0x9,%xmm4
pandn  %xmm6,%xmm4
movdqa %xmm4,-0x20(%rsp)
movzbl -0x14(%rsp),%r8d
movzbl -0x18(%rsp),%edi
movzbl -0x20(%rsp),%ecx
movzbl -0x1c(%rsp),%eax
mov    %cl,-0x9(%rsi,%rbx,4)
mov    %al,-0x5(%rsi,%rbx,4)
mov    %dil,-0x1(%rsi,%rbx,4)
mov    %r8b,0x3(%rsi,%rbx,4)
movzbl -0xa(%rsi,%rbx,4),%eax
movzbl -0x2(%rsi,%rbx,4),%ecx
movzbl 0x2(%rsi,%rbx,4),%edi
shl    $0x8,%edi
or     %ecx,%edi
movzbl -0x6(%rsi,%rbx,4),%ecx
shl    $0x8,%ecx
or     %eax,%ecx
movd   %ecx,%xmm4
pinsrw $0x1,%edi,%xmm4
punpcklbw %xmm3,%xmm4
punpcklwd %xmm3,%xmm4
paddd  %xmm1,%xmm4
movdqa %xmm4,%xmm5
psrld  $0x8,%xmm5
pxor   %xmm6,%xmm6
psubd  %xmm5,%xmm6
por    %xmm4,%xmm6
psrld  $0x9,%xmm4
pandn  %xmm6,%xmm4
movdqa %xmm4,-0x30(%rsp)
movzbl -0x24(%rsp),%r8d
movzbl -0x28(%rsp),%edi
movzbl -0x30(%rsp),%ecx
movzbl -0x2c(%rsp),%eax
mov    %cl,-0xa(%rsi,%rbx,4)
mov    %al,-0x6(%rsi,%rbx,4)
mov    %dil,-0x2(%rsi,%rbx,4)
mov    %r8b,0x2(%rsi,%rbx,4)
movzbl -0xb(%rsi,%rbx,4),%eax
movzbl -0x3(%rsi,%rbx,4),%ecx
movzbl 0x1(%rsi,%rbx,4),%edi
shl    $0x8,%edi
or     %ecx,%edi
movzbl -0x7(%rsi,%rbx,4),%ecx
shl    $0x8,%ecx
or     %eax,%ecx
movd   %ecx,%xmm4
pinsrw $0x1,%edi,%xmm4
punpcklbw %xmm3,%xmm4
punpcklwd %xmm3,%xmm4
paddd  %xmm2,%xmm4
movdqa %xmm4,%xmm5
psrld  $0x8,%xmm5
pxor   %xmm6,%xmm6
psubd  %xmm5,%xmm6
por    %xmm4,%xmm6
psrld  $0x9,%xmm4
pandn  %xmm6,%xmm4
movdqa %xmm4,-0x10(%rsp)
movzbl -0x4(%rsp),%r8d
movzbl -0x8(%rsp),%edi
movzbl -0x10(%rsp),%ecx
movzbl -0xc(%rsp),%eax
mov    %cl,-0xb(%rsi,%rbx,4)
mov    %al,-0x7(%rsi,%rbx,4)
mov    %dil,-0x3(%rsi,%rbx,4)
mov    %r8b,0x1(%rsi,%rbx,4)
add    $0x4,%rbx
cmp    %rbx,%r14
jne    1930 <__imlib_ReCopySpanToRGBA+0x830>
mov    %r11,%rsi
mov    %edx,%edx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r13b,0x3(%rsi,%rdi,4)
movzbl 0x2(%rsi,%rdi,4),%eax
add    %ebp,%eax
mov    %eax,%ecx
shr    $0x8,%ecx
neg    %ecx
or     %eax,%ecx
shr    $0x9,%eax
not    %eax
and    %ecx,%eax
mov    %al,0x2(%rsi,%rdi,4)
movzbl 0x1(%rsi,%rdi,4),%eax
add    %r9d,%eax
mov    %eax,%ecx
shr    $0x8,%ecx
neg    %ecx
or     %eax,%ecx
shr    $0x9,%eax
not    %eax
and    %ecx,%eax
mov    %al,0x1(%rsi,%rdi,4)
movzbl (%rsi,%rdi,4),%eax
add    %r10d,%eax
mov    %eax,%ecx
shr    $0x8,%ecx
neg    %ecx
or     %eax,%ecx
shr    $0x9,%eax
not    %eax
and    %ecx,%eax
mov    %al,(%rsi,%rdi,4)
add    $0x1,%rdi
cmp    %edi,%edx
jne    1ae0 <__imlib_ReCopySpanToRGBA+0x9e0>
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @__imlib_ReCopySpanToRGBA(i32 %0, i32* %1, i32 %2) {
%4 = alloca i32
%5 = alloca i32*
%6 = alloca i32
%7 = alloca i32
store i32 %0, i32* %4
store i32* %1, i32** %5
store i32 %2, i32* %6
br label %8
8: ; preds = %95, %3
%9 = load i32, i32* %6
%10 = add nsw i32 %9, -1
store i32 %10, i32* %6
%11 = icmp ne i32 %9, 0
br i1 %11, label %12, label %98
12: ; preds = %8
%13 = bitcast i32* %4 to i8*
%14 = getelementptr inbounds i8, i8* %13, i64 3
%15 = load i8, i8* %14
%16 = load i32*, i32** %5
%17 = bitcast i32* %16 to i8*
%18 = getelementptr inbounds i8, i8* %17, i64 3
store i8 %15, i8* %18
br label %19
19: ; preds = %12
%20 = load i32*, i32** %5
%21 = bitcast i32* %20 to i8*
%22 = getelementptr inbounds i8, i8* %21, i64 2
%23 = load i8, i8* %22
%24 = zext i8 %23 to i32
%25 = bitcast i32* %4 to i8*
%26 = getelementptr inbounds i8, i8* %25, i64 2
%27 = load i8, i8* %26
%28 = zext i8 %27 to i32
%29 = sub nsw i32 %28, 127
%30 = shl i32 %29, 1
%31 = add nsw i32 %24, %30
store i32 %31, i32* %7
%32 = load i32, i32* %7
%33 = load i32, i32* %7
%34 = lshr i32 %33, 8
%35 = sub i32 0, %34
%36 = or i32 %32, %35
%37 = load i32, i32* %7
%38 = lshr i32 %37, 9
%39 = xor i32 %38, -1
%40 = and i32 %36, %39
%41 = trunc i32 %40 to i8
%42 = load i32*, i32** %5
%43 = bitcast i32* %42 to i8*
%44 = getelementptr inbounds i8, i8* %43, i64 2
store i8 %41, i8* %44
%45 = load i32*, i32** %5
%46 = bitcast i32* %45 to i8*
%47 = getelementptr inbounds i8, i8* %46, i64 1
%48 = load i8, i8* %47
%49 = zext i8 %48 to i32
%50 = bitcast i32* %4 to i8*
%51 = getelementptr inbounds i8, i8* %50, i64 1
%52 = load i8, i8* %51
%53 = zext i8 %52 to i32
%54 = sub nsw i32 %53, 127
%55 = shl i32 %54, 1
%56 = add nsw i32 %49, %55
store i32 %56, i32* %7
%57 = load i32, i32* %7
%58 = load i32, i32* %7
%59 = lshr i32 %58, 8
%60 = sub i32 0, %59
%61 = or i32 %57, %60
%62 = load i32, i32* %7
%63 = lshr i32 %62, 9
%64 = xor i32 %63, -1
%65 = and i32 %61, %64
%66 = trunc i32 %65 to i8
%67 = load i32*, i32** %5
%68 = bitcast i32* %67 to i8*
%69 = getelementptr inbounds i8, i8* %68, i64 1
store i8 %66, i8* %69
%70 = load i32*, i32** %5
%71 = bitcast i32* %70 to i8*
%72 = getelementptr inbounds i8, i8* %71, i64 0
%73 = load i8, i8* %72
%74 = zext i8 %73 to i32
%75 = bitcast i32* %4 to i8*
%76 = getelementptr inbounds i8, i8* %75, i64 0
%77 = load i8, i8* %76
%78 = zext i8 %77 to i32
%79 = sub nsw i32 %78, 127
%80 = shl i32 %79, 1
%81 = add nsw i32 %74, %80
store i32 %81, i32* %7
%82 = load i32, i32* %7
%83 = load i32, i32* %7
%84 = lshr i32 %83, 8
%85 = sub i32 0, %84
%86 = or i32 %82, %85
%87 = load i32, i32* %7
%88 = lshr i32 %87, 9
%89 = xor i32 %88, -1
%90 = and i32 %86, %89
%91 = trunc i32 %90 to i8
%92 = load i32*, i32** %5
%93 = bitcast i32* %92 to i8*
%94 = getelementptr inbounds i8, i8* %93, i64 0
store i8 %91, i8* %94
br label %95
95: ; preds = %19
%96 = load i32*, i32** %5
%97 = getelementptr inbounds i32, i32* %96, i32 1
store i32* %97, i32** %5
br label %8
98: ; preds = %8
ret void
}

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