#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 */
char *malloc(int);
int /*<<< orphan*/ printf(char *, char *, char);
int stringLength_p(char *);
char *strrchr_p(char *searchStr, int charInt) {
  printf("searchString = %s \t searchChar = %c \n", searchStr, (char)charInt);
  char *start = searchStr;
  int searchLength = stringLength_p(searchStr);
  int index = 0;
  int numOccurences = 0;
  while (index < searchLength) {
    if (*searchStr != (char)charInt) {
      index++;
      searchStr++;
    } else {
      numOccurences++;
      index++;
      searchStr++;
    }
  }
  if (numOccurences == 0) {
    return NULL;
  }
  index = 0;
  int count = 0;
  searchStr = start;
  while (index < searchLength) {
    if (*searchStr != (char)charInt) {
      index++;
      searchStr++;
    } else {
      count++;
      if (count != numOccurences) {
        index++;
        searchStr++;
      }
    }
    if (count == numOccurences) {
      break;
    }
  }
  if (index == searchLength) {
    return NULL;
  }
  char *result = malloc((searchLength - index) * sizeof(char));
  int index2 = 0;
  while (index < searchLength) {
    result[index2] = *searchStr;
    index++;
    index2++;
    searchStr++;
  }
  result[index2] = '\0';
  return result;
}


x86 assembly (clang, -O0):
<strrchr_p>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    -0x10(%rbp),%rsi
mov    -0x14(%rbp),%eax
lea    0xeb3(%rip),%rdi
movsbl %al,%edx
call   1030 <printf@plt>
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rdi
call   1040 <stringLength_p@plt>
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11d5 <strrchr_p+0xa5>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
mov    -0x14(%rbp),%ecx
movsbl %cl,%ecx
cmp    %ecx,%eax
je     11b2 <strrchr_p+0x82>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    11d0 <strrchr_p+0xa0>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1177 <strrchr_p+0x47>
cmpl   $0x0,-0x2c(%rbp)
jne    11ec <strrchr_p+0xbc>
movq   $0x0,-0x8(%rbp)
jmp    130d <strrchr_p+0x1dd>
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1282 <strrchr_p+0x152>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
mov    -0x14(%rbp),%ecx
movsbl %cl,%ecx
cmp    %ecx,%eax
je     123d <strrchr_p+0x10d>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    126c <strrchr_p+0x13c>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
je     1267 <strrchr_p+0x137>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    126c <strrchr_p+0x13c>
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jne    127d <strrchr_p+0x14d>
jmp    1282 <strrchr_p+0x152>
jmp    1202 <strrchr_p+0xd2>
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jne    129b <strrchr_p+0x16b>
movq   $0x0,-0x8(%rbp)
jmp    130d <strrchr_p+0x1dd>
mov    -0x24(%rbp),%eax
sub    -0x28(%rbp),%eax
cltq
shl    $0x0,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12f9 <strrchr_p+0x1c9>
mov    -0x10(%rbp),%rax
mov    (%rax),%dl
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    12b9 <strrchr_p+0x189>
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<strrchr_p>:
push   %rbp
push   %r15
push   %r14
push   %rbx
push   %rax
mov    %esi,%r15d
mov    %rdi,%rbx
movsbl %r15b,%edx
lea    0xeb8(%rip),%rdi
mov    %rbx,%rsi
call   1030 <printf@plt>
mov    %rbx,%rdi
call   1040 <stringLength_p@plt>
mov    %eax,%r14d
xor    %eax,%eax
test   %r14d,%r14d
jle    13ce <strrchr_p+0x29e>
movsbl %r15b,%r8d
lea    -0x1(%r14),%esi
mov    $0x0,%edx
mov    %rbx,%rdi
cmp    $0x7,%esi
jb     1295 <strrchr_p+0x165>
add    $0x1,%rsi
mov    %rsi,%rdx
and    $0xfffffffffffffff8,%rdx
movd   %r8d,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rdx),%rax
mov    %rax,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rax,%rax
je     13ad <strrchr_p+0x27d>
mov    %rbp,%rax
and    $0xfffffffffffffffe,%rax
pxor   %xmm1,%xmm1
xor    %edi,%edi
pxor   %xmm2,%xmm2
nopl   (%rax)
movd   (%rbx,%rdi,1),%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
movd   0x4(%rbx,%rdi,1),%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
psrad  $0x18,%xmm3
psrad  $0x18,%xmm4
pcmpeqd %xmm0,%xmm3
psubd  %xmm3,%xmm1
pcmpeqd %xmm0,%xmm4
psubd  %xmm4,%xmm2
movd   0x8(%rbx,%rdi,1),%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
movd   0xc(%rbx,%rdi,1),%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
psrad  $0x18,%xmm3
psrad  $0x18,%xmm4
pcmpeqd %xmm0,%xmm3
psubd  %xmm3,%xmm1
pcmpeqd %xmm0,%xmm4
psubd  %xmm4,%xmm2
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rax
jne    11c0 <strrchr_p+0x90>
test   $0x1,%bpl
je     1270 <strrchr_p+0x140>
movd   (%rbx,%rdi,1),%xmm3
movd   0x4(%rbx,%rdi,1),%xmm4
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
psrad  $0x18,%xmm3
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
psrad  $0x18,%xmm4
pcmpeqd %xmm0,%xmm3
psubd  %xmm3,%xmm1
pcmpeqd %xmm0,%xmm4
psubd  %xmm4,%xmm2
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%eax
cmp    %rdx,%rsi
je     12b6 <strrchr_p+0x186>
mov    %rdx,%rdi
add    %rbx,%rdi
mov    %r14d,%esi
sub    %edx,%esi
xor    %edx,%edx
nopl   0x0(%rax)
movsbl (%rdi,%rdx,1),%ebp
xor    %ecx,%ecx
cmp    %ebp,%r8d
sete   %cl
add    %ecx,%eax
add    $0x1,%rdx
cmp    %edx,%esi
jne    12a0 <strrchr_p+0x170>
xor    %ecx,%ecx
test   %eax,%eax
je     12f6 <strrchr_p+0x1c6>
movsbl %r15b,%edx
xor    %ebp,%ebp
jmp    12d8 <strrchr_p+0x1a8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbp
cmp    %eax,%ecx
je     12ec <strrchr_p+0x1bc>
cmp    %r14d,%ebp
jge    12ec <strrchr_p+0x1bc>
movsbl (%rbx,%rbp,1),%esi
cmp    %esi,%edx
jne    12d0 <strrchr_p+0x1a0>
add    $0x1,%ecx
cmp    %eax,%ecx
jne    12d0 <strrchr_p+0x1a0>
add    %rbp,%rbx
mov    %r14d,%edi
sub    %ebp,%edi
jne    12fd <strrchr_p+0x1cd>
xor    %eax,%eax
jmp    13ce <strrchr_p+0x29e>
call   1050 <malloc@plt>
sub    %ebp,%r14d
jle    13c6 <strrchr_p+0x296>
mov    %r14d,%r8d
cmp    $0x8,%r14d
jb     132e <strrchr_p+0x1fe>
lea    (%rbx,%r8,1),%rcx
cmp    %rcx,%rax
jae    13d9 <strrchr_p+0x2a9>
lea    (%rax,%r8,1),%rcx
cmp    %rcx,%rbx
jae    13d9 <strrchr_p+0x2a9>
xor    %edx,%edx
mov    %rbx,%rsi
mov    %rdx,%rdi
not    %rdi
add    %r8,%rdi
mov    %r8,%rcx
and    $0x3,%rcx
je     1364 <strrchr_p+0x234>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rsi),%ebx
mov    %bl,(%rax,%rdx,1)
add    $0x1,%rdx
add    $0x1,%rsi
add    $0xffffffffffffffff,%rcx
jne    1350 <strrchr_p+0x220>
cmp    $0x3,%rdi
jb     13c9 <strrchr_p+0x299>
mov    %r8,%rcx
sub    %rdx,%rcx
add    %rax,%rdx
add    $0x3,%rdx
xor    %edi,%edi
nopl   0x0(%rax)
movzbl (%rsi,%rdi,1),%ebx
mov    %bl,-0x3(%rdx,%rdi,1)
movzbl 0x1(%rsi,%rdi,1),%ebx
mov    %bl,-0x2(%rdx,%rdi,1)
movzbl 0x2(%rsi,%rdi,1),%ebx
mov    %bl,-0x1(%rdx,%rdi,1)
movzbl 0x3(%rsi,%rdi,1),%ebx
mov    %bl,(%rdx,%rdi,1)
add    $0x4,%rdi
cmp    %rdi,%rcx
jne    1380 <strrchr_p+0x250>
jmp    13c9 <strrchr_p+0x299>
pxor   %xmm1,%xmm1
xor    %edi,%edi
pxor   %xmm2,%xmm2
test   $0x1,%bpl
jne    123b <strrchr_p+0x10b>
jmp    1270 <strrchr_p+0x140>
xor    %r8d,%r8d
movb   $0x0,(%rax,%r8,1)
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0x20,%r14d
jae    13e6 <strrchr_p+0x2b6>
xor    %edx,%edx
jmp    14be <strrchr_p+0x38e>
mov    %r8d,%edx
and    $0xffffffe0,%edx
lea    -0x20(%rdx),%rcx
mov    %rcx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x60,%rcx
jae    140a <strrchr_p+0x2da>
xor    %ebp,%ebp
jmp    146c <strrchr_p+0x33c>
and    $0xfffffffffffffffc,%rdi
xor    %ebp,%ebp
movups (%rbx,%rbp,1),%xmm0
movups 0x10(%rbx,%rbp,1),%xmm1
movups %xmm0,(%rax,%rbp,1)
movups %xmm1,0x10(%rax,%rbp,1)
movups 0x20(%rbx,%rbp,1),%xmm0
movups 0x30(%rbx,%rbp,1),%xmm1
movups %xmm0,0x20(%rax,%rbp,1)
movups %xmm1,0x30(%rax,%rbp,1)
movups 0x40(%rbx,%rbp,1),%xmm0
movups 0x50(%rbx,%rbp,1),%xmm1
movups %xmm0,0x40(%rax,%rbp,1)
movups %xmm1,0x50(%rax,%rbp,1)
movdqu 0x60(%rbx,%rbp,1),%xmm0
movdqu 0x70(%rbx,%rbp,1),%xmm1
movdqu %xmm0,0x60(%rax,%rbp,1)
movdqu %xmm1,0x70(%rax,%rbp,1)
sub    $0xffffffffffffff80,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1410 <strrchr_p+0x2e0>
test   %rsi,%rsi
je     14af <strrchr_p+0x37f>
lea    (%rax,%rbp,1),%rcx
add    $0x10,%rcx
lea    (%rbx,%rbp,1),%rdi
add    $0x10,%rdi
shl    $0x5,%rsi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rdi,%rbp,1),%xmm0
movdqu (%rdi,%rbp,1),%xmm1
movdqu %xmm0,-0x10(%rcx,%rbp,1)
movdqu %xmm1,(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rsi
jne    1490 <strrchr_p+0x360>
cmp    %r8,%rdx
je     13c9 <strrchr_p+0x299>
test   $0x18,%r8b
je     14ef <strrchr_p+0x3bf>
mov    %rdx,%rcx
mov    %r8d,%edx
and    $0xfffffff8,%edx
lea    (%rbx,%rdx,1),%rsi
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rcx,1),%rdi
mov    %rdi,(%rax,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rdx
jne    14d0 <strrchr_p+0x3a0>
cmp    %r8,%rdx
jne    1333 <strrchr_p+0x203>
jmp    13c9 <strrchr_p+0x299>
add    %rdx,%rbx
jmp    1330 <strrchr_p+0x200>

LLVM IR (-O0):
@.str = [38 x i8] c"searchString = %s \09 searchChar = %c \0A\00"
define i8* @strrchr_p(i8* %0, i32 %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i8*
%12 = alloca i32
store i8* %0, i8** %4
store i32 %1, i32* %5
%13 = load i8*, i8** %4
%14 = load i32, i32* %5
%15 = trunc i32 %14 to i8
%16 = call i32 @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str, i64 0, i64 0), i8* %13, i8 signext %15)
%17 = load i8*, i8** %4
store i8* %17, i8** %6
%18 = load i8*, i8** %4
%19 = call i32 @stringLength_p(i8* %18)
store i32 %19, i32* %7
store i32 0, i32* %8
store i32 0, i32* %9
br label %20
20: ; preds = %44, %2
%21 = load i32, i32* %8
%22 = load i32, i32* %7
%23 = icmp slt i32 %21, %22
br i1 %23, label %24, label %45
24: ; preds = %20
%25 = load i8*, i8** %4
%26 = load i8, i8* %25
%27 = sext i8 %26 to i32
%28 = load i32, i32* %5
%29 = trunc i32 %28 to i8
%30 = sext i8 %29 to i32
%31 = icmp ne i32 %27, %30
br i1 %31, label %32, label %37
32: ; preds = %24
%33 = load i32, i32* %8
%34 = add nsw i32 %33, 1
store i32 %34, i32* %8
%35 = load i8*, i8** %4
%36 = getelementptr inbounds i8, i8* %35, i32 1
store i8* %36, i8** %4
br label %44
37: ; preds = %24
%38 = load i32, i32* %9
%39 = add nsw i32 %38, 1
store i32 %39, i32* %9
%40 = load i32, i32* %8
%41 = add nsw i32 %40, 1
store i32 %41, i32* %8
%42 = load i8*, i8** %4
%43 = getelementptr inbounds i8, i8* %42, i32 1
store i8* %43, i8** %4
br label %44
44: ; preds = %37, %32
br label %20
45: ; preds = %20
%46 = load i32, i32* %9
%47 = icmp eq i32 %46, 0
br i1 %47, label %48, label %49
48: ; preds = %45
store i8* null, i8** %3
br label %122
49: ; preds = %45
store i32 0, i32* %8
store i32 0, i32* %10
%50 = load i8*, i8** %6
store i8* %50, i8** %4
br label %51
51: ; preds = %85, %49
%52 = load i32, i32* %8
%53 = load i32, i32* %7
%54 = icmp slt i32 %52, %53
br i1 %54, label %55, label %86
55: ; preds = %51
%56 = load i8*, i8** %4
%57 = load i8, i8* %56
%58 = sext i8 %57 to i32
%59 = load i32, i32* %5
%60 = trunc i32 %59 to i8
%61 = sext i8 %60 to i32
%62 = icmp ne i32 %58, %61
br i1 %62, label %63, label %68
63: ; preds = %55
%64 = load i32, i32* %8
%65 = add nsw i32 %64, 1
store i32 %65, i32* %8
%66 = load i8*, i8** %4
%67 = getelementptr inbounds i8, i8* %66, i32 1
store i8* %67, i8** %4
br label %80
68: ; preds = %55
%69 = load i32, i32* %10
%70 = add nsw i32 %69, 1
store i32 %70, i32* %10
%71 = load i32, i32* %10
%72 = load i32, i32* %9
%73 = icmp ne i32 %71, %72
br i1 %73, label %74, label %79
74: ; preds = %68
%75 = load i32, i32* %8
%76 = add nsw i32 %75, 1
store i32 %76, i32* %8
%77 = load i8*, i8** %4
%78 = getelementptr inbounds i8, i8* %77, i32 1
store i8* %78, i8** %4
br label %79
79: ; preds = %74, %68
br label %80
80: ; preds = %79, %63
%81 = load i32, i32* %10
%82 = load i32, i32* %9
%83 = icmp eq i32 %81, %82
br i1 %83, label %84, label %85
84: ; preds = %80
br label %86
85: ; preds = %80
br label %51
86: ; preds = %84, %51
%87 = load i32, i32* %8
%88 = load i32, i32* %7
%89 = icmp eq i32 %87, %88
br i1 %89, label %90, label %91
90: ; preds = %86
store i8* null, i8** %3
br label %122
91: ; preds = %86
%92 = load i32, i32* %7
%93 = load i32, i32* %8
%94 = sub nsw i32 %92, %93
%95 = sext i32 %94 to i64
%96 = mul i64 %95, 1
%97 = trunc i64 %96 to i32
%98 = call i8* @malloc(i32 %97)
store i8* %98, i8** %11
store i32 0, i32* %12
br label %99
99: ; preds = %103, %91
%100 = load i32, i32* %8
%101 = load i32, i32* %7
%102 = icmp slt i32 %100, %101
br i1 %102, label %103, label %116
103: ; preds = %99
%104 = load i8*, i8** %4
%105 = load i8, i8* %104
%106 = load i8*, i8** %11
%107 = load i32, i32* %12
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds i8, i8* %106, i64 %108
store i8 %105, i8* %109
%110 = load i32, i32* %8
%111 = add nsw i32 %110, 1
store i32 %111, i32* %8
%112 = load i32, i32* %12
%113 = add nsw i32 %112, 1
store i32 %113, i32* %12
%114 = load i8*, i8** %4
%115 = getelementptr inbounds i8, i8* %114, i32 1
store i8* %115, i8** %4
br label %99
116: ; preds = %99
%117 = load i8*, i8** %11
%118 = load i32, i32* %12
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds i8, i8* %117, i64 %119
store i8 0, i8* %120
%121 = load i8*, i8** %11
store i8* %121, i8** %3
br label %122
122: ; preds = %116, %90, %48
%123 = load i8*, i8** %3
ret i8* %123
}

LLVM IR (-O2):
@.str = [38 x i8] c"searchString = %s \09 searchChar = %c \0A\00"
define noalias i8* @strrchr_p(i8* %0, i32 %1) {
%3 = trunc i32 %1 to i8
%4 = tail call i32 @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str, i64 0, i64 0), i8* %0, i8 signext %3)
%5 = tail call i32 @stringLength_p(i8* %0)
%6 = icmp sgt i32 %5, 0
br i1 %6, label %7, label %296
7: ; preds = %2
%8 = shl i32 %1, 24
%9 = ashr exact i32 %8, 24
%10 = add i32 %5, -1
%11 = zext i32 %10 to i64
%12 = add nuw nsw i64 %11, 1
%13 = icmp ult i32 %10, 7
br i1 %13, label %94, label %14
14: ; preds = %7
%15 = and i64 %12, 8589934584
%16 = trunc i64 %15 to i32
%17 = getelementptr i8, i8* %0, i64 %15
%18 = insertelement <4 x i32> poison, i32 %9, i64 0
%19 = shufflevector <4 x i32> %18, <4 x i32> poison, <4 x i32> zeroinitializer
%20 = insertelement <4 x i32> poison, i32 %9, i64 0
%21 = shufflevector <4 x i32> %20, <4 x i32> poison, <4 x i32> zeroinitializer
%22 = add nsw i64 %15, -8
%23 = lshr exact i64 %22, 3
%24 = add nuw nsw i64 %23, 1
%25 = and i64 %24, 1
%26 = icmp eq i64 %22, 0
br i1 %26, label %66, label %27
27: ; preds = %14
%28 = and i64 %24, 4611686018427387902
br label %29
29: ; preds = %29, %27
%30 = phi i64 [ 0, %27 ], [ %63, %29 ]
%31 = phi <4 x i32> [ zeroinitializer, %27 ], [ %61, %29 ]
%32 = phi <4 x i32> [ zeroinitializer, %27 ], [ %62, %29 ]
%33 = phi i64 [ 0, %27 ], [ %64, %29 ]
%34 = getelementptr i8, i8* %0, i64 %30
%35 = bitcast i8* %34 to <4 x i8>*
%36 = load <4 x i8>, <4 x i8>* %35
%37 = getelementptr i8, i8* %34, i64 4
%38 = bitcast i8* %37 to <4 x i8>*
%39 = load <4 x i8>, <4 x i8>* %38
%40 = sext <4 x i8> %36 to <4 x i32>
%41 = sext <4 x i8> %39 to <4 x i32>
%42 = icmp eq <4 x i32> %19, %40
%43 = icmp eq <4 x i32> %21, %41
%44 = zext <4 x i1> %42 to <4 x i32>
%45 = zext <4 x i1> %43 to <4 x i32>
%46 = add <4 x i32> %31, %44
%47 = add <4 x i32> %32, %45
%48 = or i64 %30, 8
%49 = getelementptr i8, i8* %0, i64 %48
%50 = bitcast i8* %49 to <4 x i8>*
%51 = load <4 x i8>, <4 x i8>* %50
%52 = getelementptr i8, i8* %49, i64 4
%53 = bitcast i8* %52 to <4 x i8>*
%54 = load <4 x i8>, <4 x i8>* %53
%55 = sext <4 x i8> %51 to <4 x i32>
%56 = sext <4 x i8> %54 to <4 x i32>
%57 = icmp eq <4 x i32> %19, %55
%58 = icmp eq <4 x i32> %21, %56
%59 = zext <4 x i1> %57 to <4 x i32>
%60 = zext <4 x i1> %58 to <4 x i32>
%61 = add <4 x i32> %46, %59
%62 = add <4 x i32> %47, %60
%63 = add nuw i64 %30, 16
%64 = add i64 %33, 2
%65 = icmp eq i64 %64, %28
br i1 %65, label %66, label %29
66: ; preds = %29, %14
%67 = phi <4 x i32> [ undef, %14 ], [ %61, %29 ]
%68 = phi <4 x i32> [ undef, %14 ], [ %62, %29 ]
%69 = phi i64 [ 0, %14 ], [ %63, %29 ]
%70 = phi <4 x i32> [ zeroinitializer, %14 ], [ %61, %29 ]
%71 = phi <4 x i32> [ zeroinitializer, %14 ], [ %62, %29 ]
%72 = icmp eq i64 %25, 0
br i1 %72, label %88, label %73
73: ; preds = %66
%74 = getelementptr i8, i8* %0, i64 %69
%75 = bitcast i8* %74 to <4 x i8>*
%76 = load <4 x i8>, <4 x i8>* %75
%77 = getelementptr i8, i8* %74, i64 4
%78 = bitcast i8* %77 to <4 x i8>*
%79 = load <4 x i8>, <4 x i8>* %78
%80 = sext <4 x i8> %76 to <4 x i32>
%81 = sext <4 x i8> %79 to <4 x i32>
%82 = icmp eq <4 x i32> %19, %80
%83 = icmp eq <4 x i32> %21, %81
%84 = zext <4 x i1> %82 to <4 x i32>
%85 = zext <4 x i1> %83 to <4 x i32>
%86 = add <4 x i32> %70, %84
%87 = add <4 x i32> %71, %85
br label %88
88: ; preds = %66, %73
%89 = phi <4 x i32> [ %67, %66 ], [ %86, %73 ]
%90 = phi <4 x i32> [ %68, %66 ], [ %87, %73 ]
%91 = add <4 x i32> %90, %89
%92 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %91)
%93 = icmp eq i64 %12, %15
br i1 %93, label %110, label %94
94: ; preds = %7, %88
%95 = phi i32 [ 0, %7 ], [ %92, %88 ]
%96 = phi i32 [ 0, %7 ], [ %16, %88 ]
%97 = phi i8* [ %0, %7 ], [ %17, %88 ]
br label %98
98: ; preds = %94, %98
%99 = phi i32 [ %106, %98 ], [ %95, %94 ]
%100 = phi i32 [ %108, %98 ], [ %96, %94 ]
%101 = phi i8* [ %107, %98 ], [ %97, %94 ]
%102 = load i8, i8* %101
%103 = sext i8 %102 to i32
%104 = icmp eq i32 %9, %103
%105 = zext i1 %104 to i32
%106 = add nuw nsw i32 %99, %105
%107 = getelementptr inbounds i8, i8* %101, i64 1
%108 = add nuw nsw i32 %100, 1
%109 = icmp eq i32 %108, %5
br i1 %109, label %110, label %98
110: ; preds = %98, %88
%111 = phi i32 [ %92, %88 ], [ %106, %98 ]
%112 = icmp eq i32 %111, 0
br i1 %112, label %296, label %113
113: ; preds = %110
%114 = shl i32 %1, 24
%115 = ashr exact i32 %114, 24
br label %116
116: ; preds = %113, %128
%117 = phi i8* [ %131, %128 ], [ %0, %113 ]
%118 = phi i32 [ %130, %128 ], [ 0, %113 ]
%119 = phi i32 [ %129, %128 ], [ 0, %113 ]
%120 = icmp slt i32 %118, %5
br i1 %120, label %121, label %133
121: ; preds = %116
%122 = load i8, i8* %117
%123 = sext i8 %122 to i32
%124 = icmp eq i32 %115, %123
br i1 %124, label %125, label %128
125: ; preds = %121
%126 = add nsw i32 %119, 1
%127 = icmp eq i32 %126, %111
br i1 %127, label %133, label %128
128: ; preds = %125, %121
%129 = phi i32 [ %119, %121 ], [ %126, %125 ]
%130 = add nuw nsw i32 %118, 1
%131 = getelementptr inbounds i8, i8* %117, i64 1
%132 = icmp eq i32 %129, %111
br i1 %132, label %133, label %116
133: ; preds = %125, %128, %116
%134 = phi i8* [ %131, %128 ], [ %117, %116 ], [ %117, %125 ]
%135 = phi i32 [ %130, %128 ], [ %118, %116 ], [ %118, %125 ]
%136 = icmp eq i32 %5, %135
br i1 %136, label %296, label %137
137: ; preds = %133
%138 = sub i32 %5, %135
%139 = tail call i8* @malloc(i32 %138)
%140 = icmp sgt i32 %5, %135
br i1 %140, label %141, label %293
141: ; preds = %137
%142 = zext i32 %138 to i64
%143 = icmp ult i32 %138, 8
br i1 %143, label %250, label %144
144: ; preds = %141
%145 = getelementptr i8, i8* %139, i64 %142
%146 = getelementptr i8, i8* %134, i64 %142
%147 = icmp ult i8* %139, %146
%148 = icmp ult i8* %134, %145
%149 = and i1 %147, %148
br i1 %149, label %250, label %150
150: ; preds = %144
%151 = icmp ult i32 %138, 32
br i1 %151, label %235, label %152
152: ; preds = %150
%153 = and i64 %142, 4294967264
%154 = add nsw i64 %153, -32
%155 = lshr exact i64 %154, 5
%156 = add nuw nsw i64 %155, 1
%157 = and i64 %156, 3
%158 = icmp ult i64 %154, 96
br i1 %158, label %210, label %159
159: ; preds = %152
%160 = and i64 %156, 1152921504606846972
br label %161
161: ; preds = %161, %159
%162 = phi i64 [ 0, %159 ], [ %207, %161 ]
%163 = phi i64 [ 0, %159 ], [ %208, %161 ]
%164 = getelementptr i8, i8* %134, i64 %162
%165 = bitcast i8* %164 to <16 x i8>*
%166 = load <16 x i8>, <16 x i8>* %165
%167 = getelementptr i8, i8* %164, i64 16
%168 = bitcast i8* %167 to <16 x i8>*
%169 = load <16 x i8>, <16 x i8>* %168
%170 = getelementptr inbounds i8, i8* %139, i64 %162
%171 = bitcast i8* %170 to <16 x i8>*
store <16 x i8> %166, <16 x i8>* %171
%172 = getelementptr inbounds i8, i8* %170, i64 16
%173 = bitcast i8* %172 to <16 x i8>*
store <16 x i8> %169, <16 x i8>* %173
%174 = or i64 %162, 32
%175 = getelementptr i8, i8* %134, i64 %174
%176 = bitcast i8* %175 to <16 x i8>*
%177 = load <16 x i8>, <16 x i8>* %176
%178 = getelementptr i8, i8* %175, i64 16
%179 = bitcast i8* %178 to <16 x i8>*
%180 = load <16 x i8>, <16 x i8>* %179
%181 = getelementptr inbounds i8, i8* %139, i64 %174
%182 = bitcast i8* %181 to <16 x i8>*
store <16 x i8> %177, <16 x i8>* %182
%183 = getelementptr inbounds i8, i8* %181, i64 16
%184 = bitcast i8* %183 to <16 x i8>*
store <16 x i8> %180, <16 x i8>* %184
%185 = or i64 %162, 64
%186 = getelementptr i8, i8* %134, i64 %185
%187 = bitcast i8* %186 to <16 x i8>*
%188 = load <16 x i8>, <16 x i8>* %187
%189 = getelementptr i8, i8* %186, i64 16
%190 = bitcast i8* %189 to <16 x i8>*
%191 = load <16 x i8>, <16 x i8>* %190
%192 = getelementptr inbounds i8, i8* %139, i64 %185
%193 = bitcast i8* %192 to <16 x i8>*
store <16 x i8> %188, <16 x i8>* %193
%194 = getelementptr inbounds i8, i8* %192, i64 16
%195 = bitcast i8* %194 to <16 x i8>*
store <16 x i8> %191, <16 x i8>* %195
%196 = or i64 %162, 96
%197 = getelementptr i8, i8* %134, i64 %196
%198 = bitcast i8* %197 to <16 x i8>*
%199 = load <16 x i8>, <16 x i8>* %198
%200 = getelementptr i8, i8* %197, i64 16
%201 = bitcast i8* %200 to <16 x i8>*
%202 = load <16 x i8>, <16 x i8>* %201
%203 = getelementptr inbounds i8, i8* %139, i64 %196
%204 = bitcast i8* %203 to <16 x i8>*
store <16 x i8> %199, <16 x i8>* %204
%205 = getelementptr inbounds i8, i8* %203, i64 16
%206 = bitcast i8* %205 to <16 x i8>*
store <16 x i8> %202, <16 x i8>* %206
%207 = add nuw i64 %162, 128
%208 = add i64 %163, 4
%209 = icmp eq i64 %208, %160
br i1 %209, label %210, label %161
210: ; preds = %161, %152
%211 = phi i64 [ 0, %152 ], [ %207, %161 ]
%212 = icmp eq i64 %157, 0
br i1 %212, label %229, label %213
213: ; preds = %210, %213
%214 = phi i64 [ %226, %213 ], [ %211, %210 ]
%215 = phi i64 [ %227, %213 ], [ 0, %210 ]
%216 = getelementptr i8, i8* %134, i64 %214
%217 = bitcast i8* %216 to <16 x i8>*
%218 = load <16 x i8>, <16 x i8>* %217
%219 = getelementptr i8, i8* %216, i64 16
%220 = bitcast i8* %219 to <16 x i8>*
%221 = load <16 x i8>, <16 x i8>* %220
%222 = getelementptr inbounds i8, i8* %139, i64 %214
%223 = bitcast i8* %222 to <16 x i8>*
store <16 x i8> %218, <16 x i8>* %223
%224 = getelementptr inbounds i8, i8* %222, i64 16
%225 = bitcast i8* %224 to <16 x i8>*
store <16 x i8> %221, <16 x i8>* %225
%226 = add nuw i64 %214, 32
%227 = add i64 %215, 1
%228 = icmp eq i64 %227, %157
br i1 %228, label %229, label %213
229: ; preds = %213, %210
%230 = icmp eq i64 %153, %142
br i1 %230, label %291, label %231
231: ; preds = %229
%232 = getelementptr i8, i8* %134, i64 %153
%233 = and i64 %142, 24
%234 = icmp eq i64 %233, 0
br i1 %234, label %250, label %235
235: ; preds = %150, %231
%236 = phi i64 [ %153, %231 ], [ 0, %150 ]
%237 = and i64 %142, 4294967288
%238 = getelementptr i8, i8* %134, i64 %237
br label %239
239: ; preds = %239, %235
%240 = phi i64 [ %236, %235 ], [ %246, %239 ]
%241 = getelementptr i8, i8* %134, i64 %240
%242 = bitcast i8* %241 to <8 x i8>*
%243 = load <8 x i8>, <8 x i8>* %242
%244 = getelementptr inbounds i8, i8* %139, i64 %240
%245 = bitcast i8* %244 to <8 x i8>*
store <8 x i8> %243, <8 x i8>* %245
%246 = add nuw i64 %240, 8
%247 = icmp eq i64 %246, %237
br i1 %247, label %248, label %239
248: ; preds = %239
%249 = icmp eq i64 %237, %142
br i1 %249, label %291, label %250
250: ; preds = %144, %141, %231, %248
%251 = phi i64 [ 0, %141 ], [ 0, %144 ], [ %153, %231 ], [ %237, %248 ]
%252 = phi i8* [ %134, %141 ], [ %134, %144 ], [ %232, %231 ], [ %238, %248 ]
%253 = xor i64 %251, -1
%254 = add nsw i64 %253, %142
%255 = and i64 %142, 3
%256 = icmp eq i64 %255, 0
br i1 %256, label %267, label %257
257: ; preds = %250, %257
%258 = phi i64 [ %263, %257 ], [ %251, %250 ]
%259 = phi i8* [ %264, %257 ], [ %252, %250 ]
%260 = phi i64 [ %265, %257 ], [ 0, %250 ]
%261 = load i8, i8* %259
%262 = getelementptr inbounds i8, i8* %139, i64 %258
store i8 %261, i8* %262
%263 = add nuw nsw i64 %258, 1
%264 = getelementptr inbounds i8, i8* %259, i64 1
%265 = add i64 %260, 1
%266 = icmp eq i64 %265, %255
br i1 %266, label %267, label %257
267: ; preds = %257, %250
%268 = phi i64 [ %251, %250 ], [ %263, %257 ]
%269 = phi i8* [ %252, %250 ], [ %264, %257 ]
%270 = icmp ult i64 %254, 3
br i1 %270, label %291, label %271
271: ; preds = %267, %271
%272 = phi i64 [ %288, %271 ], [ %268, %267 ]
%273 = phi i8* [ %289, %271 ], [ %269, %267 ]
%274 = load i8, i8* %273
%275 = getelementptr inbounds i8, i8* %139, i64 %272
store i8 %274, i8* %275
%276 = add nuw nsw i64 %272, 1
%277 = getelementptr inbounds i8, i8* %273, i64 1
%278 = load i8, i8* %277
%279 = getelementptr inbounds i8, i8* %139, i64 %276
store i8 %278, i8* %279
%280 = add nuw nsw i64 %272, 2
%281 = getelementptr inbounds i8, i8* %273, i64 2
%282 = load i8, i8* %281
%283 = getelementptr inbounds i8, i8* %139, i64 %280
store i8 %282, i8* %283
%284 = add nuw nsw i64 %272, 3
%285 = getelementptr inbounds i8, i8* %273, i64 3
%286 = load i8, i8* %285
%287 = getelementptr inbounds i8, i8* %139, i64 %284
store i8 %286, i8* %287
%288 = add nuw nsw i64 %272, 4
%289 = getelementptr inbounds i8, i8* %273, i64 4
%290 = icmp eq i64 %288, %142
br i1 %290, label %291, label %271
291: ; preds = %267, %271, %248, %229
%292 = zext i32 %138 to i64
br label %293
293: ; preds = %137, %291
%294 = phi i64 [ %292, %291 ], [ 0, %137 ]
%295 = getelementptr inbounds i8, i8* %139, i64 %294
store i8 0, i8* %295
br label %296
296: ; preds = %2, %293, %133, %110
%297 = phi i8* [ null, %110 ], [ %139, %293 ], [ null, %133 ], [ null, %2 ]
ret i8* %297
}