#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 */
int /*<<< orphan*/ SDL_imageFilterClipToRangeMMX(unsigned char *,
                                                 unsigned char *, unsigned int,
                                                 unsigned char, unsigned char);
scalar_t__ SDL_imageFilterMMXdetect();
int /*<<< orphan*/ memcpy(unsigned char *, unsigned char *, unsigned int);
int SDL_imageFilterClipToRange(unsigned char *Src1, unsigned char *Dest,
                               unsigned int length, unsigned char Tmin,
                               unsigned char Tmax) {
  unsigned int i, istart;
  unsigned char *cursrc1;
  unsigned char *curdest;
  if ((Src1 == NULL) || (Dest == NULL))
    return (-1);
  if (length == 0)
    return (0);
  if ((Tmin == 0) && (Tmax == 25)) {
    memcpy(Src1, Dest, length);
    return (0);
  }
  if ((SDL_imageFilterMMXdetect()) && (length > 7)) {
    SDL_imageFilterClipToRangeMMX(Src1, Dest, length, Tmin, Tmax);
    if ((length & 7) > 0) {
      istart = length & 0xfffffff8;
      cursrc1 = &Src1[istart];
      curdest = &Dest[istart];
    } else {
      return (0);
    }
  } else {
    istart = 0;
    cursrc1 = Src1;
    curdest = Dest;
  }
  for (i = istart; i < length; i++) {
    if (*cursrc1 < Tmin) {
      *curdest = Tmin;
    } else if (*cursrc1 > Tmax) {
      *curdest = Tmax;
    } else {
      *curdest = *cursrc1;
    }
    cursrc1++;
    curdest++;
  }
  return (0);
}


x86 assembly (clang, -O0):
<SDL_imageFilterClipToRange>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%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_imageFilterClipToRange+0x32>
cmpq   $0x0,-0x18(%rbp)
jne    116e <SDL_imageFilterClipToRange+0x3e>
movl   $0xffffffff,-0x4(%rbp)
jmp    12e3 <SDL_imageFilterClipToRange+0x1b3>
cmpl   $0x0,-0x1c(%rbp)
jne    1184 <SDL_imageFilterClipToRange+0x54>
movl   $0x0,-0x4(%rbp)
jmp    12e3 <SDL_imageFilterClipToRange+0x1b3>
movzbl -0x1d(%rbp),%eax
cmp    $0x0,%eax
jne    11ba <SDL_imageFilterClipToRange+0x8a>
movzbl -0x1e(%rbp),%eax
cmp    $0x19,%eax
jne    11ba <SDL_imageFilterClipToRange+0x8a>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c(%rbp),%edx
call   1040 <memcpy@plt>
movl   $0x0,-0x4(%rbp)
jmp    12e3 <SDL_imageFilterClipToRange+0x1b3>
mov    $0x0,%al
call   1030 <SDL_imageFilterMMXdetect@plt>
cmp    $0x0,%rax
je     123a <SDL_imageFilterClipToRange+0x10a>
cmpl   $0x7,-0x1c(%rbp)
jbe    123a <SDL_imageFilterClipToRange+0x10a>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    -0x1d(%rbp),%al
movzbl %al,%ecx
movzbl -0x1e(%rbp),%r8d
call   1050 <SDL_imageFilterClipToRangeMMX@plt>
mov    -0x1c(%rbp),%eax
and    $0x7,%eax
cmp    $0x0,%eax
jbe    1229 <SDL_imageFilterClipToRange+0xf9>
mov    -0x1c(%rbp),%eax
and    $0xfffffff8,%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
jmp    1235 <SDL_imageFilterClipToRange+0x105>
movl   $0x0,-0x4(%rbp)
jmp    12e3 <SDL_imageFilterClipToRange+0x1b3>
jmp    1251 <SDL_imageFilterClipToRange+0x121>
movl   $0x0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    12dc <SDL_imageFilterClipToRange+0x1ac>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
movzbl -0x1d(%rbp),%ecx
cmp    %ecx,%eax
jge    1284 <SDL_imageFilterClipToRange+0x154>
mov    -0x1d(%rbp),%cl
mov    -0x38(%rbp),%rax
mov    %cl,(%rax)
jmp    12b6 <SDL_imageFilterClipToRange+0x186>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
movzbl -0x1e(%rbp),%ecx
cmp    %ecx,%eax
jle    12a5 <SDL_imageFilterClipToRange+0x175>
mov    -0x1e(%rbp),%cl
mov    -0x38(%rbp),%rax
mov    %cl,(%rax)
jmp    12b1 <SDL_imageFilterClipToRange+0x181>
mov    -0x30(%rbp),%rax
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %cl,(%rax)
jmp    12b6 <SDL_imageFilterClipToRange+0x186>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1257 <SDL_imageFilterClipToRange+0x127>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SDL_imageFilterClipToRange>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    $0xffffffff,%ebp
test   %rdi,%rdi
je     1297 <SDL_imageFilterClipToRange+0x167>
mov    %rsi,%r13
test   %rsi,%rsi
je     1297 <SDL_imageFilterClipToRange+0x167>
mov    %edx,%r15d
xor    %ebp,%ebp
test   %edx,%edx
je     1297 <SDL_imageFilterClipToRange+0x167>
mov    %ecx,%r12d
mov    %rdi,%r14
test   %r12b,%r12b
jne    1186 <SDL_imageFilterClipToRange+0x56>
cmp    $0x19,%r8b
jne    1186 <SDL_imageFilterClipToRange+0x56>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %r15d,%edx
call   1040 <memcpy@plt>
jmp    1297 <SDL_imageFilterClipToRange+0x167>
mov    %r8d,%ebx
xor    %ebp,%ebp
xor    %eax,%eax
call   1030 <SDL_imageFilterMMXdetect@plt>
cmp    $0x8,%r15d
jb     11cb <SDL_imageFilterClipToRange+0x9b>
test   %rax,%rax
je     11cb <SDL_imageFilterClipToRange+0x9b>
movzbl %r12b,%ecx
movzbl %bl,%r8d
mov    %r14,%rdi
mov    %r13,%rsi
mov    %r15d,%edx
call   1050 <SDL_imageFilterClipToRangeMMX@plt>
test   $0x7,%r15b
je     1297 <SDL_imageFilterClipToRange+0x167>
mov    %r15d,%eax
and    $0xfffffff8,%eax
add    %rax,%r14
add    %rax,%r13
jmp    11cd <SDL_imageFilterClipToRange+0x9d>
xor    %eax,%eax
mov    %ebx,%r11d
cmp    %r15d,%eax
jae    1297 <SDL_imageFilterClipToRange+0x167>
mov    %eax,%ecx
not    %ecx
add    %r15d,%ecx
cmp    $0x7,%ecx
jb     1207 <SDL_imageFilterClipToRange+0xd7>
lea    (%r14,%rcx,1),%rdx
add    $0x1,%rdx
cmp    %rdx,%r13
jae    12a8 <SDL_imageFilterClipToRange+0x178>
lea    (%rcx,%r13,1),%rdx
add    $0x1,%rdx
cmp    %rdx,%r14
jae    12a8 <SDL_imageFilterClipToRange+0x178>
mov    %r13,%r9
mov    %r14,%rbx
mov    %r15d,%edx
sub    %eax,%edx
mov    %eax,%ecx
not    %ecx
test   $0x1,%dl
je     1240 <SDL_imageFilterClipToRange+0x110>
movzbl (%rbx),%edx
cmp    %r11b,%dl
movzbl %r11b,%esi
cmovbe %edx,%esi
cmp    %r12b,%dl
movzbl %r12b,%edx
cmovae %esi,%edx
mov    %dl,(%r9)
add    $0x1,%rbx
add    $0x1,%r9
add    $0x1,%eax
mov    $0x0,%ebp
add    %r15d,%ecx
je     1297 <SDL_imageFilterClipToRange+0x167>
sub    %eax,%r15d
xor    %ebp,%ebp
movzbl %r11b,%eax
movzbl %r12b,%ecx
xor    %edx,%edx
nopl   0x0(%rax)
movzbl (%rbx,%rdx,1),%edi
cmp    %r11b,%dil
mov    %edi,%esi
cmova  %eax,%esi
cmp    %r12b,%dil
cmovb  %ecx,%esi
mov    %sil,(%r9,%rdx,1)
movzbl 0x1(%rbx,%rdx,1),%esi
cmp    %r11b,%sil
mov    %esi,%edi
cmova  %eax,%edi
cmp    %r12b,%sil
cmovb  %ecx,%edi
mov    %dil,0x1(%r9,%rdx,1)
add    $0x2,%rdx
cmp    %edx,%r15d
jne    1260 <SDL_imageFilterClipToRange+0x130>
mov    %ebp,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movabs $0x1ffffffe0,%rdx
movzbl %r12b,%r10d
movzbl %r11b,%r8d
cmp    $0x1f,%ecx
jae    12c6 <SDL_imageFilterClipToRange+0x196>
xor    %esi,%esi
jmp    1439 <SDL_imageFilterClipToRange+0x309>
lea    0x1(%rcx),%r9
mov    %r9,%rsi
and    %rdx,%rsi
movd   %r10d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
movd   %r8d,%xmm1
punpcklbw %xmm1,%xmm1
pshuflw $0x0,%xmm1,%xmm1
pshufd $0x0,%xmm1,%xmm1
lea    -0x20(%rsi),%rdi
mov    %rdi,%rbx
shr    $0x5,%rbx
add    $0x1,%rbx
test   %rdi,%rdi
je     13ce <SDL_imageFilterClipToRange+0x29e>
mov    %rbx,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %edi,%edi
movdqu (%r14,%rdi,1),%xmm2
movdqu 0x10(%r14,%rdi,1),%xmm3
movdqa %xmm2,%xmm4
pmaxub %xmm0,%xmm4
pcmpeqb %xmm2,%xmm4
movdqa %xmm3,%xmm5
pmaxub %xmm0,%xmm5
pcmpeqb %xmm3,%xmm5
pminub %xmm1,%xmm2
pminub %xmm1,%xmm3
pand   %xmm4,%xmm2
pandn  %xmm0,%xmm4
por    %xmm2,%xmm4
pand   %xmm5,%xmm3
pandn  %xmm0,%xmm5
por    %xmm3,%xmm5
movdqu %xmm4,0x0(%r13,%rdi,1)
movdqu %xmm5,0x10(%r13,%rdi,1)
movdqu 0x20(%r14,%rdi,1),%xmm2
movdqu 0x30(%r14,%rdi,1),%xmm3
movdqa %xmm2,%xmm4
pmaxub %xmm0,%xmm4
pcmpeqb %xmm2,%xmm4
movdqa %xmm3,%xmm5
pmaxub %xmm0,%xmm5
pcmpeqb %xmm3,%xmm5
pminub %xmm1,%xmm2
pminub %xmm1,%xmm3
pand   %xmm4,%xmm2
pandn  %xmm0,%xmm4
por    %xmm2,%xmm4
pand   %xmm5,%xmm3
pandn  %xmm0,%xmm5
por    %xmm3,%xmm5
movdqu %xmm4,0x20(%r13,%rdi,1)
movdqu %xmm5,0x30(%r13,%rdi,1)
add    $0x40,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1317 <SDL_imageFilterClipToRange+0x1e7>
jmp    13d0 <SDL_imageFilterClipToRange+0x2a0>
xor    %edi,%edi
test   $0x1,%bl
je     1428 <SDL_imageFilterClipToRange+0x2f8>
movdqu (%r14,%rdi,1),%xmm2
movdqu 0x10(%r14,%rdi,1),%xmm3
movdqa %xmm2,%xmm4
pmaxub %xmm0,%xmm4
pcmpeqb %xmm2,%xmm4
movdqa %xmm3,%xmm5
pmaxub %xmm0,%xmm5
pcmpeqb %xmm3,%xmm5
pminub %xmm1,%xmm2
pminub %xmm1,%xmm3
pand   %xmm4,%xmm2
pandn  %xmm0,%xmm4
por    %xmm2,%xmm4
pand   %xmm5,%xmm3
pandn  %xmm0,%xmm5
por    %xmm3,%xmm5
movdqu %xmm4,0x0(%r13,%rdi,1)
movdqu %xmm5,0x10(%r13,%rdi,1)
xor    %ebp,%ebp
cmp    %rsi,%r9
je     1297 <SDL_imageFilterClipToRange+0x167>
test   $0x18,%r9b
je     14b2 <SDL_imageFilterClipToRange+0x382>
add    $0x1,%rcx
add    $0x18,%rdx
and    %rcx,%rdx
lea    (%rdx,%r13,1),%r9
lea    (%r14,%rdx,1),%rbx
add    %edx,%eax
movd   %r10d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
movd   %r8d,%xmm1
punpcklbw %xmm1,%xmm1
pshuflw $0x0,%xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
movq   (%r14,%rsi,1),%xmm2
movdqa %xmm2,%xmm3
pmaxub %xmm0,%xmm3
pcmpeqb %xmm2,%xmm3
pminub %xmm1,%xmm2
pand   %xmm3,%xmm2
pandn  %xmm0,%xmm3
por    %xmm2,%xmm3
movq   %xmm3,0x0(%r13,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rdx
jne    1470 <SDL_imageFilterClipToRange+0x340>
xor    %ebp,%ebp
cmp    %rdx,%rcx
jne    120d <SDL_imageFilterClipToRange+0xdd>
jmp    1297 <SDL_imageFilterClipToRange+0x167>
add    %esi,%eax
add    %rsi,%r14
add    %rsi,%r13
jmp    1207 <SDL_imageFilterClipToRange+0xd7>

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

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