#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_imageFilterBinarizeUsingThresholdMMX(unsigned char *,
                                                            unsigned char *,
                                                            unsigned int,
                                                            unsigned char);
scalar_t__ SDL_imageFilterMMXdetect();
int /*<<< orphan*/ memset(unsigned char *, int, unsigned int);
int SDL_imageFilterBinarizeUsingThreshold(unsigned char *Src1,
                                          unsigned char *Dest,
                                          unsigned int length,
                                          unsigned char T) {
  unsigned int i, istart;
  unsigned char *cursrc1;
  unsigned char *curdest;
  if ((Src1 == NULL) || (Dest == NULL))
    return (-1);
  if (length == 0)
    return (0);
  if (T == 0) {
    memset(Dest, 255, length);
    return (0);
  }
  if ((SDL_imageFilterMMXdetect()) && (length > 7)) {
    SDL_imageFilterBinarizeUsingThresholdMMX(Src1, Dest, length, T);
    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++) {
    *curdest = ((unsigned char)*cursrc1 >= T) ? 255 : 0;
    cursrc1++;
    curdest++;
  }
  return (0);
}


x86 assembly (clang, -O0):
<SDL_imageFilterBinarizeUsingThreshold>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%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_imageFilterBinarizeUsingThreshold+0x2e>
cmpq   $0x0,-0x18(%rbp)
jne    116a <SDL_imageFilterBinarizeUsingThreshold+0x3a>
movl   $0xffffffff,-0x4(%rbp)
jmp    1298 <SDL_imageFilterBinarizeUsingThreshold+0x168>
cmpl   $0x0,-0x1c(%rbp)
jne    1180 <SDL_imageFilterBinarizeUsingThreshold+0x50>
movl   $0x0,-0x4(%rbp)
jmp    1298 <SDL_imageFilterBinarizeUsingThreshold+0x168>
movzbl -0x1d(%rbp),%eax
cmp    $0x0,%eax
jne    11aa <SDL_imageFilterBinarizeUsingThreshold+0x7a>
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%edx
mov    $0xff,%esi
call   1050 <memset@plt>
movl   $0x0,-0x4(%rbp)
jmp    1298 <SDL_imageFilterBinarizeUsingThreshold+0x168>
mov    $0x0,%al
call   1040 <SDL_imageFilterMMXdetect@plt>
cmp    $0x0,%rax
je     1223 <SDL_imageFilterBinarizeUsingThreshold+0xf3>
cmpl   $0x7,-0x1c(%rbp)
jbe    1223 <SDL_imageFilterBinarizeUsingThreshold+0xf3>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c(%rbp),%edx
movzbl -0x1d(%rbp),%ecx
call   1030 <SDL_imageFilterBinarizeUsingThresholdMMX@plt>
mov    -0x1c(%rbp),%eax
and    $0x7,%eax
cmp    $0x0,%eax
jbe    1212 <SDL_imageFilterBinarizeUsingThreshold+0xe2>
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    121e <SDL_imageFilterBinarizeUsingThreshold+0xee>
movl   $0x0,-0x4(%rbp)
jmp    1298 <SDL_imageFilterBinarizeUsingThreshold+0x168>
jmp    123a <SDL_imageFilterBinarizeUsingThreshold+0x10a>
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    1291 <SDL_imageFilterBinarizeUsingThreshold+0x161>
mov    -0x30(%rbp),%rax
movzbl (%rax),%edx
movzbl -0x1d(%rbp),%esi
xor    %eax,%eax
mov    $0xff,%ecx
cmp    %esi,%edx
cmovge %ecx,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %cl,(%rax)
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    1240 <SDL_imageFilterBinarizeUsingThreshold+0x110>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SDL_imageFilterBinarizeUsingThreshold>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    $0xffffffff,%ebx
test   %rdi,%rdi
je     12ab <SDL_imageFilterBinarizeUsingThreshold+0x17b>
mov    %rsi,%r15
test   %rsi,%rsi
je     12ab <SDL_imageFilterBinarizeUsingThreshold+0x17b>
mov    %edx,%r14d
xor    %ebx,%ebx
test   %edx,%edx
je     12ab <SDL_imageFilterBinarizeUsingThreshold+0x17b>
mov    %ecx,%ebp
test   %bpl,%bpl
je     11b0 <SDL_imageFilterBinarizeUsingThreshold+0x80>
mov    %rdi,%r12
xor    %ebx,%ebx
xor    %eax,%eax
call   1040 <SDL_imageFilterMMXdetect@plt>
cmp    $0x8,%r14d
jb     11c5 <SDL_imageFilterBinarizeUsingThreshold+0x95>
test   %rax,%rax
je     11c5 <SDL_imageFilterBinarizeUsingThreshold+0x95>
movzbl %bpl,%ecx
mov    %r12,%rdi
mov    %r15,%rsi
mov    %r14d,%edx
call   1030 <SDL_imageFilterBinarizeUsingThresholdMMX@plt>
test   $0x7,%r14b
je     12ab <SDL_imageFilterBinarizeUsingThreshold+0x17b>
mov    %r14d,%r8d
and    $0xfffffff8,%r8d
add    %r8,%r12
add    %r8,%r15
cmp    %r14d,%r8d
jb     11d1 <SDL_imageFilterBinarizeUsingThreshold+0xa1>
jmp    12ab <SDL_imageFilterBinarizeUsingThreshold+0x17b>
mov    %r15,%rdi
mov    $0xff,%esi
mov    %r14d,%edx
call   1050 <memset@plt>
jmp    12ab <SDL_imageFilterBinarizeUsingThreshold+0x17b>
xor    %r8d,%r8d
cmp    %r14d,%r8d
jae    12ab <SDL_imageFilterBinarizeUsingThreshold+0x17b>
mov    %r8d,%ecx
not    %ecx
add    %r14d,%ecx
cmp    $0x7,%ecx
jb     1200 <SDL_imageFilterBinarizeUsingThreshold+0xd0>
lea    (%r12,%rcx,1),%rax
add    $0x1,%rax
cmp    %rax,%r15
jae    12b6 <SDL_imageFilterBinarizeUsingThreshold+0x186>
lea    (%r15,%rcx,1),%rax
add    $0x1,%rax
cmp    %rax,%r12
jae    12b6 <SDL_imageFilterBinarizeUsingThreshold+0x186>
mov    %r15,%rdx
mov    %r12,%rdi
mov    %r14d,%ecx
sub    %r8d,%ecx
mov    %r8d,%eax
not    %eax
add    %r14d,%eax
and    $0x3,%ecx
je     1240 <SDL_imageFilterBinarizeUsingThreshold+0x110>
neg    %ecx
xor    %esi,%esi
nopl   (%rax)
cmp    %bpl,(%rdi)
mov    $0x0,%ebx
adc    $0xff,%bl
mov    %bl,(%rdx)
add    $0x1,%rdi
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
cmp    %esi,%ecx
jne    1220 <SDL_imageFilterBinarizeUsingThreshold+0xf0>
sub    %esi,%r8d
mov    $0x0,%ebx
cmp    $0x3,%eax
jb     12ab <SDL_imageFilterBinarizeUsingThreshold+0x17b>
sub    %r8d,%r14d
xor    %ebx,%ebx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    %bpl,(%rdi,%rax,1)
mov    $0x0,%ecx
adc    $0xff,%cl
mov    %cl,(%rdx,%rax,1)
cmp    %bpl,0x1(%rdi,%rax,1)
mov    $0x0,%ecx
adc    $0xff,%cl
mov    %cl,0x1(%rdx,%rax,1)
cmp    %bpl,0x2(%rdi,%rax,1)
mov    $0x0,%ecx
adc    $0xff,%cl
mov    %cl,0x2(%rdx,%rax,1)
cmp    %bpl,0x3(%rdi,%rax,1)
mov    $0x0,%ecx
adc    $0xff,%cl
mov    %cl,0x3(%rdx,%rax,1)
add    $0x4,%rax
cmp    %eax,%r14d
jne    1260 <SDL_imageFilterBinarizeUsingThreshold+0x130>
mov    %ebx,%eax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
movabs $0x1ffffffe0,%rsi
movzbl %bpl,%r9d
cmp    $0x1f,%ecx
jae    12d0 <SDL_imageFilterBinarizeUsingThreshold+0x1a0>
xor    %eax,%eax
jmp    13c2 <SDL_imageFilterBinarizeUsingThreshold+0x292>
lea    0x1(%rcx),%r10
mov    %r10,%rax
and    %rsi,%rax
movd   %r9d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x20(%rax),%rdi
mov    %rdi,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
test   %rdi,%rdi
je     137c <SDL_imageFilterBinarizeUsingThreshold+0x24c>
mov    %rdx,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %edi,%edi
movdqu (%r12,%rdi,1),%xmm1
movdqu 0x10(%r12,%rdi,1),%xmm2
movdqa %xmm1,%xmm3
pmaxub %xmm0,%xmm3
pcmpeqb %xmm1,%xmm3
movdqa %xmm2,%xmm1
pmaxub %xmm0,%xmm1
pcmpeqb %xmm2,%xmm1
movdqu %xmm3,(%r15,%rdi,1)
movdqu %xmm1,0x10(%r15,%rdi,1)
movdqu 0x20(%r12,%rdi,1),%xmm1
movdqu 0x30(%r12,%rdi,1),%xmm2
movdqa %xmm1,%xmm3
pmaxub %xmm0,%xmm3
pcmpeqb %xmm1,%xmm3
movdqa %xmm2,%xmm1
pmaxub %xmm0,%xmm1
pcmpeqb %xmm2,%xmm1
movdqu %xmm3,0x20(%r15,%rdi,1)
movdqu %xmm1,0x30(%r15,%rdi,1)
add    $0x40,%rdi
add    $0xfffffffffffffffe,%rbx
jne    130a <SDL_imageFilterBinarizeUsingThreshold+0x1da>
jmp    137e <SDL_imageFilterBinarizeUsingThreshold+0x24e>
xor    %edi,%edi
test   $0x1,%dl
je     13b1 <SDL_imageFilterBinarizeUsingThreshold+0x281>
movdqu (%r12,%rdi,1),%xmm1
movdqu 0x10(%r12,%rdi,1),%xmm2
movdqa %xmm1,%xmm3
pmaxub %xmm0,%xmm3
pcmpeqb %xmm1,%xmm3
pmaxub %xmm2,%xmm0
pcmpeqb %xmm2,%xmm0
movdqu %xmm3,(%r15,%rdi,1)
movdqu %xmm0,0x10(%r15,%rdi,1)
xor    %ebx,%ebx
cmp    %rax,%r10
je     12ab <SDL_imageFilterBinarizeUsingThreshold+0x17b>
test   $0x18,%r10b
je     1421 <SDL_imageFilterBinarizeUsingThreshold+0x2f1>
add    $0x1,%rcx
add    $0x18,%rsi
and    %rcx,%rsi
lea    (%r15,%rsi,1),%rdx
lea    (%r12,%rsi,1),%rdi
add    %esi,%r8d
movd   %r9d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
movq   (%r12,%rax,1),%xmm1
movdqa %xmm1,%xmm2
pmaxub %xmm0,%xmm2
pcmpeqb %xmm1,%xmm2
movq   %xmm2,(%r15,%rax,1)
add    $0x8,%rax
cmp    %rax,%rsi
jne    13f0 <SDL_imageFilterBinarizeUsingThreshold+0x2c0>
xor    %ebx,%ebx
cmp    %rsi,%rcx
jne    1206 <SDL_imageFilterBinarizeUsingThreshold+0xd6>
jmp    12ab <SDL_imageFilterBinarizeUsingThreshold+0x17b>
add    %eax,%r8d
add    %rax,%r12
add    %rax,%r15
jmp    1200 <SDL_imageFilterBinarizeUsingThreshold+0xd0>

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

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