#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_imageFilterSubByteMMX(unsigned char *, unsigned char *,
                                             unsigned int, unsigned char);
int /*<<< orphan*/ memcpy(unsigned char *, unsigned char *, unsigned int);
int SDL_imageFilterSubByte(unsigned char *Src1, unsigned char *Dest,
                           unsigned int length, 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 (C == 0) {
    memcpy(Src1, Dest, length);
    return (0);
  }
  if ((SDL_imageFilterMMXdetect()) && (length > 7)) {
    SDL_imageFilterSubByteMMX(Src1, Dest, length, 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 - iC;
    if (result < 0)
      result = 0;
    *curdest = (unsigned char)result;
    cursrc1++;
    curdest++;
  }
  return (0);
}


x86 assembly (clang, -O0):
<SDL_imageFilterSubByte>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %cl,%al
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %al,-0x1d(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     115e <SDL_imageFilterSubByte+0x2e>
cmpq   $0x0,-0x18(%rbp)
jne    116a <SDL_imageFilterSubByte+0x3a>
movl   $0xffffffff,-0x4(%rbp)
jmp    12a8 <SDL_imageFilterSubByte+0x178>
cmpl   $0x0,-0x1c(%rbp)
jne    1180 <SDL_imageFilterSubByte+0x50>
movl   $0x0,-0x4(%rbp)
jmp    12a8 <SDL_imageFilterSubByte+0x178>
movzbl -0x1d(%rbp),%eax
cmp    $0x0,%eax
jne    11a9 <SDL_imageFilterSubByte+0x79>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c(%rbp),%edx
call   1040 <memcpy@plt>
movl   $0x0,-0x4(%rbp)
jmp    12a8 <SDL_imageFilterSubByte+0x178>
mov    $0x0,%al
call   1030 <SDL_imageFilterMMXdetect@plt>
cmp    $0x0,%rax
je     1222 <SDL_imageFilterSubByte+0xf2>
cmpl   $0x7,-0x1c(%rbp)
jbe    1222 <SDL_imageFilterSubByte+0xf2>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c(%rbp),%edx
movzbl -0x1d(%rbp),%ecx
call   1050 <SDL_imageFilterSubByteMMX@plt>
mov    -0x1c(%rbp),%eax
and    $0x7,%eax
cmp    $0x0,%eax
jbe    1211 <SDL_imageFilterSubByte+0xe1>
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    121d <SDL_imageFilterSubByte+0xed>
movl   $0x0,-0x4(%rbp)
jmp    12a8 <SDL_imageFilterSubByte+0x178>
jmp    1239 <SDL_imageFilterSubByte+0x109>
movl   $0x0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x40(%rbp)
movzbl -0x1d(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    12a1 <SDL_imageFilterSubByte+0x171>
mov    -0x38(%rbp),%rax
movzbl (%rax),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jge    1270 <SDL_imageFilterSubByte+0x140>
movl   $0x0,-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    1246 <SDL_imageFilterSubByte+0x116>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SDL_imageFilterSubByte>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    $0xffffffff,%ebx
test   %rdi,%rdi
je     12a7 <SDL_imageFilterSubByte+0x177>
mov    %rsi,%r15
test   %rsi,%rsi
je     12a7 <SDL_imageFilterSubByte+0x177>
mov    %edx,%r14d
xor    %ebx,%ebx
test   %edx,%edx
je     12a7 <SDL_imageFilterSubByte+0x177>
mov    %rdi,%r12
test   %cl,%cl
je     11ae <SDL_imageFilterSubByte+0x7e>
movzbl %cl,%ebp
xor    %ebx,%ebx
xor    %eax,%eax
call   1030 <SDL_imageFilterMMXdetect@plt>
cmp    $0x8,%r14d
jb     11c1 <SDL_imageFilterSubByte+0x91>
test   %rax,%rax
je     11c1 <SDL_imageFilterSubByte+0x91>
mov    %r12,%rdi
mov    %r15,%rsi
mov    %r14d,%edx
mov    %ebp,%ecx
call   1050 <SDL_imageFilterSubByteMMX@plt>
test   $0x7,%r14b
je     12a7 <SDL_imageFilterSubByte+0x177>
mov    %r14d,%r10d
and    $0xfffffff8,%r10d
add    %r10,%r12
add    %r10,%r15
cmp    %r14d,%r10d
jb     11cd <SDL_imageFilterSubByte+0x9d>
jmp    12a7 <SDL_imageFilterSubByte+0x177>
mov    %r12,%rdi
mov    %r15,%rsi
mov    %r14d,%edx
call   1040 <memcpy@plt>
jmp    12a7 <SDL_imageFilterSubByte+0x177>
xor    %r10d,%r10d
cmp    %r14d,%r10d
jae    12a7 <SDL_imageFilterSubByte+0x177>
mov    %r10d,%ecx
not    %ecx
add    %r14d,%ecx
cmp    $0x7,%ecx
jb     11fc <SDL_imageFilterSubByte+0xcc>
lea    (%r12,%rcx,1),%rax
add    $0x1,%rax
cmp    %rax,%r15
jae    12b2 <SDL_imageFilterSubByte+0x182>
lea    (%r15,%rcx,1),%rax
add    $0x1,%rax
cmp    %rax,%r12
jae    12b2 <SDL_imageFilterSubByte+0x182>
mov    %r15,%rdi
mov    %r12,%rdx
mov    %r14d,%esi
sub    %r10d,%esi
mov    %r10d,%r8d
not    %r8d
add    %r14d,%r8d
and    $0x3,%esi
je     123f <SDL_imageFilterSubByte+0x10f>
neg    %esi
xor    %eax,%eax
xor    %ebx,%ebx
nopl   0x0(%rax)
movzbl (%rdx),%ecx
sub    %ebp,%ecx
test   %ecx,%ecx
cmovle %eax,%ecx
mov    %cl,(%rdi)
add    $0x1,%rdx
add    $0x1,%rdi
add    $0xffffffffffffffff,%rbx
cmp    %ebx,%esi
jne    1220 <SDL_imageFilterSubByte+0xf0>
sub    %ebx,%r10d
mov    $0x0,%ebx
cmp    $0x3,%r8d
jb     12a7 <SDL_imageFilterSubByte+0x177>
sub    %r10d,%r14d
xor    %ebx,%ebx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rdx,%rax,1),%ecx
sub    %ebp,%ecx
test   %ecx,%ecx
cmovle %ebx,%ecx
mov    %cl,(%rdi,%rax,1)
movzbl 0x1(%rdx,%rax,1),%ecx
sub    %ebp,%ecx
test   %ecx,%ecx
cmovle %ebx,%ecx
mov    %cl,0x1(%rdi,%rax,1)
movzbl 0x2(%rdx,%rax,1),%ecx
sub    %ebp,%ecx
test   %ecx,%ecx
cmovle %ebx,%ecx
mov    %cl,0x2(%rdi,%rax,1)
movzbl 0x3(%rdx,%rax,1),%ecx
sub    %ebp,%ecx
test   %ecx,%ecx
cmovle %ebx,%ecx
mov    %cl,0x3(%rdi,%rax,1)
add    $0x4,%rax
cmp    %eax,%r14d
jne    1260 <SDL_imageFilterSubByte+0x130>
mov    %ebx,%eax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
movabs $0x1fffffff0,%r8
movd   %ebp,%xmm8
cmp    $0xf,%ecx
jae    12cd <SDL_imageFilterSubByte+0x19d>
xor    %esi,%esi
jmp    1524 <SDL_imageFilterSubByte+0x3f4>
lea    0x1(%rcx),%r9
mov    %r9,%rsi
and    %r8,%rsi
pshufd $0x0,%xmm8,%xmm10
lea    -0x10(%rsi),%rax
mov    %rax,%rdi
shr    $0x4,%rdi
add    $0x1,%rdi
test   %rax,%rax
je     145a <SDL_imageFilterSubByte+0x32a>
mov    %rdi,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %ebx,%ebx
pxor   %xmm11,%xmm11
movdqa 0xcf4(%rip),%xmm9
movdqu (%r12,%rbx,1),%xmm7
movdqa %xmm7,%xmm5
punpcklbw %xmm11,%xmm5
movdqa %xmm5,%xmm4
punpcklwd %xmm11,%xmm4
punpckhwd %xmm11,%xmm5
punpckhbw %xmm11,%xmm7
movdqa %xmm7,%xmm6
punpcklwd %xmm11,%xmm6
punpckhwd %xmm11,%xmm7
psubd  %xmm10,%xmm7
psubd  %xmm10,%xmm6
psubd  %xmm10,%xmm5
psubd  %xmm10,%xmm4
movdqa %xmm4,%xmm0
pcmpgtd %xmm11,%xmm0
movdqa %xmm5,%xmm3
pcmpgtd %xmm11,%xmm3
movdqa %xmm6,%xmm1
pcmpgtd %xmm11,%xmm1
movdqa %xmm7,%xmm2
pcmpgtd %xmm11,%xmm2
pand   %xmm9,%xmm7
pand   %xmm2,%xmm7
pand   %xmm9,%xmm6
pand   %xmm1,%xmm6
packuswb %xmm7,%xmm6
pand   %xmm9,%xmm5
pand   %xmm3,%xmm5
pand   %xmm9,%xmm4
pand   %xmm0,%xmm4
packuswb %xmm5,%xmm4
packuswb %xmm6,%xmm4
movdqu %xmm4,(%r15,%rbx,1)
movdqu 0x10(%r12,%rbx,1),%xmm7
movdqa %xmm7,%xmm5
punpcklbw %xmm11,%xmm5
movdqa %xmm5,%xmm4
punpcklwd %xmm11,%xmm4
punpckhwd %xmm11,%xmm5
punpckhbw %xmm11,%xmm7
movdqa %xmm7,%xmm6
punpcklwd %xmm11,%xmm6
punpckhwd %xmm11,%xmm7
psubd  %xmm10,%xmm7
psubd  %xmm10,%xmm6
psubd  %xmm10,%xmm5
psubd  %xmm10,%xmm4
movdqa %xmm4,%xmm0
pcmpgtd %xmm11,%xmm0
movdqa %xmm5,%xmm1
pcmpgtd %xmm11,%xmm1
movdqa %xmm6,%xmm2
pcmpgtd %xmm11,%xmm2
movdqa %xmm7,%xmm3
pcmpgtd %xmm11,%xmm3
pand   %xmm9,%xmm7
pand   %xmm3,%xmm7
pand   %xmm9,%xmm6
pand   %xmm2,%xmm6
packuswb %xmm7,%xmm6
pand   %xmm9,%xmm5
pand   %xmm1,%xmm5
pand   %xmm9,%xmm4
pand   %xmm0,%xmm4
packuswb %xmm5,%xmm4
packuswb %xmm6,%xmm4
movdqu %xmm4,0x10(%r15,%rbx,1)
add    $0x20,%rbx
add    $0xfffffffffffffffe,%rdx
jne    130c <SDL_imageFilterSubByte+0x1dc>
jmp    145c <SDL_imageFilterSubByte+0x32c>
xor    %ebx,%ebx
test   $0x1,%dil
je     1505 <SDL_imageFilterSubByte+0x3d5>
movdqu (%r12,%rbx,1),%xmm5
pxor   %xmm0,%xmm0
movdqa %xmm5,%xmm3
punpcklbw %xmm0,%xmm3
movdqa %xmm3,%xmm2
punpcklwd %xmm0,%xmm2
punpckhwd %xmm0,%xmm3
punpckhbw %xmm0,%xmm5
movdqa %xmm5,%xmm4
punpcklwd %xmm0,%xmm4
punpckhwd %xmm0,%xmm5
psubd  %xmm10,%xmm5
psubd  %xmm10,%xmm4
psubd  %xmm10,%xmm3
psubd  %xmm10,%xmm2
movdqa %xmm2,%xmm9
pcmpgtd %xmm0,%xmm9
movdqa %xmm3,%xmm6
pcmpgtd %xmm0,%xmm6
movdqa %xmm4,%xmm7
pcmpgtd %xmm0,%xmm7
movdqa %xmm5,%xmm1
pcmpgtd %xmm0,%xmm1
movdqa 0xb2e(%rip),%xmm0
pand   %xmm0,%xmm5
pand   %xmm1,%xmm5
pand   %xmm0,%xmm4
pand   %xmm7,%xmm4
packuswb %xmm5,%xmm4
pand   %xmm0,%xmm3
pand   %xmm6,%xmm3
pand   %xmm0,%xmm2
pand   %xmm9,%xmm2
packuswb %xmm3,%xmm2
packuswb %xmm4,%xmm2
movdqu %xmm2,(%r15,%rbx,1)
xor    %ebx,%ebx
cmp    %rsi,%r9
je     12a7 <SDL_imageFilterSubByte+0x177>
test   $0x8,%r9b
jne    1524 <SDL_imageFilterSubByte+0x3f4>
add    %esi,%r10d
add    %rsi,%r12
add    %rsi,%r15
jmp    11fc <SDL_imageFilterSubByte+0xcc>
add    $0x1,%rcx
add    $0x8,%r8
and    %rcx,%r8
lea    (%r15,%r8,1),%rdi
lea    (%r12,%r8,1),%rdx
add    %r8d,%r10d
pshufd $0x0,%xmm8,%xmm0
pxor   %xmm1,%xmm1
movdqa 0xab4(%rip),%xmm2
nopl   0x0(%rax)
movq   (%r12,%rsi,1),%xmm3
punpcklbw %xmm1,%xmm3
movdqa %xmm3,%xmm4
punpcklwd %xmm1,%xmm4
punpckhwd %xmm1,%xmm3
psubd  %xmm0,%xmm3
psubd  %xmm0,%xmm4
movdqa %xmm4,%xmm5
pcmpgtd %xmm1,%xmm5
movdqa %xmm3,%xmm6
pcmpgtd %xmm1,%xmm6
pand   %xmm2,%xmm3
pand   %xmm6,%xmm3
pand   %xmm2,%xmm4
pand   %xmm5,%xmm4
packuswb %xmm3,%xmm4
packuswb %xmm4,%xmm4
movq   %xmm4,(%r15,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%r8
jne    1550 <SDL_imageFilterSubByte+0x420>
xor    %ebx,%ebx
cmp    %r8,%rcx
jne    1202 <SDL_imageFilterSubByte+0xd2>
jmp    12a7 <SDL_imageFilterSubByte+0x177>

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

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