#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_imageFilterAddByteToHalfMMX(unsigned char *,
                                                   unsigned char *,
                                                   unsigned int, unsigned char,
                                                   unsigned char *);
scalar_t__ SDL_imageFilterMMXdetect();
int SDL_imageFilterAddByteToHalf(unsigned char *Src1, unsigned char *Dest,
                                 unsigned int length, unsigned char C) {
  static unsigned char Mask[8] = {0x7F, 0x7F, 0x7F, 0x7F,
                                  0x7F, 0x7F, 0x7F, 0x7F};
  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 ((SDL_imageFilterMMXdetect()) && (length > 7)) {
    SDL_imageFilterAddByteToHalfMMX(Src1, Dest, length, C, Mask);
    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 / 2) + iC;
    if (result > 255)
      result = 255;
    *curdest = (unsigned char)result;
    cursrc1++;
    curdest++;
  }
  return (0);
}


x86 assembly (clang, -O0):
<SDL_imageFilterAddByteToHalf>:
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     114e <SDL_imageFilterAddByteToHalf+0x2e>
cmpq   $0x0,-0x18(%rbp)
jne    115a <SDL_imageFilterAddByteToHalf+0x3a>
movl   $0xffffffff,-0x4(%rbp)
jmp    1281 <SDL_imageFilterAddByteToHalf+0x161>
cmpl   $0x0,-0x1c(%rbp)
jne    1170 <SDL_imageFilterAddByteToHalf+0x50>
movl   $0x0,-0x4(%rbp)
jmp    1281 <SDL_imageFilterAddByteToHalf+0x161>
mov    $0x0,%al
call   1030 <SDL_imageFilterMMXdetect@plt>
cmp    $0x0,%rax
je     11f0 <SDL_imageFilterAddByteToHalf+0xd0>
cmpl   $0x7,-0x1c(%rbp)
jbe    11f0 <SDL_imageFilterAddByteToHalf+0xd0>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c(%rbp),%edx
lea    0x2e93(%rip),%r8
movzbl -0x1d(%rbp),%ecx
call   1040 <SDL_imageFilterAddByteToHalfMMX@plt>
mov    -0x1c(%rbp),%eax
and    $0x7,%eax
cmp    $0x0,%eax
jbe    11df <SDL_imageFilterAddByteToHalf+0xbf>
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    11eb <SDL_imageFilterAddByteToHalf+0xcb>
movl   $0x0,-0x4(%rbp)
jmp    1281 <SDL_imageFilterAddByteToHalf+0x161>
jmp    1207 <SDL_imageFilterAddByteToHalf+0xe7>
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    127a <SDL_imageFilterAddByteToHalf+0x15a>
mov    -0x38(%rbp),%rax
movzbl (%rax),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    -0x2c(%rbp),%eax
mov    %eax,-0x44(%rbp)
cmpl   $0xff,-0x44(%rbp)
jle    1249 <SDL_imageFilterAddByteToHalf+0x129>
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    1214 <SDL_imageFilterAddByteToHalf+0xf4>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SDL_imageFilterAddByteToHalf>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    $0xffffffff,%ebx
test   %rdi,%rdi
je     1266 <SDL_imageFilterAddByteToHalf+0x146>
mov    %rsi,%r15
test   %rsi,%rsi
je     1266 <SDL_imageFilterAddByteToHalf+0x146>
mov    %edx,%r12d
test   %edx,%edx
je     11a1 <SDL_imageFilterAddByteToHalf+0x81>
mov    %ecx,%ebp
mov    %rdi,%r13
xor    %ebx,%ebx
xor    %eax,%eax
call   1030 <SDL_imageFilterMMXdetect@plt>
movzbl %bpl,%r14d
cmp    $0x8,%r12d
jb     11a8 <SDL_imageFilterAddByteToHalf+0x88>
test   %rax,%rax
je     11a8 <SDL_imageFilterAddByteToHalf+0x88>
lea    0x2ec0(%rip),%r8
mov    %r13,%rdi
mov    %r15,%rsi
mov    %r12d,%edx
mov    %r14d,%ecx
call   1040 <SDL_imageFilterAddByteToHalfMMX@plt>
test   $0x7,%r12b
je     1266 <SDL_imageFilterAddByteToHalf+0x146>
mov    %r12d,%eax
and    $0xfffffff8,%eax
add    %rax,%r13
add    %rax,%r15
cmp    %r12d,%eax
jb     11b3 <SDL_imageFilterAddByteToHalf+0x93>
jmp    1266 <SDL_imageFilterAddByteToHalf+0x146>
xor    %ebx,%ebx
jmp    1266 <SDL_imageFilterAddByteToHalf+0x146>
xor    %eax,%eax
cmp    %r12d,%eax
jae    1266 <SDL_imageFilterAddByteToHalf+0x146>
mov    %eax,%ecx
not    %ecx
add    %r12d,%ecx
cmp    $0x7,%ecx
jb     11e1 <SDL_imageFilterAddByteToHalf+0xc1>
lea    (%rcx,%r13,1),%rdx
add    $0x1,%rdx
cmp    %rdx,%r15
jae    1277 <SDL_imageFilterAddByteToHalf+0x157>
lea    (%r15,%rcx,1),%rdx
add    $0x1,%rdx
cmp    %rdx,%r13
jae    1277 <SDL_imageFilterAddByteToHalf+0x157>
mov    %r15,%rdi
mov    %r13,%rbp
mov    %r12d,%edx
sub    %eax,%edx
mov    %eax,%ecx
not    %ecx
test   $0x1,%dl
je     121a <SDL_imageFilterAddByteToHalf+0xfa>
movzbl 0x0(%rbp),%edx
shr    %edx
add    %r14d,%edx
cmp    $0xff,%edx
mov    $0xff,%esi
cmovb  %edx,%esi
mov    %sil,(%rdi)
add    $0x1,%rbp
add    $0x1,%rdi
add    $0x1,%eax
mov    $0x0,%ebx
add    %r12d,%ecx
je     1266 <SDL_imageFilterAddByteToHalf+0x146>
sub    %eax,%r12d
xor    %ebx,%ebx
mov    $0xff,%eax
xor    %ecx,%ecx
movzbl 0x0(%rbp,%rcx,1),%edx
shr    %edx
add    %r14d,%edx
cmp    $0xff,%edx
cmovae %eax,%edx
mov    %dl,(%rdi,%rcx,1)
movzbl 0x1(%rbp,%rcx,1),%edx
shr    %edx
add    %r14d,%edx
cmp    $0xff,%edx
cmovae %eax,%edx
mov    %dl,0x1(%rdi,%rcx,1)
add    $0x2,%rcx
cmp    %ecx,%r12d
jne    1230 <SDL_imageFilterAddByteToHalf+0x110>
mov    %ebx,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movabs $0x1fffffff0,%rdx
movd   %r14d,%xmm8
cmp    $0xf,%ecx
jae    1292 <SDL_imageFilterAddByteToHalf+0x172>
xor    %esi,%esi
jmp    151f <SDL_imageFilterAddByteToHalf+0x3ff>
lea    0x1(%rcx),%r8
mov    %r8,%rsi
and    %rdx,%rsi
pshufd $0x0,%xmm8,%xmm1
lea    -0x10(%rsi),%rdi
mov    %rdi,%r9
shr    $0x4,%r9
add    $0x1,%r9
test   %rdi,%rdi
je     143f <SDL_imageFilterAddByteToHalf+0x31f>
mov    %r9,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %ebp,%ebp
movdqa 0xd34(%rip),%xmm9
pxor   %xmm3,%xmm3
movdqa 0xd38(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movdqu 0x0(%r13,%rbp,1),%xmm5
psrlw  $0x1,%xmm5
pand   %xmm9,%xmm5
movdqa %xmm5,%xmm7
punpcklbw %xmm3,%xmm7
movdqa %xmm7,%xmm0
punpckhwd %xmm3,%xmm0
punpcklwd %xmm3,%xmm7
punpckhbw %xmm3,%xmm5
movdqa %xmm5,%xmm6
punpckhwd %xmm3,%xmm6
punpcklwd %xmm3,%xmm5
paddd  %xmm1,%xmm5
paddd  %xmm1,%xmm6
paddd  %xmm1,%xmm7
paddd  %xmm1,%xmm0
movdqa %xmm2,%xmm4
pcmpgtd %xmm0,%xmm4
pand   %xmm4,%xmm0
pandn  %xmm2,%xmm4
por    %xmm0,%xmm4
movdqa %xmm2,%xmm0
pcmpgtd %xmm7,%xmm0
pand   %xmm0,%xmm7
pandn  %xmm2,%xmm0
por    %xmm7,%xmm0
packuswb %xmm4,%xmm0
movdqa %xmm2,%xmm4
pcmpgtd %xmm6,%xmm4
pand   %xmm4,%xmm6
pandn  %xmm2,%xmm4
por    %xmm6,%xmm4
movdqa %xmm2,%xmm6
pcmpgtd %xmm5,%xmm6
pand   %xmm6,%xmm5
pandn  %xmm2,%xmm6
por    %xmm5,%xmm6
packuswb %xmm4,%xmm6
packuswb %xmm6,%xmm0
movdqu %xmm0,(%r15,%rbp,1)
movdqu 0x10(%r13,%rbp,1),%xmm5
psrlw  $0x1,%xmm5
pand   %xmm9,%xmm5
movdqa %xmm5,%xmm7
punpcklbw %xmm3,%xmm7
movdqa %xmm7,%xmm0
punpckhwd %xmm3,%xmm0
punpcklwd %xmm3,%xmm7
punpckhbw %xmm3,%xmm5
movdqa %xmm5,%xmm6
punpckhwd %xmm3,%xmm6
punpcklwd %xmm3,%xmm5
paddd  %xmm1,%xmm5
paddd  %xmm1,%xmm6
paddd  %xmm1,%xmm7
paddd  %xmm1,%xmm0
movdqa %xmm2,%xmm4
pcmpgtd %xmm0,%xmm4
pand   %xmm4,%xmm0
pandn  %xmm2,%xmm4
por    %xmm0,%xmm4
movdqa %xmm2,%xmm0
pcmpgtd %xmm7,%xmm0
pand   %xmm0,%xmm7
pandn  %xmm2,%xmm0
por    %xmm7,%xmm0
packuswb %xmm4,%xmm0
movdqa %xmm2,%xmm4
pcmpgtd %xmm6,%xmm4
pand   %xmm4,%xmm6
pandn  %xmm2,%xmm4
por    %xmm6,%xmm4
movdqa %xmm2,%xmm6
pcmpgtd %xmm5,%xmm6
pand   %xmm6,%xmm5
pandn  %xmm2,%xmm6
por    %xmm5,%xmm6
packuswb %xmm4,%xmm6
packuswb %xmm6,%xmm0
movdqu %xmm0,0x10(%r15,%rbp,1)
add    $0x20,%rbp
add    $0xfffffffffffffffe,%rbx
jne    12e0 <SDL_imageFilterAddByteToHalf+0x1c0>
jmp    1441 <SDL_imageFilterAddByteToHalf+0x321>
xor    %ebp,%ebp
test   $0x1,%r9b
je     1501 <SDL_imageFilterAddByteToHalf+0x3e1>
movdqu 0x0(%r13,%rbp,1),%xmm2
psrlw  $0x1,%xmm2
pand   0xba1(%rip),%xmm2
pxor   %xmm0,%xmm0
movdqa %xmm2,%xmm4
punpcklbw %xmm0,%xmm4
movdqa %xmm4,%xmm5
punpckhwd %xmm0,%xmm5
punpcklwd %xmm0,%xmm4
punpckhbw %xmm0,%xmm2
movdqa %xmm2,%xmm3
punpckhwd %xmm0,%xmm3
punpcklwd %xmm0,%xmm2
paddd  %xmm1,%xmm2
paddd  %xmm1,%xmm3
paddd  %xmm1,%xmm4
paddd  %xmm1,%xmm5
movdqa 0xb71(%rip),%xmm0
movdqa %xmm0,%xmm1
pcmpgtd %xmm5,%xmm1
pand   %xmm1,%xmm5
pandn  %xmm0,%xmm1
por    %xmm5,%xmm1
movdqa %xmm0,%xmm5
pcmpgtd %xmm4,%xmm5
pand   %xmm5,%xmm4
pandn  %xmm0,%xmm5
por    %xmm4,%xmm5
packuswb %xmm1,%xmm5
movdqa %xmm0,%xmm1
pcmpgtd %xmm3,%xmm1
pand   %xmm1,%xmm3
pandn  %xmm0,%xmm1
por    %xmm3,%xmm1
movdqa %xmm0,%xmm3
pcmpgtd %xmm2,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm0,%xmm3
por    %xmm2,%xmm3
packuswb %xmm1,%xmm3
packuswb %xmm3,%xmm5
movdqu %xmm5,(%r15,%rbp,1)
xor    %ebx,%ebx
cmp    %rsi,%r8
je     1266 <SDL_imageFilterAddByteToHalf+0x146>
test   $0x8,%r8b
jne    151f <SDL_imageFilterAddByteToHalf+0x3ff>
add    %esi,%eax
add    %rsi,%r13
add    %rsi,%r15
jmp    11e1 <SDL_imageFilterAddByteToHalf+0xc1>
add    $0x1,%rcx
add    $0x8,%rdx
and    %rcx,%rdx
lea    (%r15,%rdx,1),%rdi
lea    (%rdx,%r13,1),%rbp
add    %edx,%eax
pshufd $0x0,%xmm8,%xmm0
movdqa 0xabe(%rip),%xmm1
pxor   %xmm2,%xmm2
movdqa 0xac2(%rip),%xmm3
xchg   %ax,%ax
movq   0x0(%r13,%rsi,1),%xmm4
psrlw  $0x1,%xmm4
pand   %xmm1,%xmm4
punpcklbw %xmm2,%xmm4
movdqa %xmm4,%xmm5
punpckhwd %xmm2,%xmm5
punpcklwd %xmm2,%xmm4
paddd  %xmm0,%xmm4
paddd  %xmm0,%xmm5
movdqa %xmm3,%xmm6
pcmpgtd %xmm5,%xmm6
pand   %xmm6,%xmm5
pandn  %xmm3,%xmm6
por    %xmm5,%xmm6
movdqa %xmm3,%xmm5
pcmpgtd %xmm4,%xmm5
pand   %xmm5,%xmm4
pandn  %xmm3,%xmm5
por    %xmm4,%xmm5
packuswb %xmm6,%xmm5
packuswb %xmm5,%xmm5
movq   %xmm5,(%r15,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rdx
jne    1550 <SDL_imageFilterAddByteToHalf+0x430>
xor    %ebx,%ebx
cmp    %rdx,%rcx
jne    11e7 <SDL_imageFilterAddByteToHalf+0xc7>
jmp    1266 <SDL_imageFilterAddByteToHalf+0x146>

LLVM IR (-O0):
@SDL_imageFilterAddByteToHalf.Mask = internal global [8 x i8] c"\7F\7F\7F\7F\7F\7F\7F\7F"
define i32 @SDL_imageFilterAddByteToHalf(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 %87
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 %87
26: ; preds = %22
%27 = call i64 (...) @SDL_imageFilterMMXdetect()
%28 = icmp ne i64 %27, 0
br i1 %28, label %29, label %54
29: ; preds = %26
%30 = load i32, i32* %8
%31 = icmp ugt i32 %30, 7
br i1 %31, label %32, label %54
32: ; preds = %29
%33 = load i8*, i8** %6
%34 = load i8*, i8** %7
%35 = load i32, i32* %8
%36 = load i8, i8* %9
%37 = call i32 @SDL_imageFilterAddByteToHalfMMX(i8* %33, i8* %34, i32 %35, i8 zeroext %36, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @SDL_imageFilterAddByteToHalf.Mask, i64 0, i64 0))
%38 = load i32, i32* %8
%39 = and i32 %38, 7
%40 = icmp ugt i32 %39, 0
br i1 %40, label %41, label %52
41: ; preds = %32
%42 = load i32, i32* %8
%43 = and i32 %42, -8
store i32 %43, i32* %11
%44 = load i8*, i8** %6
%45 = load i32, i32* %11
%46 = zext i32 %45 to i64
%47 = getelementptr inbounds i8, i8* %44, i64 %46
store i8* %47, i8** %13
%48 = load i8*, i8** %7
%49 = load i32, i32* %11
%50 = zext i32 %49 to i64
%51 = getelementptr inbounds i8, i8* %48, i64 %50
store i8* %51, i8** %14
br label %53
52: ; preds = %32
store i32 0, i32* %5
br label %87
53: ; preds = %41
br label %57
54: ; preds = %29, %26
store i32 0, i32* %11
%55 = load i8*, i8** %6
store i8* %55, i8** %13
%56 = load i8*, i8** %7
store i8* %56, i8** %14
br label %57
57: ; preds = %54, %53
%58 = load i8, i8* %9
%59 = zext i8 %58 to i32
store i32 %59, i32* %12
%60 = load i32, i32* %11
store i32 %60, i32* %10
br label %61
61: ; preds = %83, %57
%62 = load i32, i32* %10
%63 = load i32, i32* %8
%64 = icmp ult i32 %62, %63
br i1 %64, label %65, label %86
65: ; preds = %61
%66 = load i8*, i8** %13
%67 = load i8, i8* %66
%68 = zext i8 %67 to i32
%69 = sdiv i32 %68, 2
%70 = load i32, i32* %12
%71 = add nsw i32 %69, %70
store i32 %71, i32* %15
%72 = load i32, i32* %15
%73 = icmp sgt i32 %72, 255
br i1 %73, label %74, label %75
74: ; preds = %65
store i32 255, i32* %15
br label %75
75: ; preds = %74, %65
%76 = load i32, i32* %15
%77 = trunc i32 %76 to i8
%78 = load i8*, i8** %14
store i8 %77, i8* %78
%79 = load i8*, i8** %13
%80 = getelementptr inbounds i8, i8* %79, i32 1
store i8* %80, i8** %13
%81 = load i8*, i8** %14
%82 = getelementptr inbounds i8, i8* %81, i32 1
store i8* %82, i8** %14
br label %83
83: ; preds = %75
%84 = load i32, i32* %10
%85 = add i32 %84, 1
store i32 %85, i32* %10
br label %61
86: ; preds = %61
store i32 0, i32* %5
br label %87
87: ; preds = %86, %52, %25, %21
%88 = load i32, i32* %5
ret i32 %88
}

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