#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ SDL_imageFilterMMXdetect();
int /*<<< orphan*/ SDL_imageFilterShiftRightAndMultByByteMMX(unsigned char *,
                                                             unsigned char *,
                                                             unsigned int,
                                                             unsigned char,
                                                             unsigned char);
int /*<<< orphan*/ memcpy(unsigned char *, unsigned char *, unsigned int);
int SDL_imageFilterShiftRightAndMultByByte(unsigned char *Src1,
                                           unsigned char *Dest,
                                           unsigned int length, unsigned char N,
                                           unsigned char C) {
  unsigned int i, istart;
  int iC;
  unsigned char *cursrc1;
  unsigned char *curdest;
  int result;
  if ((Src1 == NULL) || (Dest == NULL))
    return (-1);
  if (length == 0)
    return (0);
  if (N > 8) {
    return (-1);
  }
  if ((N == 0) && (C == 1)) {
    memcpy(Src1, Dest, length);
    return (0);
  }
  if ((SDL_imageFilterMMXdetect()) && (length > 7)) {
    SDL_imageFilterShiftRightAndMultByByteMMX(Src1, Dest, length, N, C);
    if ((length & 7) > 0) {
      istart = length & 0xfffffff8;
      cursrc1 = &Src1[istart];
      curdest = &Dest[istart];
    } else {
      return (0);
    }
  } else {
    istart = 0;
    cursrc1 = Src1;
    curdest = Dest;
  }
  iC = (int)C;
  for (i = istart; i < length; i++) {
    result = (int)(*cursrc1 >> N) * iC;
    if (result > 255)
      result = 255;
    *curdest = (unsigned char)result;
    cursrc1++;
    curdest++;
  }
  return (0);
}


x86 assembly (clang, -O0):
<SDL_imageFilterShiftRightAndMultByByte>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %r8b,%al
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %cl,-0x1d(%rbp)
mov    %al,-0x1e(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     1162 <SDL_imageFilterShiftRightAndMultByByte+0x32>
cmpq   $0x0,-0x18(%rbp)
jne    116e <SDL_imageFilterShiftRightAndMultByByte+0x3e>
movl   $0xffffffff,-0x4(%rbp)
jmp    12e3 <SDL_imageFilterShiftRightAndMultByByte+0x1b3>
cmpl   $0x0,-0x1c(%rbp)
jne    1184 <SDL_imageFilterShiftRightAndMultByByte+0x54>
movl   $0x0,-0x4(%rbp)
jmp    12e3 <SDL_imageFilterShiftRightAndMultByByte+0x1b3>
movzbl -0x1d(%rbp),%eax
cmp    $0x8,%eax
jle    119d <SDL_imageFilterShiftRightAndMultByByte+0x6d>
movl   $0xffffffff,-0x4(%rbp)
jmp    12e3 <SDL_imageFilterShiftRightAndMultByByte+0x1b3>
movzbl -0x1d(%rbp),%eax
cmp    $0x0,%eax
jne    11d3 <SDL_imageFilterShiftRightAndMultByByte+0xa3>
movzbl -0x1e(%rbp),%eax
cmp    $0x1,%eax
jne    11d3 <SDL_imageFilterShiftRightAndMultByByte+0xa3>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c(%rbp),%edx
call   1050 <memcpy@plt>
movl   $0x0,-0x4(%rbp)
jmp    12e3 <SDL_imageFilterShiftRightAndMultByByte+0x1b3>
mov    $0x0,%al
call   1030 <SDL_imageFilterMMXdetect@plt>
cmp    $0x0,%rax
je     1253 <SDL_imageFilterShiftRightAndMultByByte+0x123>
cmpl   $0x7,-0x1c(%rbp)
jbe    1253 <SDL_imageFilterShiftRightAndMultByByte+0x123>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    -0x1d(%rbp),%al
movzbl %al,%ecx
movzbl -0x1e(%rbp),%r8d
call   1040 <SDL_imageFilterShiftRightAndMultByByteMMX@plt>
mov    -0x1c(%rbp),%eax
and    $0x7,%eax
cmp    $0x0,%eax
jbe    1242 <SDL_imageFilterShiftRightAndMultByByte+0x112>
mov    -0x1c(%rbp),%eax
and    $0xfffffff8,%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
jmp    124e <SDL_imageFilterShiftRightAndMultByByte+0x11e>
movl   $0x0,-0x4(%rbp)
jmp    12e3 <SDL_imageFilterShiftRightAndMultByByte+0x1b3>
jmp    126a <SDL_imageFilterShiftRightAndMultByByte+0x13a>
movl   $0x0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x40(%rbp)
movzbl -0x1e(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    12dc <SDL_imageFilterShiftRightAndMultByByte+0x1ac>
mov    -0x38(%rbp),%rax
movzbl (%rax),%eax
movzbl -0x1d(%rbp),%ecx
sar    %cl,%eax
imul   -0x2c(%rbp),%eax
mov    %eax,-0x44(%rbp)
cmpl   $0xff,-0x44(%rbp)
jle    12ab <SDL_imageFilterShiftRightAndMultByByte+0x17b>
movl   $0xff,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    %al,%cl
mov    -0x40(%rbp),%rax
mov    %cl,(%rax)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1277 <SDL_imageFilterShiftRightAndMultByByte+0x147>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SDL_imageFilterShiftRightAndMultByByte>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    $0xffffffff,%ebp
test   %rdi,%rdi
je     117b <SDL_imageFilterShiftRightAndMultByByte+0x4b>
mov    %rsi,%r13
test   %rsi,%rsi
je     117b <SDL_imageFilterShiftRightAndMultByByte+0x4b>
mov    %edx,%r15d
test   %edx,%edx
je     1179 <SDL_imageFilterShiftRightAndMultByByte+0x49>
mov    %ecx,%r12d
cmp    $0x8,%r12b
ja     117b <SDL_imageFilterShiftRightAndMultByByte+0x4b>
mov    %rdi,%rbx
test   %r12b,%r12b
jne    118c <SDL_imageFilterShiftRightAndMultByByte+0x5c>
cmp    $0x1,%r8b
jne    118c <SDL_imageFilterShiftRightAndMultByByte+0x5c>
mov    %rbx,%rdi
mov    %r13,%rsi
mov    %r15d,%edx
call   1050 <memcpy@plt>
xor    %ebp,%ebp
mov    %ebp,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movzbl %r12b,%eax
mov    %eax,0x4(%rsp)
movzbl %r8b,%r14d
xor    %ebp,%ebp
xor    %eax,%eax
call   1030 <SDL_imageFilterMMXdetect@plt>
cmp    $0x8,%r15d
jb     11d5 <SDL_imageFilterShiftRightAndMultByByte+0xa5>
test   %rax,%rax
je     11d5 <SDL_imageFilterShiftRightAndMultByByte+0xa5>
mov    %rbx,%rdi
mov    %r13,%rsi
mov    %r15d,%edx
mov    0x4(%rsp),%ecx
mov    %r14d,%r8d
call   1040 <SDL_imageFilterShiftRightAndMultByByteMMX@plt>
test   $0x7,%r15b
je     117b <SDL_imageFilterShiftRightAndMultByByte+0x4b>
mov    %r15d,%eax
and    $0xfffffff8,%eax
add    %rax,%rbx
add    %rax,%r13
jmp    11d7 <SDL_imageFilterShiftRightAndMultByByte+0xa7>
xor    %eax,%eax
cmp    %r15d,%eax
jae    117b <SDL_imageFilterShiftRightAndMultByByte+0x4b>
mov    %eax,%ecx
not    %ecx
add    %r15d,%ecx
cmp    $0x7,%ecx
jb     120a <SDL_imageFilterShiftRightAndMultByByte+0xda>
lea    (%rbx,%rcx,1),%rdx
add    $0x1,%rdx
cmp    %rdx,%r13
jae    129f <SDL_imageFilterShiftRightAndMultByByte+0x16f>
lea    (%rcx,%r13,1),%rdx
add    $0x1,%rdx
cmp    %rdx,%rbx
jae    129f <SDL_imageFilterShiftRightAndMultByByte+0x16f>
mov    %r13,%rdi
mov    %rbx,%rdx
mov    %r15d,%ecx
sub    %eax,%ecx
mov    %eax,%esi
not    %esi
test   $0x1,%cl
je     1245 <SDL_imageFilterShiftRightAndMultByByte+0x115>
movzbl (%rdx),%ebp
mov    %r12d,%ecx
shr    %cl,%ebp
imul   %r14d,%ebp
cmp    $0xff,%ebp
mov    $0xff,%ecx
cmovl  %ebp,%ecx
mov    %cl,(%rdi)
add    $0x1,%rdx
add    $0x1,%rdi
add    $0x1,%eax
mov    $0x0,%ebp
add    %r15d,%esi
je     117b <SDL_imageFilterShiftRightAndMultByByte+0x4b>
sub    %eax,%r15d
xor    %ebp,%ebp
mov    $0xff,%eax
xor    %esi,%esi
nop
movzbl (%rdx,%rsi,1),%ebx
mov    %r12d,%ecx
shr    %cl,%ebx
imul   %r14d,%ebx
cmp    $0xff,%ebx
cmovge %eax,%ebx
mov    %bl,(%rdi,%rsi,1)
movzbl 0x1(%rdx,%rsi,1),%ebx
shr    %cl,%ebx
imul   %r14d,%ebx
cmp    $0xff,%ebx
cmovge %eax,%ebx
mov    %bl,0x1(%rdi,%rsi,1)
add    $0x2,%rsi
cmp    %esi,%r15d
jne    1260 <SDL_imageFilterShiftRightAndMultByByte+0x130>
jmp    117b <SDL_imageFilterShiftRightAndMultByByte+0x4b>
movabs $0x1fffffff0,%r9
movss  0x4(%rsp),%xmm9
movd   %r14d,%xmm8
cmp    $0xf,%ecx
jae    12c1 <SDL_imageFilterShiftRightAndMultByByte+0x191>
xor    %esi,%esi
jmp    1563 <SDL_imageFilterShiftRightAndMultByByte+0x433>
lea    0x1(%rcx),%r8
mov    %r8,%rsi
and    %r9,%rsi
pshufd $0x0,%xmm8,%xmm2
lea    -0x10(%rsi),%rdx
mov    %rdx,%rdi
shr    $0x4,%rdi
add    $0x1,%rdi
test   %rdx,%rdx
je     147c <SDL_imageFilterShiftRightAndMultByByte+0x34c>
mov    %rdi,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %ebp,%ebp
pxor   %xmm10,%xmm10
xorps  %xmm4,%xmm4
movss  %xmm9,%xmm4
movdqa 0xcf9(%rip),%xmm3
movdqu (%rbx,%rbp,1),%xmm7
movdqa %xmm7,%xmm6
punpckhbw %xmm10,%xmm6
movdqa %xmm6,%xmm1
punpckhwd %xmm10,%xmm6
punpcklbw %xmm10,%xmm7
movdqa %xmm7,%xmm0
punpcklwd %xmm10,%xmm0
punpckhwd %xmm10,%xmm7
psrld  %xmm4,%xmm7
psrld  %xmm4,%xmm0
psrld  %xmm4,%xmm6
punpcklwd %xmm10,%xmm1
psrld  %xmm4,%xmm1
pmaddwd %xmm2,%xmm1
pmaddwd %xmm2,%xmm6
pmaddwd %xmm2,%xmm0
pmaddwd %xmm2,%xmm7
movdqa %xmm3,%xmm5
pcmpgtd %xmm7,%xmm5
pand   %xmm5,%xmm7
pandn  %xmm3,%xmm5
por    %xmm7,%xmm5
movdqa %xmm3,%xmm7
pcmpgtd %xmm0,%xmm7
pand   %xmm7,%xmm0
pandn  %xmm3,%xmm7
por    %xmm0,%xmm7
packuswb %xmm5,%xmm7
movdqa %xmm3,%xmm0
pcmpgtd %xmm6,%xmm0
pand   %xmm0,%xmm6
pandn  %xmm3,%xmm0
por    %xmm6,%xmm0
movdqa %xmm3,%xmm5
pcmpgtd %xmm1,%xmm5
pand   %xmm5,%xmm1
pandn  %xmm3,%xmm5
por    %xmm1,%xmm5
packuswb %xmm0,%xmm5
packuswb %xmm5,%xmm7
movdqu %xmm7,0x0(%r13,%rbp,1)
movdqu 0x10(%rbx,%rbp,1),%xmm1
movdqa %xmm1,%xmm7
punpckhbw %xmm10,%xmm7
movdqa %xmm7,%xmm6
punpcklwd %xmm10,%xmm6
punpckhwd %xmm10,%xmm7
punpcklbw %xmm10,%xmm1
movdqa %xmm1,%xmm0
punpcklwd %xmm10,%xmm0
punpckhwd %xmm10,%xmm1
psrld  %xmm4,%xmm1
psrld  %xmm4,%xmm0
psrld  %xmm4,%xmm7
psrld  %xmm4,%xmm6
pmaddwd %xmm2,%xmm6
pmaddwd %xmm2,%xmm7
pmaddwd %xmm2,%xmm0
pmaddwd %xmm2,%xmm1
movdqa %xmm3,%xmm5
pcmpgtd %xmm1,%xmm5
pand   %xmm5,%xmm1
pandn  %xmm3,%xmm5
por    %xmm1,%xmm5
movdqa %xmm3,%xmm1
pcmpgtd %xmm0,%xmm1
pand   %xmm1,%xmm0
pandn  %xmm3,%xmm1
por    %xmm0,%xmm1
packuswb %xmm5,%xmm1
movdqa %xmm3,%xmm0
pcmpgtd %xmm7,%xmm0
pand   %xmm0,%xmm7
pandn  %xmm3,%xmm0
por    %xmm7,%xmm0
movdqa %xmm3,%xmm5
pcmpgtd %xmm6,%xmm5
pand   %xmm5,%xmm6
pandn  %xmm3,%xmm5
por    %xmm6,%xmm5
packuswb %xmm0,%xmm5
packuswb %xmm5,%xmm1
movdqu %xmm1,0x10(%r13,%rbp,1)
add    $0x20,%rbp
add    $0xfffffffffffffffe,%rdx
jne    1307 <SDL_imageFilterShiftRightAndMultByByte+0x1d7>
jmp    147e <SDL_imageFilterShiftRightAndMultByByte+0x34e>
xor    %ebp,%ebp
test   $0x1,%dil
je     1545 <SDL_imageFilterShiftRightAndMultByByte+0x415>
movdqu (%rbx,%rbp,1),%xmm5
pxor   %xmm0,%xmm0
movdqa %xmm5,%xmm4
punpckhbw %xmm0,%xmm4
movdqa %xmm4,%xmm3
punpcklwd %xmm0,%xmm3
punpckhwd %xmm0,%xmm4
punpcklbw %xmm0,%xmm5
movdqa %xmm5,%xmm6
punpcklwd %xmm0,%xmm6
punpckhwd %xmm0,%xmm5
movss  %xmm9,%xmm0
psrld  %xmm0,%xmm5
psrld  %xmm0,%xmm6
psrld  %xmm0,%xmm4
psrld  %xmm0,%xmm3
pmaddwd %xmm2,%xmm3
pmaddwd %xmm2,%xmm4
pmaddwd %xmm2,%xmm6
pmaddwd %xmm2,%xmm5
movdqa 0xb1e(%rip),%xmm0
movdqa %xmm0,%xmm1
pcmpgtd %xmm5,%xmm1
pand   %xmm1,%xmm5
pandn  %xmm0,%xmm1
por    %xmm5,%xmm1
movdqa %xmm0,%xmm2
pcmpgtd %xmm6,%xmm2
pand   %xmm2,%xmm6
pandn  %xmm0,%xmm2
por    %xmm6,%xmm2
packuswb %xmm1,%xmm2
movdqa %xmm0,%xmm1
pcmpgtd %xmm4,%xmm1
pand   %xmm1,%xmm4
pandn  %xmm0,%xmm1
por    %xmm4,%xmm1
movdqa %xmm0,%xmm4
pcmpgtd %xmm3,%xmm4
pand   %xmm4,%xmm3
pandn  %xmm0,%xmm4
por    %xmm3,%xmm4
packuswb %xmm1,%xmm4
packuswb %xmm4,%xmm2
movdqu %xmm2,0x0(%r13,%rbp,1)
xor    %ebp,%ebp
cmp    %rsi,%r8
je     117b <SDL_imageFilterShiftRightAndMultByByte+0x4b>
test   $0x8,%r8b
jne    1563 <SDL_imageFilterShiftRightAndMultByByte+0x433>
add    %esi,%eax
add    %rsi,%rbx
add    %rsi,%r13
jmp    120a <SDL_imageFilterShiftRightAndMultByByte+0xda>
add    $0x1,%rcx
add    $0x8,%r9
and    %rcx,%r9
lea    (%r9,%r13,1),%rdi
lea    (%rbx,%r9,1),%rdx
add    %r9d,%eax
pshufd $0x0,%xmm8,%xmm1
pxor   %xmm2,%xmm2
pxor   %xmm3,%xmm3
movss  %xmm9,%xmm3
movdqa 0xa6c(%rip),%xmm0
movq   (%rbx,%rsi,1),%xmm4
punpcklbw %xmm2,%xmm4
movdqa %xmm4,%xmm5
punpcklwd %xmm2,%xmm5
punpckhwd %xmm2,%xmm4
psrld  %xmm3,%xmm4
psrld  %xmm3,%xmm5
pmaddwd %xmm1,%xmm5
pmaddwd %xmm1,%xmm4
movdqa %xmm0,%xmm6
pcmpgtd %xmm4,%xmm6
pand   %xmm6,%xmm4
pandn  %xmm0,%xmm6
por    %xmm4,%xmm6
movdqa %xmm0,%xmm4
pcmpgtd %xmm5,%xmm4
pand   %xmm4,%xmm5
pandn  %xmm0,%xmm4
por    %xmm5,%xmm4
packuswb %xmm6,%xmm4
packuswb %xmm4,%xmm4
movq   %xmm4,0x0(%r13,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%r9
jne    1594 <SDL_imageFilterShiftRightAndMultByByte+0x464>
xor    %ebp,%ebp
cmp    %r9,%rcx
je     117b <SDL_imageFilterShiftRightAndMultByByte+0x4b>
jmp    1210 <SDL_imageFilterShiftRightAndMultByByte+0xe0>

LLVM IR (-O0):
define i32 @SDL_imageFilterShiftRightAndMultByByte(i8* %0, i8* %1, i32 %2, i8 zeroext %3, i8 zeroext %4) {
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i8
%11 = alloca i8
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i8*
%16 = alloca i8*
%17 = alloca i32
store i8* %0, i8** %7
store i8* %1, i8** %8
store i32 %2, i32* %9
store i8 %3, i8* %10
store i8 %4, i8* %11
%18 = load i8*, i8** %7
%19 = icmp eq i8* %18, null
br i1 %19, label %23, label %20
20: ; preds = %5
%21 = load i8*, i8** %8
%22 = icmp eq i8* %21, null
br i1 %22, label %23, label %24
23: ; preds = %20, %5
store i32 -1, i32* %6
br label %110
24: ; preds = %20
%25 = load i32, i32* %9
%26 = icmp eq i32 %25, 0
br i1 %26, label %27, label %28
27: ; preds = %24
store i32 0, i32* %6
br label %110
28: ; preds = %24
%29 = load i8, i8* %10
%30 = zext i8 %29 to i32
%31 = icmp sgt i32 %30, 8
br i1 %31, label %32, label %33
32: ; preds = %28
store i32 -1, i32* %6
br label %110
33: ; preds = %28
%34 = load i8, i8* %10
%35 = zext i8 %34 to i32
%36 = icmp eq i32 %35, 0
br i1 %36, label %37, label %46
37: ; preds = %33
%38 = load i8, i8* %11
%39 = zext i8 %38 to i32
%40 = icmp eq i32 %39, 1
br i1 %40, label %41, label %46
41: ; preds = %37
%42 = load i8*, i8** %7
%43 = load i8*, i8** %8
%44 = load i32, i32* %9
%45 = call i32 @memcpy(i8* %42, i8* %43, i32 %44)
store i32 0, i32* %6
br label %110
46: ; preds = %37, %33
%47 = call i64 (...) @SDL_imageFilterMMXdetect()
%48 = icmp ne i64 %47, 0
br i1 %48, label %49, label %75
49: ; preds = %46
%50 = load i32, i32* %9
%51 = icmp ugt i32 %50, 7
br i1 %51, label %52, label %75
52: ; preds = %49
%53 = load i8*, i8** %7
%54 = load i8*, i8** %8
%55 = load i32, i32* %9
%56 = load i8, i8* %10
%57 = load i8, i8* %11
%58 = call i32 @SDL_imageFilterShiftRightAndMultByByteMMX(i8* %53, i8* %54, i32 %55, i8 zeroext %56, i8 zeroext %57)
%59 = load i32, i32* %9
%60 = and i32 %59, 7
%61 = icmp ugt i32 %60, 0
br i1 %61, label %62, label %73
62: ; preds = %52
%63 = load i32, i32* %9
%64 = and i32 %63, -8
store i32 %64, i32* %13
%65 = load i8*, i8** %7
%66 = load i32, i32* %13
%67 = zext i32 %66 to i64
%68 = getelementptr inbounds i8, i8* %65, i64 %67
store i8* %68, i8** %15
%69 = load i8*, i8** %8
%70 = load i32, i32* %13
%71 = zext i32 %70 to i64
%72 = getelementptr inbounds i8, i8* %69, i64 %71
store i8* %72, i8** %16
br label %74
73: ; preds = %52
store i32 0, i32* %6
br label %110
74: ; preds = %62
br label %78
75: ; preds = %49, %46
store i32 0, i32* %13
%76 = load i8*, i8** %7
store i8* %76, i8** %15
%77 = load i8*, i8** %8
store i8* %77, i8** %16
br label %78
78: ; preds = %75, %74
%79 = load i8, i8* %11
%80 = zext i8 %79 to i32
store i32 %80, i32* %14
%81 = load i32, i32* %13
store i32 %81, i32* %12
br label %82
82: ; preds = %106, %78
%83 = load i32, i32* %12
%84 = load i32, i32* %9
%85 = icmp ult i32 %83, %84
br i1 %85, label %86, label %109
86: ; preds = %82
%87 = load i8*, i8** %15
%88 = load i8, i8* %87
%89 = zext i8 %88 to i32
%90 = load i8, i8* %10
%91 = zext i8 %90 to i32
%92 = ashr i32 %89, %91
%93 = load i32, i32* %14
%94 = mul nsw i32 %92, %93
store i32 %94, i32* %17
%95 = load i32, i32* %17
%96 = icmp sgt i32 %95, 255
br i1 %96, label %97, label %98
97: ; preds = %86
store i32 255, i32* %17
br label %98
98: ; preds = %97, %86
%99 = load i32, i32* %17
%100 = trunc i32 %99 to i8
%101 = load i8*, i8** %16
store i8 %100, i8* %101
%102 = load i8*, i8** %15
%103 = getelementptr inbounds i8, i8* %102, i32 1
store i8* %103, i8** %15
%104 = load i8*, i8** %16
%105 = getelementptr inbounds i8, i8* %104, i32 1
store i8* %105, i8** %16
br label %106
106: ; preds = %98
%107 = load i32, i32* %12
%108 = add i32 %107, 1
store i32 %108, i32* %12
br label %82
109: ; preds = %82
store i32 0, i32* %6
br label %110
110: ; preds = %109, %73, %41, %32, %27, %23
%111 = load i32, i32* %6
ret i32 %111
}

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