#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__ strcmp(char *, char *);
char *Misc_Str_Trim(char *s) {
  char *pb;
  char *pe;
  char *ps;
  char *pd;
  if (strcmp(s, "") == 0)
    return s;
  pb = s;
  while (((*pb == ' ') || (*pb == '\t') || (*pb == '\n') || (*pb == '\r')) &&
         (*pb != 0)) {
    pb++;
  }
  pe = s;
  while (*pe != 0) {
    pe++;
  }
  pe--;
  while ((pe >= s) &&
         ((*pe == ' ') || (*pe == '\t') || (*pe == '\n') || (*pe == '\r'))) {
    pe--;
  }
  ps = pb;
  pd = s;
  while (ps <= pe) {
    *pd = *ps;
    ps++;
    pd++;
  }
  *pd = 0;
  return s;
}


x86 assembly (clang, -O0):
<Misc_Str_Trim>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    -0x10(%rbp),%rdi
lea    0xed9(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1143 <Misc_Str_Trim+0x33>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    12d5 <Misc_Str_Trim+0x1c5>
mov    -0x10(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
je     1190 <Misc_Str_Trim+0x80>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x9,%eax
je     1190 <Misc_Str_Trim+0x80>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
je     1190 <Misc_Str_Trim+0x80>
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0xd,%ecx
mov    %al,-0x31(%rbp)
jne    11a0 <Misc_Str_Trim+0x90>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x31(%rbp)
mov    -0x31(%rbp),%al
test   $0x1,%al
jne    11b0 <Misc_Str_Trim+0xa0>
jmp    11c1 <Misc_Str_Trim+0xb1>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    114b <Misc_Str_Trim+0x3b>
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     11ea <Misc_Str_Trim+0xda>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    11c9 <Misc_Str_Trim+0xb9>
mov    -0x20(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rcx
xor    %eax,%eax
cmp    -0x10(%rbp),%rcx
mov    %al,-0x32(%rbp)
jb     125e <Misc_Str_Trim+0x14e>
mov    -0x20(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x20,%ecx
mov    %al,-0x33(%rbp)
je     1258 <Misc_Str_Trim+0x148>
mov    -0x20(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x9,%ecx
mov    %al,-0x33(%rbp)
je     1258 <Misc_Str_Trim+0x148>
mov    -0x20(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0xa,%ecx
mov    %al,-0x33(%rbp)
je     1258 <Misc_Str_Trim+0x148>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xd,%eax
sete   %al
mov    %al,-0x33(%rbp)
mov    -0x33(%rbp),%al
mov    %al,-0x32(%rbp)
mov    -0x32(%rbp),%al
test   $0x1,%al
jne    126e <Misc_Str_Trim+0x15e>
jmp    127f <Misc_Str_Trim+0x16f>
mov    -0x20(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
jmp    11f6 <Misc_Str_Trim+0xe6>
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x20(%rbp),%rax
ja     12c6 <Misc_Str_Trim+0x1b6>
mov    -0x28(%rbp),%rax
mov    (%rax),%cl
mov    -0x30(%rbp),%rax
mov    %cl,(%rax)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    128f <Misc_Str_Trim+0x17f>
mov    -0x30(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Misc_Str_Trim>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdi,%r13
lea    0xedb(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     1379 <Misc_Str_Trim+0x269>
lea    0x2(%r13),%rdi
mov    %r13,%r8
not    %r8
xor    %eax,%eax
movabs $0x100002600,%rsi
mov    %r8,%rdx
mov    %r13,%rcx
nop
movzbl 0x0(%r13,%rax,1),%ebx
cmp    $0x20,%rbx
ja     1174 <Misc_Str_Trim+0x64>
bt     %rbx,%rsi
jae    1174 <Misc_Str_Trim+0x64>
add    $0x1,%rcx
add    $0x1,%rdi
add    $0xffffffffffffffff,%rdx
add    $0x1,%rax
jmp    1150 <Misc_Str_Trim+0x40>
lea    -0x2(%r13),%rcx
lea    (%rax,%r13,1),%r10
nopl   0x0(%rax)
cmpb   $0x0,0x2(%rcx)
lea    0x1(%rcx),%rcx
jne    1180 <Misc_Str_Trim+0x70>
jmp    1194 <Misc_Str_Trim+0x84>
nopl   0x0(%rax)
add    $0xffffffffffffffff,%rcx
cmp    %r13,%rcx
jb     11a8 <Misc_Str_Trim+0x98>
movzbl (%rcx),%ebp
cmp    $0x20,%rbp
ja     11a8 <Misc_Str_Trim+0x98>
bt     %rbp,%rsi
jb     1190 <Misc_Str_Trim+0x80>
mov    %r13,%r12
cmp    %rcx,%r10
ja     1374 <Misc_Str_Trim+0x264>
mov    %bl,0x0(%r13)
lea    (%rax,%r13,1),%rsi
add    $0x1,%rsi
lea    0x1(%r13),%r12
cmp    %rcx,%rsi
ja     1374 <Misc_Str_Trim+0x264>
lea    0x1(%rcx),%r11
cmp    %r11,%rdi
mov    %r11,%r9
cmova  %rdi,%r9
add    %r8,%r9
sub    %rax,%r9
cmp    $0x20,%r9
jb     1360 <Misc_Str_Trim+0x250>
cmp    %r11,%rdi
mov    %r11,%rbx
cmova  %rdi,%rbx
lea    (%rbx,%r8,1),%rbp
add    $0x1,%rbp
sub    %rax,%rbp
add    %rbp,%r10
cmp    %r10,%r12
jae    121f <Misc_Str_Trim+0x10f>
lea    (%r8,%r13,1),%rbp
add    $0x1,%rbp
add    %rbx,%rbp
sub    %rax,%rbp
cmp    %rbp,%rsi
jb     1360 <Misc_Str_Trim+0x250>
mov    %r9,%rsi
and    $0xffffffffffffffe0,%rsi
cmp    %r11,%rdi
mov    %r11,%r10
cmova  %rdi,%r10
mov    %rsi,(%rsp)
add    $0xffffffffffffffe0,%rsi
mov    %rsi,%r15
shr    $0x5,%r15
add    $0x1,%r15
cmp    $0x60,%rsi
jae    1250 <Misc_Str_Trim+0x140>
xor    %ebp,%ebp
jmp    12e3 <Misc_Str_Trim+0x1d3>
lea    0x71(%r13),%rsi
cmp    %r11,%rdi
mov    %r11,%rbx
cmova  %rdi,%rbx
add    %r8,%rbx
sub    %rax,%rbx
and    $0xffffffffffffffe0,%rbx
add    $0xffffffffffffffe0,%rbx
shr    $0x5,%rbx
add    $0x1,%rbx
and    $0xfffffffffffffffc,%rbx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    %r13,%r14
add    %rbp,%r14
movups 0x1(%rax,%r14,1),%xmm0
movups 0x11(%rax,%r14,1),%xmm1
movups %xmm0,-0x70(%rsi)
movups %xmm1,-0x60(%rsi)
movups 0x21(%rax,%r14,1),%xmm0
movups 0x31(%rax,%r14,1),%xmm1
movups %xmm0,-0x50(%rsi)
movups %xmm1,-0x40(%rsi)
movups 0x41(%rax,%r14,1),%xmm0
movups 0x51(%rax,%r14,1),%xmm1
movups %xmm0,-0x30(%rsi)
movups %xmm1,-0x20(%rsi)
movups 0x61(%rax,%r14,1),%xmm0
movups 0x71(%rax,%r14,1),%xmm1
movups %xmm0,-0x10(%rsi)
movups %xmm1,(%rsi)
sub    $0xffffffffffffff80,%rbp
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rbx
jne    1280 <Misc_Str_Trim+0x170>
test   $0x3,%r15b
je     133f <Misc_Str_Trim+0x22f>
cmp    %r11,%rdi
cmova  %rdi,%r11
lea    0x11(,%r13,1),%rsi
add    %rbp,%rsi
add    %r8d,%r11d
sub    %eax,%r11d
and    $0x60,%r11b
add    $0xe0,%r11b
shr    $0x5,%r11b
add    $0x1,%r11b
movzbl %r11b,%edi
and    $0x3,%edi
shl    $0x5,%rdi
xor    %ebp,%ebp
xchg   %ax,%ax
lea    (%rsi,%rbp,1),%rbx
movups -0x10(%rax,%rbx,1),%xmm0
movups (%rax,%rbx,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbp,1)
movups %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdi
jne    1320 <Misc_Str_Trim+0x210>
mov    (%rsp),%rsi
add    %rsi,%r12
cmp    %rsi,%r9
je     1374 <Misc_Str_Trim+0x264>
add    %rdx,%r10
and    $0xffffffffffffffe0,%r10
add    %r13,%r10
lea    (%rax,%r10,1),%rsi
add    $0x1,%rsi
nopl   (%rax)
movzbl (%rsi),%eax
mov    %al,(%r12)
add    $0x1,%rsi
add    $0x1,%r12
cmp    %rcx,%rsi
jbe    1360 <Misc_Str_Trim+0x250>
movb   $0x0,(%r12)
mov    %r13,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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