#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 *NextBlank(char *);
char *NextStr(char *);
const char *GetNextStr(char *pBuffer) {
  static char buff[100] = {0};
  buff[0] = '\0';
  if (!pBuffer)
    return NULL;
  char *p1 = NextStr(pBuffer);
  if (!p1)
    return buff;
  char *p2 = NextBlank(p1);
  if (!p2)
    return buff;
  int i = 0;
  while (p1 != p2 && i < 99)
    buff[i++] = *(p1++);
  buff[i] = '\0';
  return buff;
}


x86 assembly (clang, -O0):
<GetNextStr>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
movb   $0x0,0x2f0d(%rip)
cmpq   $0x0,-0x10(%rbp)
jne    114b <GetNextStr+0x2b>
movq   $0x0,-0x8(%rbp)
jmp    1217 <GetNextStr+0xf7>
mov    -0x10(%rbp),%rdi
call   1030 <NextStr@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    1173 <GetNextStr+0x53>
lea    0x2ed6(%rip),%rax
mov    %rax,-0x8(%rbp)
jmp    1217 <GetNextStr+0xf7>
mov    -0x18(%rbp),%rdi
call   1040 <NextBlank@plt>
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
jne    119b <GetNextStr+0x7b>
lea    0x2eae(%rip),%rax
mov    %rax,-0x8(%rbp)
jmp    1217 <GetNextStr+0xf7>
movl   $0x0,-0x24(%rbp)
mov    -0x18(%rbp),%rcx
xor    %eax,%eax
cmp    -0x20(%rbp),%rcx
mov    %al,-0x25(%rbp)
je     11bf <GetNextStr+0x9f>
cmpl   $0x63,-0x24(%rbp)
setl   %al
mov    %al,-0x25(%rbp)
mov    -0x25(%rbp),%al
test   $0x1,%al
jne    11cf <GetNextStr+0xaf>
jmp    11fd <GetNextStr+0xdd>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
mov    (%rax),%dl
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x24(%rbp)
movslq %eax,%rcx
lea    0x2e4b(%rip),%rax
mov    %dl,(%rax,%rcx,1)
jmp    11a2 <GetNextStr+0x82>
movslq -0x24(%rbp),%rcx
lea    0x2e38(%rip),%rax
movb   $0x0,(%rax,%rcx,1)
lea    0x2e2d(%rip),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<GetNextStr>:
push   %r14
push   %rbx
push   %rax
movb   $0x0,0x2f15(%rip)
test   %rdi,%rdi
je     11df <GetNextStr+0xbf>
call   1030 <NextStr@plt>
lea    0x2f00(%rip),%r14
test   %rax,%rax
je     11f2 <GetNextStr+0xd2>
mov    %rax,%rbx
mov    %rax,%rdi
call   1040 <NextBlank@plt>
test   %rax,%rax
je     11f2 <GetNextStr+0xd2>
cmp    %rax,%rbx
je     11e4 <GetNextStr+0xc4>
mov    %rbx,%rdx
not    %rdx
add    %rax,%rdx
cmp    $0x62,%rdx
mov    $0x62,%ecx
mov    $0x62,%r8d
cmovb  %rdx,%r8
cmp    $0xf,%r8
jb     11b0 <GetNextStr+0x90>
cmp    $0x62,%rdx
cmovb  %rdx,%rcx
lea    0x2ea9(%rip),%r11
lea    (%rbx,%rcx,1),%rdx
add    $0x1,%rdx
cmp    %r11,%rdx
jbe    11fd <GetNextStr+0xdd>
add    %r11,%rcx
add    $0x1,%rcx
cmp    %rcx,%rbx
jae    11fd <GetNextStr+0xdd>
xor    %ecx,%ecx
add    $0x1,%rbx
lea    0x2e83(%rip),%rdi
mov    %rcx,%rsi
movzbl -0x1(%rbx),%edx
lea    0x1(%rsi),%rcx
mov    %dl,(%rsi,%rdi,1)
cmp    %rax,%rbx
je     11e6 <GetNextStr+0xc6>
add    $0x1,%rbx
cmp    $0x62,%rsi
mov    %rcx,%rsi
jb     11c0 <GetNextStr+0xa0>
jmp    11e6 <GetNextStr+0xc6>
xor    %r14d,%r14d
jmp    11f2 <GetNextStr+0xd2>
xor    %ecx,%ecx
lea    0x2e53(%rip),%r14
movb   $0x0,(%rcx,%r14,1)
mov    %r14,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret
add    $0x1,%r8
mov    %r8d,%ecx
and    $0xf0,%ecx
lea    -0x10(%rcx),%rdx
mov    %rdx,%rdi
shr    $0x4,%rdi
add    $0x1,%rdi
mov    %edi,%r9d
and    $0x7,%r9d
cmp    $0x70,%rdx
jae    122a <GetNextStr+0x10a>
xor    %edx,%edx
jmp    1290 <GetNextStr+0x170>
and    $0xfffffffffffffff8,%rdi
xor    %edx,%edx
movups (%rbx,%rdx,1),%xmm0
movaps %xmm0,(%rdx,%r11,1)
movups 0x10(%rbx,%rdx,1),%xmm0
movaps %xmm0,0x10(%rdx,%r11,1)
movups 0x20(%rbx,%rdx,1),%xmm0
movaps %xmm0,0x20(%rdx,%r11,1)
movups 0x30(%rbx,%rdx,1),%xmm0
movaps %xmm0,0x30(%rdx,%r11,1)
movups 0x40(%rbx,%rdx,1),%xmm0
movaps %xmm0,0x40(%rdx,%r11,1)
movups 0x50(%rbx,%rdx,1),%xmm0
movaps %xmm0,0x50(%rdx,%r11,1)
movups 0x60(%rbx,%rdx,1),%xmm0
movaps %xmm0,0x60(%rdx,%r11,1)
movups 0x70(%rbx,%rdx,1),%xmm0
movaps %xmm0,0x70(%rdx,%r11,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffff8,%rdi
jne    1230 <GetNextStr+0x110>
test   %r9,%r9
je     12b7 <GetNextStr+0x197>
lea    (%rbx,%rdx,1),%r10
shl    $0x4,%r9
xor    %edi,%edi
nop
movups (%r10,%rdi,1),%xmm0
lea    (%rdx,%rdi,1),%rsi
movaps %xmm0,(%r11,%rsi,1)
add    $0x10,%rdi
cmp    %rdi,%r9
jne    12a0 <GetNextStr+0x180>
cmp    %rcx,%r8
je     11e6 <GetNextStr+0xc6>
add    %rcx,%rbx
jmp    11b2 <GetNextStr+0x92>

LLVM IR (-O0):
@GetNextStr.buff = internal global [100 x i8] zeroinitializer
define i8* @GetNextStr(i8* %0) {
%2 = alloca i8*
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i32
store i8* %0, i8** %3
store i8 0, i8* getelementptr inbounds ([100 x i8], [100 x i8]* @GetNextStr.buff, i64 0, i64 0)
%7 = load i8*, i8** %3
%8 = icmp ne i8* %7, null
br i1 %8, label %10, label %9
9: ; preds = %1
store i8* null, i8** %2
br label %44
10: ; preds = %1
%11 = load i8*, i8** %3
%12 = call i8* @NextStr(i8* %11)
store i8* %12, i8** %4
%13 = load i8*, i8** %4
%14 = icmp ne i8* %13, null
br i1 %14, label %16, label %15
15: ; preds = %10
store i8* getelementptr inbounds ([100 x i8], [100 x i8]* @GetNextStr.buff, i64 0, i64 0), i8** %2
br label %44
16: ; preds = %10
%17 = load i8*, i8** %4
%18 = call i8* @NextBlank(i8* %17)
store i8* %18, i8** %5
%19 = load i8*, i8** %5
%20 = icmp ne i8* %19, null
br i1 %20, label %22, label %21
21: ; preds = %16
store i8* getelementptr inbounds ([100 x i8], [100 x i8]* @GetNextStr.buff, i64 0, i64 0), i8** %2
br label %44
22: ; preds = %16
store i32 0, i32* %6
br label %23
23: ; preds = %32, %22
%24 = load i8*, i8** %4
%25 = load i8*, i8** %5
%26 = icmp ne i8* %24, %25
br i1 %26, label %27, label %30
27: ; preds = %23
%28 = load i32, i32* %6
%29 = icmp slt i32 %28, 99
br label %30
30: ; preds = %27, %23
%31 = phi i1 [ false, %23 ], [ %29, %27 ]
br i1 %31, label %32, label %40
32: ; preds = %30
%33 = load i8*, i8** %4
%34 = getelementptr inbounds i8, i8* %33, i32 1
store i8* %34, i8** %4
%35 = load i8, i8* %33
%36 = load i32, i32* %6
%37 = add nsw i32 %36, 1
store i32 %37, i32* %6
%38 = sext i32 %36 to i64
%39 = getelementptr inbounds [100 x i8], [100 x i8]* @GetNextStr.buff, i64 0, i64 %38
store i8 %35, i8* %39
br label %23
40: ; preds = %30
%41 = load i32, i32* %6
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds [100 x i8], [100 x i8]* @GetNextStr.buff, i64 0, i64 %42
store i8 0, i8* %43
store i8* getelementptr inbounds ([100 x i8], [100 x i8]* @GetNextStr.buff, i64 0, i64 0), i8** %2
br label %44
44: ; preds = %40, %21, %15, %9
%45 = load i8*, i8** %2
ret i8* %45
}

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