#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*/ memset(char *, int /*<<< orphan*/, int);
int /*<<< orphan*/ strcat(char *, char *);
char *intToString(int x) {
  char *result = malloc(sizeof(char) * 11);
  if (result == NULL) {
    return NULL;
  }
  memset(result, 0, 11);
  int length = 0;
  while (x > 0) {
    int digit = (x - ((int)(x / 10) * 10));
    switch (digit) {
    case 0:
      strcat(result, "0");
      break;
    case 1:
      strcat(result, "1");
      break;
    case 2:
      strcat(result, "2");
      break;
    case 3:
      strcat(result, "3");
      break;
    case 4:
      strcat(result, "4");
      break;
    case 5:
      strcat(result, "5");
      break;
    case 6:
      strcat(result, "6");
      break;
    case 7:
      strcat(result, "7");
      break;
    case 8:
      strcat(result, "8");
      break;
    case 9:
      strcat(result, "9");
      break;
    }
    x /= 10;
    length++;
  }
  char *rev_result = malloc(sizeof(char) * (length + 1));
  if (rev_result == NULL)
    return NULL;
  memset(rev_result, 0, length + 1);
  int y;
  for (y = 0; x < length; x++) {
    rev_result[x] = result[(length - 1) - x];
  }
  return rev_result;
}


x86 assembly (clang, -O0):
<intToString>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0xc(%rbp)
mov    $0xb,%edi
call   1040 <malloc@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    1161 <intToString+0x31>
movq   $0x0,-0x8(%rbp)
jmp    133d <intToString+0x20d>
mov    -0x18(%rbp),%rdi
xor    %esi,%esi
mov    $0xb,%edx
call   1030 <memset@plt>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x0,-0xc(%rbp)
jle    12b6 <intToString+0x186>
movslq -0xc(%rbp),%rcx
mov    %ecx,%eax
imul   $0x66666667,%rcx,%rdx
mov    %rdx,%rcx
shr    $0x3f,%rcx
sar    $0x22,%rdx
add    %ecx,%edx
add    %edx,%edx
mov    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    %rax,-0x38(%rbp)
sub    $0x9,%rax
ja     129a <intToString+0x16a>
mov    -0x38(%rbp),%rax
lea    0xe3c(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0xe50(%rip),%rsi
call   1050 <strcat@plt>
jmp    129a <intToString+0x16a>
mov    -0x18(%rbp),%rdi
lea    0xe3d(%rip),%rsi
call   1050 <strcat@plt>
jmp    129a <intToString+0x16a>
mov    -0x18(%rbp),%rdi
lea    0xe2a(%rip),%rsi
call   1050 <strcat@plt>
jmp    129a <intToString+0x16a>
mov    -0x18(%rbp),%rdi
lea    0xe17(%rip),%rsi
call   1050 <strcat@plt>
jmp    129a <intToString+0x16a>
mov    -0x18(%rbp),%rdi
lea    0xe04(%rip),%rsi
call   1050 <strcat@plt>
jmp    129a <intToString+0x16a>
mov    -0x18(%rbp),%rdi
lea    0xdf1(%rip),%rsi
call   1050 <strcat@plt>
jmp    129a <intToString+0x16a>
mov    -0x18(%rbp),%rdi
lea    0xdde(%rip),%rsi
call   1050 <strcat@plt>
jmp    129a <intToString+0x16a>
mov    -0x18(%rbp),%rdi
lea    0xdcb(%rip),%rsi
call   1050 <strcat@plt>
jmp    129a <intToString+0x16a>
mov    -0x18(%rbp),%rdi
lea    0xdb8(%rip),%rsi
call   1050 <strcat@plt>
jmp    129a <intToString+0x16a>
mov    -0x18(%rbp),%rdi
lea    0xda5(%rip),%rsi
call   1050 <strcat@plt>
mov    -0xc(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0xc(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1178 <intToString+0x48>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x0,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jne    12e5 <intToString+0x1b5>
movq   $0x0,-0x8(%rbp)
jmp    133d <intToString+0x20d>
mov    -0x28(%rbp),%rdi
mov    -0x1c(%rbp),%edx
add    $0x1,%edx
xor    %esi,%esi
call   1030 <memset@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1335 <intToString+0x205>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x28(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    12fd <intToString+0x1cd>
mov    -0x28(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<intToString>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %edi,%ebp
mov    $0xb,%edi
call   1040 <malloc@plt>
xor    %r12d,%r12d
test   %rax,%rax
je     1268 <intToString+0x138>
mov    %rax,%r15
mov    %rax,%rdi
xor    %esi,%esi
mov    $0xb,%edx
call   1030 <memset@plt>
test   %ebp,%ebp
jle    11b8 <intToString+0x88>
xor    %r12d,%r12d
mov    $0xcccccccd,%r14d
lea    0xe9b(%rip),%r13
jmp    118b <intToString+0x5b>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12d
cmp    $0x9,%ebp
mov    %ebx,%ebp
jbe    11ba <intToString+0x8a>
mov    %ebp,%ebx
imul   %r14,%rbx
shr    $0x23,%rbx
lea    (%rbx,%rbx,1),%eax
lea    (%rax,%rax,4),%ecx
mov    %ebp,%eax
sub    %ecx,%eax
cmp    $0x9,%eax
ja     1180 <intToString+0x50>
cltq
movslq 0x0(%r13,%rax,4),%rsi
add    %r13,%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
jmp    1180 <intToString+0x50>
mov    %ebp,%ebx
lea    0x1(%r12),%ebp
mov    %ebp,%edi
call   1040 <malloc@plt>
test   %rax,%rax
je     1268 <intToString+0x138>
mov    %rax,%r14
mov    %rax,%rdi
xor    %esi,%esi
mov    %ebp,%edx
call   1030 <memset@plt>
cmp    %r12d,%ebx
jge    126b <intToString+0x13b>
movslq %ebx,%rcx
movslq %r12d,%rax
mov    %rax,%r8
sub    %rcx,%r8
cmp    $0x8,%r8
jae    127d <intToString+0x14d>
mov    %rcx,%rsi
mov    %r12d,%edx
sub    %esi,%edx
mov    %rsi,%rcx
not    %rcx
test   $0x1,%dl
je     1226 <intToString+0xf6>
mov    %esi,%edx
not    %edx
add    %r12d,%edx
movslq %edx,%rdx
mov    (%r15,%rdx,1),%dl
mov    %dl,(%r14,%rsi,1)
add    $0x1,%rsi
add    %rax,%rcx
je     126b <intToString+0x13b>
sub    %rsi,%rax
lea    (%rsi,%r14,1),%rcx
add    $0x1,%rcx
not    %esi
add    %r12d,%esi
xor    %edx,%edx
nopl   (%rax)
movslq %esi,%rsi
movzbl (%r15,%rsi,1),%ebx
mov    %bl,-0x1(%rcx,%rdx,1)
lea    -0x1(%rsi),%edi
movslq %edi,%rdi
movzbl (%r15,%rdi,1),%ebx
mov    %bl,(%rcx,%rdx,1)
add    $0x2,%rdx
add    $0xfffffffe,%esi
cmp    %rdx,%rax
jne    1240 <intToString+0x110>
jmp    126b <intToString+0x13b>
xor    %r14d,%r14d
mov    %r14,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %ebx,%esi
not    %esi
add    %r12d,%esi
mov    %esi,%edi
sub    %edx,%edi
cmp    %esi,%edi
jg     11fd <intToString+0xcd>
shr    $0x20,%rdx
jne    11fd <intToString+0xcd>
cmp    $0x20,%r8
jae    12b0 <intToString+0x180>
xor    %edi,%edi
jmp    1368 <intToString+0x238>
mov    %r8,%rdi
and    $0xffffffffffffffe0,%rdi
lea    (%rcx,%r14,1),%rbp
add    $0x10,%rbp
xor    %edx,%edx
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movslq %esi,%rsi
movdqu -0x1f(%r15,%rsi,1),%xmm1
movdqu -0xf(%r15,%rsi,1),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,-0x10(%rbp,%rdx,1)
movdqu %xmm1,0x0(%rbp,%rdx,1)
add    $0x20,%rdx
add    $0xffffffe0,%esi
cmp    %rdx,%rdi
jne    12d0 <intToString+0x1a0>
cmp    %rdi,%r8
je     126b <intToString+0x13b>
test   $0x18,%r8b
je     13d0 <intToString+0x2a0>
mov    %r8,%rdx
and    $0xfffffffffffffff8,%rdx
lea    (%rdx,%rcx,1),%rsi
add    %edi,%ebx
not    %ebx
add    %r12d,%ebx
add    %r14,%rcx
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %ebx,%rbx
movq   -0x7(%r15,%rbx,1),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rcx,%rdi,1)
add    $0x8,%rdi
add    $0xfffffff8,%ebx
cmp    %rdi,%rdx
jne    1390 <intToString+0x260>
cmp    %rdx,%r8
jne    1200 <intToString+0xd0>
jmp    126b <intToString+0x13b>
add    %rcx,%rdi
mov    %rdi,%rsi
jmp    1200 <intToString+0xd0>

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

LLVM IR (-O2):
@.str = [2 x i8] c"0\00"
@.str.1 = [2 x i8] c"1\00"
@.str.2 = [2 x i8] c"2\00"
@.str.3 = [2 x i8] c"3\00"
@.str.4 = [2 x i8] c"4\00"
@.str.5 = [2 x i8] c"5\00"
@.str.6 = [2 x i8] c"6\00"
@.str.7 = [2 x i8] c"7\00"
@.str.8 = [2 x i8] c"8\00"
@.str.9 = [2 x i8] c"9\00"
@reltable.intToString = [10 x i32] [i32 trunc (i64 sub (i64 ptrtoint ([2 x i8]* @.str to i64), i64 ptrtoint ([10 x i32]* @reltable.intToString to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([2 x i8]* @.str.1 to i64), i64 ptrtoint ([10 x i32]* @reltable.intToString to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([2 x i8]* @.str.2 to i64), i64 ptrtoint ([10 x i32]* @reltable.intToString to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([2 x i8]* @.str.3 to i64), i64 ptrtoint ([10 x i32]* @reltable.intToString to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([2 x i8]* @.str.4 to i64), i64 ptrtoint ([10 x i32]* @reltable.intToString to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([2 x i8]* @.str.5 to i64), i64 ptrtoint ([10 x i32]* @reltable.intToString to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([2 x i8]* @.str.6 to i64), i64 ptrtoint ([10 x i32]* @reltable.intToString to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([2 x i8]* @.str.7 to i64), i64 ptrtoint ([10 x i32]* @reltable.intToString to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([2 x i8]* @.str.8 to i64), i64 ptrtoint ([10 x i32]* @reltable.intToString to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([2 x i8]* @.str.9 to i64), i64 ptrtoint ([10 x i32]* @reltable.intToString to i64)) to i32)]
define i8* @intToString(i32 %0) {
%2 = tail call dereferenceable_or_null(11) i8* @malloc(i32 11)
%3 = icmp eq i8* %2, null
br i1 %3, label %142, label %4
4: ; preds = %1
%5 = tail call i32 @memset(i8* %2, i32 0, i32 11)
%6 = icmp sgt i32 %0, 0
br i1 %6, label %7, label %22
7: ; preds = %4, %19
%8 = phi i32 [ %10, %19 ], [ %0, %4 ]
%9 = phi i32 [ %20, %19 ], [ 0, %4 ]
%10 = udiv i32 %8, 10
%11 = mul nsw i32 %10, -10
%12 = add nsw i32 %11, %8
%13 = icmp ult i32 %12, 10
br i1 %13, label %14, label %19
14: ; preds = %7
%15 = sext i32 %12 to i64
%16 = shl i64 %15, 2
%17 = call i8* @llvm.load.relative.i64(i8* bitcast ([10 x i32]* @reltable.intToString to i8*), i64 %16)
%18 = tail call i32 @strcat(i8* %2, i8* %17)
br label %19
19: ; preds = %7, %14
%20 = add nuw nsw i32 %9, 1
%21 = icmp ult i32 %8, 10
br i1 %21, label %22, label %7
22: ; preds = %19, %4
%23 = phi i32 [ 0, %4 ], [ %20, %19 ]
%24 = phi i32 [ %0, %4 ], [ %10, %19 ]
%25 = add nuw nsw i32 %23, 1
%26 = tail call i8* @malloc(i32 %25)
%27 = icmp eq i8* %26, null
br i1 %27, label %142, label %28
28: ; preds = %22
%29 = tail call i32 @memset(i8* %26, i32 0, i32 %25)
%30 = icmp slt i32 %24, %23
br i1 %30, label %31, label %142
31: ; preds = %28
%32 = sext i32 %24 to i64
%33 = sext i32 %23 to i64
%34 = sub nsw i64 %33, %32
%35 = icmp ult i64 %34, 8
br i1 %35, label %104, label %36
36: ; preds = %31
%37 = xor i64 %32, -1
%38 = add nsw i64 %37, %33
%39 = xor i32 %24, -1
%40 = add i32 %23, %39
%41 = trunc i64 %38 to i32
%42 = sub i32 %40, %41
%43 = icmp sgt i32 %42, %40
%44 = icmp ugt i64 %38, 4294967295
%45 = or i1 %43, %44
br i1 %45, label %104, label %46
46: ; preds = %36
%47 = icmp ult i64 %34, 32
br i1 %47, label %80, label %48
48: ; preds = %46
%49 = and i64 %34, -32
br label %50
50: ; preds = %50, %48
%51 = phi i64 [ 0, %48 ], [ %72, %50 ]
%52 = add i64 %51, %32
%53 = trunc i64 %51 to i32
%54 = add i32 %24, %53
%55 = xor i32 %54, -1
%56 = add i32 %23, %55
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds i8, i8* %2, i64 %57
%59 = getelementptr inbounds i8, i8* %58, i64 -15
%60 = bitcast i8* %59 to <16 x i8>*
%61 = load <16 x i8>, <16 x i8>* %60
%62 = shufflevector <16 x i8> %61, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%63 = getelementptr inbounds i8, i8* %58, i64 -16
%64 = getelementptr inbounds i8, i8* %63, i64 -15
%65 = bitcast i8* %64 to <16 x i8>*
%66 = load <16 x i8>, <16 x i8>* %65
%67 = shufflevector <16 x i8> %66, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%68 = getelementptr inbounds i8, i8* %26, i64 %52
%69 = bitcast i8* %68 to <16 x i8>*
store <16 x i8> %62, <16 x i8>* %69
%70 = getelementptr inbounds i8, i8* %68, i64 16
%71 = bitcast i8* %70 to <16 x i8>*
store <16 x i8> %67, <16 x i8>* %71
%72 = add nuw i64 %51, 32
%73 = icmp eq i64 %72, %49
br i1 %73, label %74, label %50
74: ; preds = %50
%75 = icmp eq i64 %34, %49
br i1 %75, label %142, label %76
76: ; preds = %74
%77 = add nsw i64 %49, %32
%78 = and i64 %34, 24
%79 = icmp eq i64 %78, 0
br i1 %79, label %104, label %80
80: ; preds = %46, %76
%81 = phi i64 [ %49, %76 ], [ 0, %46 ]
%82 = sub nsw i64 %33, %32
%83 = and i64 %82, -8
%84 = add nsw i64 %83, %32
%85 = getelementptr inbounds i8, i8* %2, i64 -7
br label %86
86: ; preds = %86, %80
%87 = phi i64 [ %81, %80 ], [ %100, %86 ]
%88 = add i64 %87, %32
%89 = trunc i64 %87 to i32
%90 = add i32 %24, %89
%91 = xor i32 %90, -1
%92 = add i32 %23, %91
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds i8, i8* %85, i64 %93
%95 = bitcast i8* %94 to <8 x i8>*
%96 = load <8 x i8>, <8 x i8>* %95
%97 = shufflevector <8 x i8> %96, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%98 = getelementptr inbounds i8, i8* %26, i64 %88
%99 = bitcast i8* %98 to <8 x i8>*
store <8 x i8> %97, <8 x i8>* %99
%100 = add nuw i64 %87, 8
%101 = icmp eq i64 %100, %83
br i1 %101, label %102, label %86
102: ; preds = %86
%103 = icmp eq i64 %82, %83
br i1 %103, label %142, label %104
104: ; preds = %36, %31, %76, %102
%105 = phi i64 [ %32, %31 ], [ %32, %36 ], [ %77, %76 ], [ %84, %102 ]
%106 = sub nsw i64 %33, %105
%107 = xor i64 %105, -1
%108 = and i64 %106, 1
%109 = icmp eq i64 %108, 0
br i1 %109, label %119, label %110
110: ; preds = %104
%111 = trunc i64 %105 to i32
%112 = xor i32 %111, -1
%113 = add i32 %23, %112
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds i8, i8* %2, i64 %114
%116 = load i8, i8* %115
%117 = getelementptr inbounds i8, i8* %26, i64 %105
store i8 %116, i8* %117
%118 = add nsw i64 %105, 1
br label %119
119: ; preds = %110, %104
%120 = phi i64 [ %105, %104 ], [ %118, %110 ]
%121 = sub nsw i64 0, %33
%122 = icmp eq i64 %107, %121
br i1 %122, label %142, label %123
123: ; preds = %119, %123
%124 = phi i64 [ %140, %123 ], [ %120, %119 ]
%125 = trunc i64 %124 to i32
%126 = xor i32 %125, -1
%127 = add i32 %23, %126
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds i8, i8* %2, i64 %128
%130 = load i8, i8* %129
%131 = getelementptr inbounds i8, i8* %26, i64 %124
store i8 %130, i8* %131
%132 = add nsw i64 %124, 1
%133 = trunc i64 %132 to i32
%134 = xor i32 %133, -1
%135 = add i32 %23, %134
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds i8, i8* %2, i64 %136
%138 = load i8, i8* %137
%139 = getelementptr inbounds i8, i8* %26, i64 %132
store i8 %138, i8* %139
%140 = add nsw i64 %124, 2
%141 = icmp eq i64 %140, %33
br i1 %141, label %142, label %123
142: ; preds = %119, %123, %74, %102, %28, %22, %1
%143 = phi i8* [ null, %1 ], [ null, %22 ], [ %26, %28 ], [ %26, %102 ], [ %26, %74 ], [ %26, %123 ], [ %26, %119 ]
ret i8* %143
}