#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 *,
                                                            int, unsigned char);
scalar_t__ SDL_imageFilterMMXdetect();
int SDL_imageFilterBinarizeUsingThreshold(unsigned char *Src1,
                                          unsigned char *Dest, int length,
                                          unsigned char T) {
  unsigned int i, istart;
  unsigned char *cursrc1;
  unsigned char *curdest;
  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)
mov    $0x0,%al
call   1040 <SDL_imageFilterMMXdetect@plt>
cmp    $0x0,%rax
je     11b1 <SDL_imageFilterBinarizeUsingThreshold+0x91>
cmpl   $0x7,-0x1c(%rbp)
jle    11b1 <SDL_imageFilterBinarizeUsingThreshold+0x91>
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
jle    11a0 <SDL_imageFilterBinarizeUsingThreshold+0x80>
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    11ac <SDL_imageFilterBinarizeUsingThreshold+0x8c>
movl   $0x0,-0x4(%rbp)
jmp    1226 <SDL_imageFilterBinarizeUsingThreshold+0x106>
jmp    11c8 <SDL_imageFilterBinarizeUsingThreshold+0xa8>
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    121f <SDL_imageFilterBinarizeUsingThreshold+0xff>
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    11ce <SDL_imageFilterBinarizeUsingThreshold+0xae>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SDL_imageFilterBinarizeUsingThreshold>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %ecx,%ebx
mov    %edx,%r14d
mov    %rsi,%r12
mov    %rdi,%r15
xor    %r13d,%r13d
xor    %eax,%eax
call   1040 <SDL_imageFilterMMXdetect@plt>
cmp    $0x8,%r14d
jl     1171 <SDL_imageFilterBinarizeUsingThreshold+0x51>
test   %rax,%rax
je     1171 <SDL_imageFilterBinarizeUsingThreshold+0x51>
movzbl %bl,%ecx
mov    %r15,%rdi
mov    %r12,%rsi
mov    %r14d,%edx
call   1030 <SDL_imageFilterBinarizeUsingThresholdMMX@plt>
test   $0x7,%r14b
je     1247 <SDL_imageFilterBinarizeUsingThreshold+0x127>
mov    %r14d,%r13d
and    $0xfffffff8,%r13d
add    %r13,%r15
add    %r13,%r12
cmp    %r14d,%r13d
jae    1247 <SDL_imageFilterBinarizeUsingThreshold+0x127>
mov    %r13d,%eax
not    %eax
add    %r14d,%eax
cmp    $0x7,%eax
jb     11a9 <SDL_imageFilterBinarizeUsingThreshold+0x89>
lea    (%r15,%rax,1),%rcx
add    $0x1,%rcx
cmp    %rcx,%r12
jae    1253 <SDL_imageFilterBinarizeUsingThreshold+0x133>
lea    (%r12,%rax,1),%rcx
add    $0x1,%rcx
cmp    %rcx,%r15
jae    1253 <SDL_imageFilterBinarizeUsingThreshold+0x133>
mov    %r12,%rcx
mov    %r15,%rsi
mov    %r14d,%edx
sub    %r13d,%edx
mov    %r13d,%r8d
not    %r8d
add    %r14d,%r8d
and    $0x3,%edx
je     11ee <SDL_imageFilterBinarizeUsingThreshold+0xce>
neg    %edx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
cmp    %bl,(%rsi)
mov    $0x0,%eax
adc    $0xff,%al
mov    %al,(%rcx)
add    $0x1,%rsi
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
cmp    %edi,%edx
jne    11d0 <SDL_imageFilterBinarizeUsingThreshold+0xb0>
sub    %edi,%r13d
cmp    $0x3,%r8d
jb     1247 <SDL_imageFilterBinarizeUsingThreshold+0x127>
sub    %r13d,%r14d
xor    %eax,%eax
nopl   0x0(%rax)
cmp    %bl,(%rsi,%rax,1)
mov    $0x0,%edx
adc    $0xff,%dl
mov    %dl,(%rcx,%rax,1)
cmp    %bl,0x1(%rsi,%rax,1)
mov    $0x0,%edx
adc    $0xff,%dl
mov    %dl,0x1(%rcx,%rax,1)
cmp    %bl,0x2(%rsi,%rax,1)
mov    $0x0,%edx
adc    $0xff,%dl
mov    %dl,0x2(%rcx,%rax,1)
cmp    %bl,0x3(%rsi,%rax,1)
mov    $0x0,%edx
adc    $0xff,%dl
mov    %dl,0x3(%rcx,%rax,1)
add    $0x4,%rax
cmp    %eax,%r14d
jne    1200 <SDL_imageFilterBinarizeUsingThreshold+0xe0>
xor    %eax,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret
movabs $0x1ffffffe0,%rdx
movzbl %bl,%r8d
cmp    $0x1f,%eax
jae    126d <SDL_imageFilterBinarizeUsingThreshold+0x14d>
xor    %edi,%edi
jmp    1363 <SDL_imageFilterBinarizeUsingThreshold+0x243>
lea    0x1(%rax),%r9
mov    %r9,%rdi
and    %rdx,%rdi
movd   %r8d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x20(%rdi),%rcx
mov    %rcx,%r10
shr    $0x5,%r10
add    $0x1,%r10
test   %rcx,%rcx
je     13bf <SDL_imageFilterBinarizeUsingThreshold+0x29f>
mov    %r10,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movdqu (%r15,%rsi,1),%xmm1
movdqu 0x10(%r15,%rsi,1),%xmm2
movdqa %xmm1,%xmm3
pmaxub %xmm0,%xmm3
pcmpeqb %xmm1,%xmm3
movdqa %xmm2,%xmm1
pmaxub %xmm0,%xmm1
pcmpeqb %xmm2,%xmm1
movdqu %xmm3,(%r12,%rsi,1)
movdqu %xmm1,0x10(%r12,%rsi,1)
movdqu 0x20(%r15,%rsi,1),%xmm1
movdqu 0x30(%r15,%rsi,1),%xmm2
movdqa %xmm1,%xmm3
pmaxub %xmm0,%xmm3
pcmpeqb %xmm1,%xmm3
movdqa %xmm2,%xmm1
pmaxub %xmm0,%xmm1
pcmpeqb %xmm2,%xmm1
movdqu %xmm3,0x20(%r12,%rsi,1)
movdqu %xmm1,0x30(%r12,%rsi,1)
add    $0x40,%rsi
add    $0xfffffffffffffffe,%rcx
jne    12b0 <SDL_imageFilterBinarizeUsingThreshold+0x190>
test   $0x1,%r10b
je     1354 <SDL_imageFilterBinarizeUsingThreshold+0x234>
movdqu (%r15,%rsi,1),%xmm1
movdqu 0x10(%r15,%rsi,1),%xmm2
movdqa %xmm1,%xmm3
pmaxub %xmm0,%xmm3
pcmpeqb %xmm1,%xmm3
pmaxub %xmm2,%xmm0
pcmpeqb %xmm2,%xmm0
movdqu %xmm3,(%r12,%rsi,1)
movdqu %xmm0,0x10(%r12,%rsi,1)
cmp    %rdi,%r9
je     1247 <SDL_imageFilterBinarizeUsingThreshold+0x127>
test   $0x18,%r9b
je     13cd <SDL_imageFilterBinarizeUsingThreshold+0x2ad>
add    $0x1,%rax
add    $0x18,%rdx
and    %rax,%rdx
lea    (%r12,%rdx,1),%rcx
lea    (%r15,%rdx,1),%rsi
add    %edx,%r13d
movd   %r8d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movq   (%r15,%rdi,1),%xmm1
movdqa %xmm1,%xmm2
pmaxub %xmm0,%xmm2
pcmpeqb %xmm1,%xmm2
movq   %xmm2,(%r12,%rdi,1)
add    $0x8,%rdi
cmp    %rdi,%rdx
jne    1390 <SDL_imageFilterBinarizeUsingThreshold+0x270>
cmp    %rdx,%rax
jne    11af <SDL_imageFilterBinarizeUsingThreshold+0x8f>
jmp    1247 <SDL_imageFilterBinarizeUsingThreshold+0x127>
xor    %esi,%esi
test   $0x1,%r10b
jne    1326 <SDL_imageFilterBinarizeUsingThreshold+0x206>
jmp    1354 <SDL_imageFilterBinarizeUsingThreshold+0x234>
add    %edi,%r13d
add    %rdi,%r15
add    %rdi,%r12
jmp    11a9 <SDL_imageFilterBinarizeUsingThreshold+0x89>

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 = call i64 (...) @SDL_imageFilterMMXdetect()
%15 = icmp ne i64 %14, 0
br i1 %15, label %16, label %41
16: ; preds = %4
%17 = load i32, i32* %8
%18 = icmp sgt i32 %17, 7
br i1 %18, label %19, label %41
19: ; preds = %16
%20 = load i8*, i8** %6
%21 = load i8*, i8** %7
%22 = load i32, i32* %8
%23 = load i8, i8* %9
%24 = call i32 @SDL_imageFilterBinarizeUsingThresholdMMX(i8* %20, i8* %21, i32 %22, i8 zeroext %23)
%25 = load i32, i32* %8
%26 = and i32 %25, 7
%27 = icmp sgt i32 %26, 0
br i1 %27, label %28, label %39
28: ; preds = %19
%29 = load i32, i32* %8
%30 = and i32 %29, -8
store i32 %30, i32* %11
%31 = load i8*, i8** %6
%32 = load i32, i32* %11
%33 = zext i32 %32 to i64
%34 = getelementptr inbounds i8, i8* %31, i64 %33
store i8* %34, i8** %12
%35 = load i8*, i8** %7
%36 = load i32, i32* %11
%37 = zext i32 %36 to i64
%38 = getelementptr inbounds i8, i8* %35, i64 %37
store i8* %38, i8** %13
br label %40
39: ; preds = %19
store i32 0, i32* %5
br label %69
40: ; preds = %28
br label %44
41: ; preds = %16, %4
store i32 0, i32* %11
%42 = load i8*, i8** %6
store i8* %42, i8** %12
%43 = load i8*, i8** %7
store i8* %43, i8** %13
br label %44
44: ; preds = %41, %40
%45 = load i32, i32* %11
store i32 %45, i32* %10
br label %46
46: ; preds = %65, %44
%47 = load i32, i32* %10
%48 = load i32, i32* %8
%49 = icmp ult i32 %47, %48
br i1 %49, label %50, label %68
50: ; preds = %46
%51 = load i8*, i8** %12
%52 = load i8, i8* %51
%53 = zext i8 %52 to i32
%54 = load i8, i8* %9
%55 = zext i8 %54 to i32
%56 = icmp sge i32 %53, %55
%57 = zext i1 %56 to i64
%58 = select i1 %56, i32 255, i32 0
%59 = trunc i32 %58 to i8
%60 = load i8*, i8** %13
store i8 %59, i8* %60
%61 = load i8*, i8** %12
%62 = getelementptr inbounds i8, i8* %61, i32 1
store i8* %62, i8** %12
%63 = load i8*, i8** %13
%64 = getelementptr inbounds i8, i8* %63, i32 1
store i8* %64, i8** %13
br label %65
65: ; preds = %50
%66 = load i32, i32* %10
%67 = add i32 %66, 1
store i32 %67, i32* %10
br label %46
68: ; preds = %46
store i32 0, i32* %5
br label %69
69: ; preds = %68, %39
%70 = load i32, i32* %5
ret i32 %70
}

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