#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 *,
                                                             int, unsigned char,
                                                             unsigned char);
int SDL_imageFilterShiftRightAndMultByByte(unsigned char *Src1,
                                           unsigned char *Dest, int length,
                                           unsigned char N, unsigned char C) {
  unsigned int i, istart;
  int iC;
  unsigned char *cursrc1;
  unsigned char *curdest;
  int result;
  if ((N > 8) || (N < 1)) {
    return (-1);
  }
  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)
movzbl -0x1d(%rbp),%eax
cmp    $0x8,%eax
jg     1156 <SDL_imageFilterShiftRightAndMultByByte+0x36>
movzbl -0x1d(%rbp),%eax
cmp    $0x1,%eax
jge    1162 <SDL_imageFilterShiftRightAndMultByByte+0x42>
movl   $0xffffffff,-0x4(%rbp)
jmp    1272 <SDL_imageFilterShiftRightAndMultByByte+0x152>
mov    $0x0,%al
call   1030 <SDL_imageFilterMMXdetect@plt>
cmp    $0x0,%rax
je     11e2 <SDL_imageFilterShiftRightAndMultByByte+0xc2>
cmpl   $0x7,-0x1c(%rbp)
jle    11e2 <SDL_imageFilterShiftRightAndMultByByte+0xc2>
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
jle    11d1 <SDL_imageFilterShiftRightAndMultByByte+0xb1>
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    11dd <SDL_imageFilterShiftRightAndMultByByte+0xbd>
movl   $0x0,-0x4(%rbp)
jmp    1272 <SDL_imageFilterShiftRightAndMultByByte+0x152>
jmp    11f9 <SDL_imageFilterShiftRightAndMultByByte+0xd9>
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    126b <SDL_imageFilterShiftRightAndMultByByte+0x14b>
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    123a <SDL_imageFilterShiftRightAndMultByByte+0x11a>
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    1206 <SDL_imageFilterShiftRightAndMultByByte+0xe6>
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    %ecx,%r15d
lea    -0x9(%r15),%eax
mov    $0xffffffff,%r13d
cmp    $0xf8,%al
jb     127b <SDL_imageFilterShiftRightAndMultByByte+0x15b>
mov    %r8d,%ebx
mov    %rsi,%r14
mov    %rdi,%r12
xor    %r13d,%r13d
xor    %eax,%eax
mov    %rdx,%rbp
call   1030 <SDL_imageFilterMMXdetect@plt>
mov    %rbp,%rdx
movzbl %bl,%r8d
cmp    $0x8,%edx
jl     11a8 <SDL_imageFilterShiftRightAndMultByByte+0x88>
test   %rax,%rax
je     11a8 <SDL_imageFilterShiftRightAndMultByByte+0x88>
movzbl %r15b,%ecx
mov    %r12,%rbx
mov    %r12,%rdi
mov    %r14,%r12
mov    %r14,%rsi
mov    %r8d,%r14d
call   1040 <SDL_imageFilterShiftRightAndMultByByteMMX@plt>
mov    %rbp,%rdx
test   $0x7,%dl
je     127b <SDL_imageFilterShiftRightAndMultByByte+0x15b>
mov    %edx,%r10d
and    $0xfffffff8,%r10d
add    %r10,%rbx
add    %r10,%r12
mov    %rbx,%rcx
mov    %r14d,%r8d
cmp    %edx,%r10d
jb     11ba <SDL_imageFilterShiftRightAndMultByByte+0x9a>
jmp    127b <SDL_imageFilterShiftRightAndMultByByte+0x15b>
xor    %r10d,%r10d
mov    %r12,%rcx
mov    %r14,%r12
cmp    %edx,%r10d
jae    127b <SDL_imageFilterShiftRightAndMultByByte+0x15b>
mov    %r10d,%eax
not    %eax
add    %edx,%eax
cmp    $0x7,%eax
jb     11e8 <SDL_imageFilterShiftRightAndMultByByte+0xc8>
lea    (%rcx,%rax,1),%rsi
add    $0x1,%rsi
cmp    %rsi,%r12
jae    128d <SDL_imageFilterShiftRightAndMultByByte+0x16d>
lea    (%r12,%rax,1),%rsi
add    $0x1,%rsi
cmp    %rsi,%rcx
jae    128d <SDL_imageFilterShiftRightAndMultByByte+0x16d>
mov    %r12,%rdi
mov    %rcx,%rbx
mov    %edx,%ecx
sub    %r10d,%ecx
mov    %r10d,%eax
not    %eax
test   $0x1,%cl
je     1225 <SDL_imageFilterShiftRightAndMultByByte+0x105>
movzbl (%rbx),%esi
mov    %r15d,%ecx
shr    %cl,%esi
imul   %r8d,%esi
cmp    $0xff,%esi
mov    $0xff,%ecx
cmovl  %esi,%ecx
mov    %cl,(%rdi)
add    $0x1,%rbx
add    $0x1,%rdi
add    $0x1,%r10d
mov    $0x0,%r13d
add    %edx,%eax
je     127b <SDL_imageFilterShiftRightAndMultByByte+0x15b>
sub    %r10d,%edx
xor    %r13d,%r13d
mov    $0xff,%eax
xor    %ebp,%ebp
nopl   0x0(%rax)
movzbl (%rbx,%rbp,1),%esi
mov    %r15d,%ecx
shr    %cl,%esi
imul   %r8d,%esi
cmp    $0xff,%esi
cmovge %eax,%esi
mov    %sil,(%rdi,%rbp,1)
movzbl 0x1(%rbx,%rbp,1),%esi
shr    %cl,%esi
imul   %r8d,%esi
cmp    $0xff,%esi
cmovge %eax,%esi
mov    %sil,0x1(%rdi,%rbp,1)
add    $0x2,%rbp
cmp    %ebp,%edx
jne    1240 <SDL_imageFilterShiftRightAndMultByByte+0x120>
mov    %r13d,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movabs $0x1fffffff0,%r11
movd   %r15d,%xmm9
movd   %r8d,%xmm8
cmp    $0xf,%eax
jae    12ad <SDL_imageFilterShiftRightAndMultByByte+0x18d>
xor    %esi,%esi
jmp    155c <SDL_imageFilterShiftRightAndMultByByte+0x43c>
lea    0x1(%rax),%r14
mov    %r14,%rsi
and    %r11,%rsi
pshufd $0x0,%xmm8,%xmm2
lea    -0x10(%rsi),%rdi
mov    %rdi,%r9
shr    $0x4,%r9
add    $0x1,%r9
test   %rdi,%rdi
je     1474 <SDL_imageFilterShiftRightAndMultByByte+0x354>
mov    %r9,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %ebp,%ebp
pxor   %xmm10,%xmm10
xorps  %xmm4,%xmm4
movss  %xmm9,%xmm4
movdqa 0xd0d(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu (%rcx,%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,(%r12,%rbp,1)
movdqu 0x10(%rcx,%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(%r12,%rbp,1)
add    $0x20,%rbp
add    $0xfffffffffffffffe,%rbx
jne    1300 <SDL_imageFilterShiftRightAndMultByByte+0x1e0>
jmp    1476 <SDL_imageFilterShiftRightAndMultByByte+0x356>
xor    %ebp,%ebp
test   $0x1,%r9b
je     153c <SDL_imageFilterShiftRightAndMultByByte+0x41c>
movdqu (%rcx,%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 0xb26(%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,(%r12,%rbp,1)
xor    %r13d,%r13d
cmp    %rsi,%r14
je     127b <SDL_imageFilterShiftRightAndMultByByte+0x15b>
test   $0x8,%r14b
jne    155c <SDL_imageFilterShiftRightAndMultByByte+0x43c>
add    %esi,%r10d
add    %rsi,%rcx
add    %rsi,%r12
jmp    11e8 <SDL_imageFilterShiftRightAndMultByByte+0xc8>
add    $0x1,%rax
add    $0x8,%r11
and    %rax,%r11
lea    (%r12,%r11,1),%rdi
lea    (%rcx,%r11,1),%rbx
add    %r11d,%r10d
pshufd $0x0,%xmm8,%xmm1
pxor   %xmm2,%xmm2
pxor   %xmm3,%xmm3
movss  %xmm9,%xmm3
movdqa 0xa73(%rip),%xmm0
nopl   (%rax)
movq   (%rcx,%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,(%r12,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%r11
jne    1590 <SDL_imageFilterShiftRightAndMultByByte+0x470>
xor    %r13d,%r13d
cmp    %r11,%rax
jne    11ee <SDL_imageFilterShiftRightAndMultByByte+0xce>
jmp    127b <SDL_imageFilterShiftRightAndMultByByte+0x15b>

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* %10
%19 = zext i8 %18 to i32
%20 = icmp sgt i32 %19, 8
br i1 %20, label %25, label %21
21: ; preds = %5
%22 = load i8, i8* %10
%23 = zext i8 %22 to i32
%24 = icmp slt i32 %23, 1
br i1 %24, label %25, label %26
25: ; preds = %21, %5
store i32 -1, i32* %6
br label %90
26: ; preds = %21
%27 = call i64 (...) @SDL_imageFilterMMXdetect()
%28 = icmp ne i64 %27, 0
br i1 %28, label %29, label %55
29: ; preds = %26
%30 = load i32, i32* %9
%31 = icmp sgt i32 %30, 7
br i1 %31, label %32, label %55
32: ; preds = %29
%33 = load i8*, i8** %7
%34 = load i8*, i8** %8
%35 = load i32, i32* %9
%36 = load i8, i8* %10
%37 = load i8, i8* %11
%38 = call i32 @SDL_imageFilterShiftRightAndMultByByteMMX(i8* %33, i8* %34, i32 %35, i8 zeroext %36, i8 zeroext %37)
%39 = load i32, i32* %9
%40 = and i32 %39, 7
%41 = icmp sgt i32 %40, 0
br i1 %41, label %42, label %53
42: ; preds = %32
%43 = load i32, i32* %9
%44 = and i32 %43, -8
store i32 %44, i32* %13
%45 = load i8*, i8** %7
%46 = load i32, i32* %13
%47 = zext i32 %46 to i64
%48 = getelementptr inbounds i8, i8* %45, i64 %47
store i8* %48, i8** %15
%49 = load i8*, i8** %8
%50 = load i32, i32* %13
%51 = zext i32 %50 to i64
%52 = getelementptr inbounds i8, i8* %49, i64 %51
store i8* %52, i8** %16
br label %54
53: ; preds = %32
store i32 0, i32* %6
br label %90
54: ; preds = %42
br label %58
55: ; preds = %29, %26
store i32 0, i32* %13
%56 = load i8*, i8** %7
store i8* %56, i8** %15
%57 = load i8*, i8** %8
store i8* %57, i8** %16
br label %58
58: ; preds = %55, %54
%59 = load i8, i8* %11
%60 = zext i8 %59 to i32
store i32 %60, i32* %14
%61 = load i32, i32* %13
store i32 %61, i32* %12
br label %62
62: ; preds = %86, %58
%63 = load i32, i32* %12
%64 = load i32, i32* %9
%65 = icmp ult i32 %63, %64
br i1 %65, label %66, label %89
66: ; preds = %62
%67 = load i8*, i8** %15
%68 = load i8, i8* %67
%69 = zext i8 %68 to i32
%70 = load i8, i8* %10
%71 = zext i8 %70 to i32
%72 = ashr i32 %69, %71
%73 = load i32, i32* %14
%74 = mul nsw i32 %72, %73
store i32 %74, i32* %17
%75 = load i32, i32* %17
%76 = icmp sgt i32 %75, 255
br i1 %76, label %77, label %78
77: ; preds = %66
store i32 255, i32* %17
br label %78
78: ; preds = %77, %66
%79 = load i32, i32* %17
%80 = trunc i32 %79 to i8
%81 = load i8*, i8** %16
store i8 %80, i8* %81
%82 = load i8*, i8** %15
%83 = getelementptr inbounds i8, i8* %82, i32 1
store i8* %83, i8** %15
%84 = load i8*, i8** %16
%85 = getelementptr inbounds i8, i8* %84, i32 1
store i8* %85, i8** %16
br label %86
86: ; preds = %78
%87 = load i32, i32* %12
%88 = add i32 %87, 1
store i32 %88, i32* %12
br label %62
89: ; preds = %62
store i32 0, i32* %6
br label %90
90: ; preds = %89, %53, %25
%91 = load i32, i32* %6
ret i32 %91
}

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