#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 */
scalar_t__ is_whitespace(char);
char *malloc(size_t);
int /*<<< orphan*/ memset(char *, int /*<<< orphan*/, size_t);
size_t strlen(char const *);
char *string_trim(const char *str) {
  char *trimmed_str;
  size_t trimmed_len;
  size_t str_len;
  size_t preceding_whitespace_len;
  size_t trailing_whitespace_len;
  char ch;
  int index;
  int begin_index;
  int i;
  str_len = strlen(str);
  index = 0;
  preceding_whitespace_len = 0;
  ch = str[0];
  while (is_whitespace(ch) && index < str_len) {
    index++;
    preceding_whitespace_len++;
    ch = str[index];
  }
  begin_index = index;
  trailing_whitespace_len = 0;
  index = str_len - 1;
  ch = str[index];
  while (is_whitespace(ch) && index >= 0) {
    index--;
    trailing_whitespace_len++;
    ch = str[index];
  }
  if (preceding_whitespace_len + trailing_whitespace_len >= str_len) {
    return NULL;
  }
  trimmed_len = str_len - preceding_whitespace_len - trailing_whitespace_len;
  trimmed_str = malloc(trimmed_len + 1);
  memset(trimmed_str, 0, trimmed_len + 1);
  for (i = begin_index; i < begin_index + trimmed_len; i++) {
    ch = str[i];
    trimmed_str[i - begin_index] = ch;
  }
  return trimmed_str;
}


x86 assembly (clang, -O0):
<string_trim>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x40(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x39(%rbp)
movsbl -0x39(%rbp),%edi
call   1050 <is_whitespace@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x49(%rbp)
je     119a <string_trim+0x5a>
movslq -0x40(%rbp),%rax
cmp    -0x28(%rbp),%rax
setb   %al
mov    %al,-0x49(%rbp)
mov    -0x49(%rbp),%al
test   $0x1,%al
jne    11aa <string_trim+0x6a>
jmp    11d2 <string_trim+0x92>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x39(%rbp)
jmp    1171 <string_trim+0x31>
mov    -0x40(%rbp),%eax
mov    %eax,-0x44(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x28(%rbp),%rax
sub    $0x1,%rax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x39(%rbp)
movsbl -0x39(%rbp),%edi
call   1050 <is_whitespace@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x4a(%rbp)
je     121e <string_trim+0xde>
cmpl   $0x0,-0x40(%rbp)
setge  %al
mov    %al,-0x4a(%rbp)
mov    -0x4a(%rbp),%al
test   $0x1,%al
jne    122e <string_trim+0xee>
jmp    1256 <string_trim+0x116>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x39(%rbp)
jmp    11f9 <string_trim+0xb9>
mov    -0x30(%rbp),%rax
add    -0x38(%rbp),%rax
cmp    -0x28(%rbp),%rax
jb     1275 <string_trim+0x135>
movq   $0x0,-0x8(%rbp)
jmp    12fb <string_trim+0x1bb>
mov    -0x28(%rbp),%rax
sub    -0x30(%rbp),%rax
sub    -0x38(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rdi
add    $0x1,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rdx
add    $0x1,%rdx
xor    %esi,%esi
call   1040 <memset@plt>
mov    -0x44(%rbp),%eax
mov    %eax,-0x48(%rbp)
movslq -0x48(%rbp),%rax
movslq -0x44(%rbp),%rcx
add    -0x20(%rbp),%rcx
cmp    %rcx,%rax
jae    12f3 <string_trim+0x1b3>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x39(%rbp)
mov    -0x39(%rbp),%dl
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    12af <string_trim+0x16f>
mov    -0x18(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<string_trim>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rdi,%r15
call   1030 <strlen@plt>
mov    %rax,%rbx
movsbl (%r15),%edi
call   1050 <is_whitespace@plt>
xor    %ecx,%ecx
mov    $0x0,%ebp
test   %rax,%rax
je     119b <string_trim+0x5b>
test   %rbx,%rbx
je     119b <string_trim+0x5b>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movsbl 0x1(%r15,%rbp,1),%edi
add    $0x1,%rbp
call   1050 <is_whitespace@plt>
test   %rax,%rax
je     1199 <string_trim+0x59>
cmp    %rbp,%rbx
ja     1180 <string_trim+0x40>
mov    %ebp,%ecx
mov    %rcx,0x18(%rsp)
mov    %ecx,%eax
mov    %rax,0x20(%rsp)
lea    (%rbx,%rax,1),%r14
sub    %rbp,%r14
add    $0x1,%r14
mov    %rbx,0x10(%rsp)
add    $0xffffffff,%ebx
movslq %ebx,%r12
mov    %r15,0x8(%rsp)
add    %r15,%r12
xor    %r15d,%r15d
nopl   0x0(%rax,%rax,1)
movsbl (%r12,%r15,1),%edi
call   1050 <is_whitespace@plt>
lea    -0x1(%r15),%r13
add    $0xffffffffffffffff,%r14
test   %rax,%rax
je     11ef <string_trim+0xaf>
add    %ebx,%r15d
mov    %r13,%r15
jns    11d0 <string_trim+0x90>
mov    %r13,%rax
not    %rax
add    %rbp,%rax
mov    0x10(%rsp),%rcx
cmp    %rax,%rcx
jbe    12a7 <string_trim+0x167>
mov    %rcx,%rax
sub    %rbp,%rax
lea    (%rax,%r13,1),%rbx
add    $0x2,%rbx
mov    %rbx,%rdi
call   1060 <malloc@plt>
mov    %rax,%r12
mov    %rax,(%rsp)
mov    %rax,%rdi
xor    %esi,%esi
mov    %rbx,%rdx
mov    0x10(%rsp),%rbx
call   1040 <memset@plt>
mov    %rbx,%rax
mov    0x20(%rsp),%r15
add    %r15,%rax
sub    %rbp,%rax
lea    (%rax,%r13,1),%r10
add    $0x1,%r10
cmp    %r15,%r10
jbe    12aa <string_trim+0x16a>
mov    0x18(%rsp),%rdx
movslq %edx,%r9
lea    0x1(%rdx),%r8d
xor    %esi,%esi
mov    %r10,%rcx
sub    %r8,%rcx
cmovae %rcx,%rsi
add    $0x1,%rsi
cmp    $0x8,%rsi
jae    12bc <string_trim+0x17c>
mov    %r9,%rsi
mov    %r15,%rdx
mov    0x8(%rsp),%r11
mov    (%rsp),%r14
sub    %r9,%r14
add    $0x1,%rsi
nopl   0x0(%rax,%rax,1)
movzbl (%r11,%rdx,1),%eax
mov    %al,-0x1(%r14,%rsi,1)
mov    %esi,%edx
add    $0x1,%rsi
cmp    %rdx,%r10
ja     1290 <string_trim+0x150>
jmp    12aa <string_trim+0x16a>
xor    %r12d,%r12d
mov    %r12,%rax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    %r8,%r14
cmovae %r8,%r14
lea    (%rdx,%rbx,1),%ecx
sub    %ebp,%ecx
sub    %r14d,%ecx
add    %r13d,%ecx
add    $0x1,%ecx
mov    %edx,%edi
add    %ecx,%edi
jb     1272 <string_trim+0x132>
sub    %r14,%rax
add    %r13,%rax
add    $0x1,%rax
shr    $0x20,%rax
jne    1272 <string_trim+0x132>
mov    $0xfffffffe,%edi
sub    %edx,%edi
cmp    %ecx,%edi
jb     1272 <string_trim+0x132>
test   %rax,%rax
mov    0x8(%rsp),%r11
mov    (%rsp),%r14
jne    1334 <string_trim+0x1f4>
cmp    $0x20,%rsi
jae    1311 <string_trim+0x1d1>
xor    %edi,%edi
jmp    143b <string_trim+0x2fb>
mov    %rsi,%rdi
and    $0xffffffffffffffe0,%rdi
lea    -0x20(%rdi),%rax
mov    %rax,%rcx
shr    $0x5,%rcx
add    $0x1,%rcx
cmp    $0x60,%rax
jae    133c <string_trim+0x1fc>
xor    %ebp,%ebp
jmp    13d0 <string_trim+0x290>
mov    %r9,%rsi
jmp    1498 <string_trim+0x358>
lea    (%r15,%r11,1),%rbx
add    $0x70,%rbx
xor    %ebp,%ebp
mov    %r10,%rax
sub    %r8,%rax
cmovb  %rbp,%rax
add    $0x1,%rax
and    $0xffffffffffffffe0,%rax
add    $0xffffffffffffffe0,%rax
shr    $0x5,%rax
add    $0x1,%rax
and    $0xfffffffffffffffc,%rax
nopl   0x0(%rax,%rax,1)
movups -0x70(%rbx,%rbp,1),%xmm0
movups -0x60(%rbx,%rbp,1),%xmm1
movups %xmm0,(%r12,%rbp,1)
movups %xmm1,0x10(%r12,%rbp,1)
movups -0x50(%rbx,%rbp,1),%xmm0
movups -0x40(%rbx,%rbp,1),%xmm1
movups %xmm0,0x20(%r12,%rbp,1)
movups %xmm1,0x30(%r12,%rbp,1)
movups -0x30(%rbx,%rbp,1),%xmm0
movups -0x20(%rbx,%rbp,1),%xmm1
movups %xmm0,0x40(%r12,%rbp,1)
movups %xmm1,0x50(%r12,%rbp,1)
movups -0x10(%rbx,%rbp,1),%xmm0
movups (%rbx,%rbp,1),%xmm1
movups %xmm0,0x60(%r12,%rbp,1)
movups %xmm1,0x70(%r12,%rbp,1)
sub    $0xffffffffffffff80,%rbp
add    $0xfffffffffffffffc,%rax
jne    1370 <string_trim+0x230>
test   $0x3,%cl
je     142c <string_trim+0x2ec>
lea    (%r14,%rbp,1),%rax
add    $0x10,%rax
add    %r15,%rbp
cmp    %r8,%r10
mov    %r8,%rcx
cmova  %r10,%rcx
add    %r11,%rbp
add    $0x10,%rbp
sub    %r8d,%ecx
add    $0x1,%cl
and    $0x60,%cl
add    $0xe0,%cl
shr    $0x5,%cl
add    $0x1,%cl
movzbl %cl,%ebx
and    $0x3,%ebx
shl    $0x5,%rbx
xor    %ecx,%ecx
nop
movups -0x10(%rbp,%rcx,1),%xmm0
movups 0x0(%rbp,%rcx,1),%xmm1
movups %xmm0,-0x10(%rax,%rcx,1)
movups %xmm1,(%rax,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rbx
jne    1410 <string_trim+0x2d0>
cmp    %rdi,%rsi
je     12aa <string_trim+0x16a>
test   $0x18,%sil
je     148f <string_trim+0x34f>
xor    %ebx,%ebx
mov    %r10,%rax
sub    %r8,%rax
cmovb  %rbx,%rax
add    $0x1,%rax
mov    %rax,%rbp
and    $0xfffffffffffffff8,%rbp
lea    (%r9,%rbp,1),%rsi
mov    %r10,%rcx
sub    %r8,%rcx
cmovb  %rbx,%rcx
lea    (%r15,%rbp,1),%rdx
add    $0x1,%rcx
and    $0xfffffffffffffff8,%rcx
add    %r11,%r15
nop
mov    (%r15,%rdi,1),%rbx
mov    %rbx,(%r12,%rdi,1)
add    $0x8,%rdi
cmp    %rdi,%rcx
jne    1470 <string_trim+0x330>
cmp    %rbp,%rax
jne    1281 <string_trim+0x141>
jmp    12aa <string_trim+0x16a>
add    %rdi,%r15
add    %r9,%rdi
mov    %rdi,%rsi
mov    %r15,%rdx
jmp    1281 <string_trim+0x141>

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

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