#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__ isspace(char);
int /*<<< orphan*/ memmove(char *, char *, size_t);
char *strchr(char *, char);
char *xor_expand(char *);
char *get_function(char *out_name, char *lib_func) {
  static char newfunc[16384];
  char *fptr, *sptr;
  int nest;
  int state = 0;
  fptr = newfunc;
  sptr = out_name;
  while (*sptr != '\0')
    *fptr++ = *sptr++;
  *fptr++ = ' ';
  *fptr++ = '=';
  *fptr++ = ' ';
  sptr = xor_expand(lib_func);
  while (*sptr != '\0') {
    if (*sptr == '(') {
      if (state == 3 || state == 2) {
        *fptr++ = '*';
        *fptr++ = ' ';
      }
      state = 1;
      *fptr++ = *sptr++;
    } else if (*sptr == ')') {
      state = 2;
      *fptr++ = *sptr++;
    } else if (*sptr == '!' || *sptr == '*' || *sptr == '+' || *sptr == '\'') {
      state = 4;
      *fptr++ = *sptr++;
    } else if (*sptr == ' ' || *sptr == '\t') {
      if (state == 3) {
        state = 6;
      }
      *fptr++ = *sptr++;
    } else if (*sptr == '^') {
      state = 5;
    } else {
      if (state == 6 || state == 2) {
        *fptr++ = '*';
        *fptr++ = ' ';
      }
      state = 3;
      *fptr++ = *sptr++;
    }
  }
  *fptr = '\0';
  while ((sptr = strchr(newfunc, '\'')) != NULL) {
    fptr = sptr - 1;
    while (isspace(*fptr))
      fptr--;
    if (*fptr == ')') {
      nest = 1;
      while (nest > 0) {
        fptr--;
        if (*fptr == ')')
          nest++;
        else if (*fptr == '(')
          nest--;
        else if (fptr == newfunc)
          break;
      }
    } else {
      while (*fptr != '!' && *fptr != '*' && *fptr != '+' && !isspace(*fptr) &&
             (fptr > newfunc) && *fptr != '(' && *fptr != ')')
        fptr--;
      if (fptr > newfunc)
        fptr++;
    }
    memmove(fptr + 1, fptr, (size_t)(sptr - fptr));
    *fptr = '!';
  }
  return newfunc;
}


x86 assembly (clang, -O0):
<get_function>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x28(%rbp)
lea    0x2ef2(%rip),%rax
mov    %rax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     11a1 <get_function+0x61>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
jmp    116a <get_function+0x2a>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
movb   $0x3d,(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
movb   $0x20,(%rax)
mov    -0x10(%rbp),%rdi
call   1060 <xor_expand@plt>
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     1404 <get_function+0x2c4>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x28,%eax
jne    126a <get_function+0x12a>
cmpl   $0x3,-0x28(%rbp)
je     1218 <get_function+0xd8>
cmpl   $0x2,-0x28(%rbp)
jne    123c <get_function+0xfc>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
movb   $0x2a,(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
movb   $0x20,(%rax)
movl   $0x1,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
jmp    13ff <get_function+0x2bf>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x29,%eax
jne    12a8 <get_function+0x168>
movl   $0x2,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
jmp    13fa <get_function+0x2ba>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x21,%eax
je     12e8 <get_function+0x1a8>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2a,%eax
je     12e8 <get_function+0x1a8>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2b,%eax
je     12e8 <get_function+0x1a8>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x27,%eax
jne    1316 <get_function+0x1d6>
movl   $0x4,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
jmp    13f5 <get_function+0x2b5>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
je     1336 <get_function+0x1f6>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x9,%eax
jne    136e <get_function+0x22e>
cmpl   $0x3,-0x28(%rbp)
jne    1347 <get_function+0x207>
movl   $0x6,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
jmp    13f0 <get_function+0x2b0>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5e,%eax
jne    138a <get_function+0x24a>
movl   $0x5,-0x28(%rbp)
jmp    13eb <get_function+0x2ab>
cmpl   $0x6,-0x28(%rbp)
je     139e <get_function+0x25e>
cmpl   $0x2,-0x28(%rbp)
jne    13c2 <get_function+0x282>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
movb   $0x2a,(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
movb   $0x20,(%rax)
movl   $0x3,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
jmp    13f0 <get_function+0x2b0>
jmp    13f5 <get_function+0x2b5>
jmp    13fa <get_function+0x2ba>
jmp    13ff <get_function+0x2bf>
jmp    11e4 <get_function+0xa4>
mov    -0x18(%rbp),%rax
movb   $0x0,(%rax)
lea    0x2c3e(%rip),%rdi
mov    $0x27,%esi
call   1030 <strchr@plt>
mov    %rax,-0x20(%rbp)
cmp    $0x0,%rax
je     15f8 <get_function+0x4b8>
mov    -0x20(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isspace@plt>
cmp    $0x0,%rax
je     145d <get_function+0x31d>
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
jmp    1436 <get_function+0x2f6>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x29,%eax
jne    14f0 <get_function+0x3b0>
movl   $0x1,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    14eb <get_function+0x3ab>
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x29,%eax
jne    14a8 <get_function+0x368>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    14e6 <get_function+0x3a6>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x28,%eax
jne    14c6 <get_function+0x386>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    14e1 <get_function+0x3a1>
lea    0x2b83(%rip),%rax
cmp    %rax,-0x18(%rbp)
jne    14dc <get_function+0x39c>
jmp    14eb <get_function+0x3ab>
jmp    14e1 <get_function+0x3a1>
jmp    14e6 <get_function+0x3a6>
jmp    1474 <get_function+0x334>
jmp    15d0 <get_function+0x490>
jmp    14f5 <get_function+0x3b5>
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x21,%ecx
mov    %al,-0x29(%rbp)
je     158d <get_function+0x44d>
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x2a,%ecx
mov    %al,-0x29(%rbp)
je     158d <get_function+0x44d>
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x2b,%ecx
mov    %al,-0x29(%rbp)
je     158d <get_function+0x44d>
mov    -0x18(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isspace@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x29(%rbp)
jne    158d <get_function+0x44d>
xor    %eax,%eax
lea    0x2af5(%rip),%rcx
cmp    %rcx,-0x18(%rbp)
mov    %al,-0x29(%rbp)
jbe    158d <get_function+0x44d>
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x28,%ecx
mov    %al,-0x29(%rbp)
je     158d <get_function+0x44d>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x29,%eax
setne  %al
mov    %al,-0x29(%rbp)
mov    -0x29(%rbp),%al
test   $0x1,%al
jne    159d <get_function+0x45d>
jmp    15ae <get_function+0x46e>
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
jmp    14f5 <get_function+0x3b5>
lea    0x2a9b(%rip),%rax
cmp    %rax,-0x18(%rbp)
jbe    15cb <get_function+0x48b>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    15d0 <get_function+0x490>
mov    -0x18(%rbp),%rdi
add    $0x1,%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x18(%rbp),%rax
sub    %rax,%rdx
call   1050 <memmove@plt>
mov    -0x18(%rbp),%rax
movb   $0x21,(%rax)
jmp    140b <get_function+0x2cb>
lea    0x2a51(%rip),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_function>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    (%rdi),%al
test   %al,%al
je     1173 <get_function+0x33>
add    $0x1,%rdi
lea    0x2ef6(%rip),%rbx
nopw   0x0(%rax,%rax,1)
mov    %al,(%rbx)
add    $0x1,%rbx
movzbl (%rdi),%eax
add    $0x1,%rdi
test   %al,%al
jne    1160 <get_function+0x20>
jmp    117a <get_function+0x3a>
lea    0x2ed6(%rip),%rbx
movw   $0x3d20,(%rbx)
movb   $0x20,0x2(%rbx)
add    $0x3,%rbx
mov    %rsi,%rdi
call   1060 <xor_expand@plt>
xor    %esi,%esi
lea    0xe68(%rip),%rcx
mov    $0x6,%r8d
jmp    11af <get_function+0x6f>
mov    %dl,(%rbx)
add    $0x1,%rbx
mov    $0x4,%esi
add    $0x1,%rax
mov    (%rax),%dl
mov    %esi,%edi
mov    $0x5,%esi
cmp    $0x5e,%dl
je     11b1 <get_function+0x71>
cmp    $0x2b,%dl
ja     121b <get_function+0xdb>
movzbl %dl,%esi
movslq (%rcx,%rsi,4),%rsi
add    %rcx,%rsi
jmp    *%rsi
cmp    $0x3,%edi
cmove  %r8d,%edi
mov    %dl,(%rbx)
add    $0x1,%rbx
add    $0x1,%rax
mov    %edi,%esi
jmp    11af <get_function+0x6f>
and    $0xfffffffe,%edi
mov    $0x28,%dl
cmp    $0x2,%edi
jne    11f8 <get_function+0xb8>
movw   $0x202a,(%rbx)
add    $0x2,%rbx
mov    (%rax),%dl
mov    %dl,(%rbx)
add    $0x1,%rbx
mov    $0x1,%esi
add    $0x1,%rax
jmp    11af <get_function+0x6f>
movb   $0x29,(%rbx)
add    $0x1,%rbx
mov    $0x2,%esi
add    $0x1,%rax
jmp    11af <get_function+0x6f>
and    $0xfffffffb,%edi
cmp    $0x2,%edi
jne    122e <get_function+0xee>
movw   $0x202a,(%rbx)
add    $0x2,%rbx
mov    (%rax),%dl
mov    %dl,(%rbx)
add    $0x1,%rbx
mov    $0x3,%esi
add    $0x1,%rax
jmp    11af <get_function+0x6f>
movb   $0x0,(%rbx)
lea    0x2e04(%rip),%r14
mov    %r14,%rdi
mov    $0x27,%esi
call   1030 <strchr@plt>
test   %rax,%rax
je     137c <get_function+0x23c>
mov    %rax,%r15
movabs $0xc0200000000,%r12
jmp    12b7 <get_function+0x177>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    %r13,%r14
adc    $0x0,%r13
lea    0x1(%r13),%rdi
sub    %r13,%r15
mov    %r13,%rsi
mov    %r15,%rdx
call   1050 <memmove@plt>
movb   $0x21,0x0(%r13)
mov    %r14,%rdi
mov    $0x27,%esi
call   1030 <strchr@plt>
mov    %rax,%r15
test   %rax,%rax
je     137c <get_function+0x23c>
lea    -0x2(%r15),%rcx
mov    %r15,%r13
xchg   %ax,%ax
mov    %rcx,%rbx
movsbl -0x1(%r13),%edi
add    $0xffffffffffffffff,%r13
call   1040 <isspace@plt>
lea    -0x1(%rbx),%rcx
test   %rax,%rax
jne    12c0 <get_function+0x180>
mov    0x0(%r13),%al
cmp    $0x29,%al
jne    1320 <get_function+0x1e0>
mov    $0x1,%eax
jmp    12fb <get_function+0x1bb>
nopl   0x0(%rax)
add    $0xffffffff,%eax
add    $0xffffffffffffffff,%rbx
test   %eax,%eax
jle    1370 <get_function+0x230>
movzbl (%rbx),%ecx
cmp    $0x28,%cl
je     12f0 <get_function+0x1b0>
cmp    $0x29,%cl
jne    1310 <get_function+0x1d0>
add    $0x1,%eax
jmp    12f3 <get_function+0x1b3>
nopl   (%rax)
cmp    %r14,%rbx
jne    12f3 <get_function+0x1b3>
mov    %r14,%r13
jmp    1287 <get_function+0x147>
nopl   (%rax)
cmp    $0x2b,%al
ja     1331 <get_function+0x1f1>
movzbl %al,%ecx
bt     %rcx,%r12
jb     1280 <get_function+0x140>
movsbl %al,%edi
call   1040 <isspace@plt>
cmp    %r14,%r13
jbe    1280 <get_function+0x140>
test   %rax,%rax
jne    1280 <get_function+0x140>
movzbl 0x0(%r13),%eax
and    $0xfe,%al
cmp    $0x28,%al
je     1280 <get_function+0x140>
movzbl -0x1(%r13),%eax
add    $0xffffffffffffffff,%r13
jmp    1320 <get_function+0x1e0>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbx
mov    %rbx,%r13
jmp    1287 <get_function+0x147>
lea    0x2ccd(%rip),%rax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@get_function.newfunc = internal global [16384 x i8] zeroinitializer
define i8* @get_function(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
store i8* %0, i8** %3
store i8* %1, i8** %4
store i32 0, i32* %8
store i8* getelementptr inbounds ([16384 x i8], [16384 x i8]* @get_function.newfunc, i64 0, i64 0), i8** %5
%9 = load i8*, i8** %3
store i8* %9, i8** %6
br label %10
10: ; preds = %15, %2
%11 = load i8*, i8** %6
%12 = load i8, i8* %11
%13 = sext i8 %12 to i32
%14 = icmp ne i32 %13, 0
br i1 %14, label %15, label %21
15: ; preds = %10
%16 = load i8*, i8** %6
%17 = getelementptr inbounds i8, i8* %16, i32 1
store i8* %17, i8** %6
%18 = load i8, i8* %16
%19 = load i8*, i8** %5
%20 = getelementptr inbounds i8, i8* %19, i32 1
store i8* %20, i8** %5
store i8 %18, i8* %19
br label %10
21: ; preds = %10
%22 = load i8*, i8** %5
%23 = getelementptr inbounds i8, i8* %22, i32 1
store i8* %23, i8** %5
store i8 32, i8* %22
%24 = load i8*, i8** %5
%25 = getelementptr inbounds i8, i8* %24, i32 1
store i8* %25, i8** %5
store i8 61, i8* %24
%26 = load i8*, i8** %5
%27 = getelementptr inbounds i8, i8* %26, i32 1
store i8* %27, i8** %5
store i8 32, i8* %26
%28 = load i8*, i8** %4
%29 = call i8* @xor_expand(i8* %28)
store i8* %29, i8** %6
br label %30
30: ; preds = %141, %21
%31 = load i8*, i8** %6
%32 = load i8, i8* %31
%33 = sext i8 %32 to i32
%34 = icmp ne i32 %33, 0
br i1 %34, label %35, label %142
35: ; preds = %30
%36 = load i8*, i8** %6
%37 = load i8, i8* %36
%38 = sext i8 %37 to i32
%39 = icmp eq i32 %38, 40
br i1 %39, label %40, label %57
40: ; preds = %35
%41 = load i32, i32* %8
%42 = icmp eq i32 %41, 3
br i1 %42, label %46, label %43
43: ; preds = %40
%44 = load i32, i32* %8
%45 = icmp eq i32 %44, 2
br i1 %45, label %46, label %51
46: ; preds = %43, %40
%47 = load i8*, i8** %5
%48 = getelementptr inbounds i8, i8* %47, i32 1
store i8* %48, i8** %5
store i8 42, i8* %47
%49 = load i8*, i8** %5
%50 = getelementptr inbounds i8, i8* %49, i32 1
store i8* %50, i8** %5
store i8 32, i8* %49
br label %51
51: ; preds = %46, %43
store i32 1, i32* %8
%52 = load i8*, i8** %6
%53 = getelementptr inbounds i8, i8* %52, i32 1
store i8* %53, i8** %6
%54 = load i8, i8* %52
%55 = load i8*, i8** %5
%56 = getelementptr inbounds i8, i8* %55, i32 1
store i8* %56, i8** %5
store i8 %54, i8* %55
br label %141
57: ; preds = %35
%58 = load i8*, i8** %6
%59 = load i8, i8* %58
%60 = sext i8 %59 to i32
%61 = icmp eq i32 %60, 41
br i1 %61, label %62, label %68
62: ; preds = %57
store i32 2, i32* %8
%63 = load i8*, i8** %6
%64 = getelementptr inbounds i8, i8* %63, i32 1
store i8* %64, i8** %6
%65 = load i8, i8* %63
%66 = load i8*, i8** %5
%67 = getelementptr inbounds i8, i8* %66, i32 1
store i8* %67, i8** %5
store i8 %65, i8* %66
br label %140
68: ; preds = %57
%69 = load i8*, i8** %6
%70 = load i8, i8* %69
%71 = sext i8 %70 to i32
%72 = icmp eq i32 %71, 33
br i1 %72, label %88, label %73
73: ; preds = %68
%74 = load i8*, i8** %6
%75 = load i8, i8* %74
%76 = sext i8 %75 to i32
%77 = icmp eq i32 %76, 42
br i1 %77, label %88, label %78
78: ; preds = %73
%79 = load i8*, i8** %6
%80 = load i8, i8* %79
%81 = sext i8 %80 to i32
%82 = icmp eq i32 %81, 43
br i1 %82, label %88, label %83
83: ; preds = %78
%84 = load i8*, i8** %6
%85 = load i8, i8* %84
%86 = sext i8 %85 to i32
%87 = icmp eq i32 %86, 39
br i1 %87, label %88, label %94
88: ; preds = %83, %78, %73, %68
store i32 4, i32* %8
%89 = load i8*, i8** %6
%90 = getelementptr inbounds i8, i8* %89, i32 1
store i8* %90, i8** %6
%91 = load i8, i8* %89
%92 = load i8*, i8** %5
%93 = getelementptr inbounds i8, i8* %92, i32 1
store i8* %93, i8** %5
store i8 %91, i8* %92
br label %139
94: ; preds = %83
%95 = load i8*, i8** %6
%96 = load i8, i8* %95
%97 = sext i8 %96 to i32
%98 = icmp eq i32 %97, 32
br i1 %98, label %104, label %99
99: ; preds = %94
%100 = load i8*, i8** %6
%101 = load i8, i8* %100
%102 = sext i8 %101 to i32
%103 = icmp eq i32 %102, 9
br i1 %103, label %104, label %114
104: ; preds = %99, %94
%105 = load i32, i32* %8
%106 = icmp eq i32 %105, 3
br i1 %106, label %107, label %108
107: ; preds = %104
store i32 6, i32* %8
br label %108
108: ; preds = %107, %104
%109 = load i8*, i8** %6
%110 = getelementptr inbounds i8, i8* %109, i32 1
store i8* %110, i8** %6
%111 = load i8, i8* %109
%112 = load i8*, i8** %5
%113 = getelementptr inbounds i8, i8* %112, i32 1
store i8* %113, i8** %5
store i8 %111, i8* %112
br label %138
114: ; preds = %99
%115 = load i8*, i8** %6
%116 = load i8, i8* %115
%117 = sext i8 %116 to i32
%118 = icmp eq i32 %117, 94
br i1 %118, label %119, label %120
119: ; preds = %114
store i32 5, i32* %8
br label %137
120: ; preds = %114
%121 = load i32, i32* %8
%122 = icmp eq i32 %121, 6
br i1 %122, label %126, label %123
123: ; preds = %120
%124 = load i32, i32* %8
%125 = icmp eq i32 %124, 2
br i1 %125, label %126, label %131
126: ; preds = %123, %120
%127 = load i8*, i8** %5
%128 = getelementptr inbounds i8, i8* %127, i32 1
store i8* %128, i8** %5
store i8 42, i8* %127
%129 = load i8*, i8** %5
%130 = getelementptr inbounds i8, i8* %129, i32 1
store i8* %130, i8** %5
store i8 32, i8* %129
br label %131
131: ; preds = %126, %123
store i32 3, i32* %8
%132 = load i8*, i8** %6
%133 = getelementptr inbounds i8, i8* %132, i32 1
store i8* %133, i8** %6
%134 = load i8, i8* %132
%135 = load i8*, i8** %5
%136 = getelementptr inbounds i8, i8* %135, i32 1
store i8* %136, i8** %5
store i8 %134, i8* %135
br label %137
137: ; preds = %131, %119
br label %138
138: ; preds = %137, %108
br label %139
139: ; preds = %138, %88
br label %140
140: ; preds = %139, %62
br label %141
141: ; preds = %140, %51
br label %30
142: ; preds = %30
%143 = load i8*, i8** %5
store i8 0, i8* %143
br label %144
144: ; preds = %239, %142
%145 = call i8* @strchr(i8* getelementptr inbounds ([16384 x i8], [16384 x i8]* @get_function.newfunc, i64 0, i64 0), i8 signext 39)
store i8* %145, i8** %6
%146 = icmp ne i8* %145, null
br i1 %146, label %147, label %250
147: ; preds = %144
%148 = load i8*, i8** %6
%149 = getelementptr inbounds i8, i8* %148, i64 -1
store i8* %149, i8** %5
br label %150
150: ; preds = %155, %147
%151 = load i8*, i8** %5
%152 = load i8, i8* %151
%153 = call i64 @isspace(i8 signext %152)
%154 = icmp ne i64 %153, 0
br i1 %154, label %155, label %158
155: ; preds = %150
%156 = load i8*, i8** %5
%157 = getelementptr inbounds i8, i8* %156, i32 -1
store i8* %157, i8** %5
br label %150
158: ; preds = %150
%159 = load i8*, i8** %5
%160 = load i8, i8* %159
%161 = sext i8 %160 to i32
%162 = icmp eq i32 %161, 41
br i1 %162, label %163, label %193
163: ; preds = %158
store i32 1, i32* %7
br label %164
164: ; preds = %191, %163
%165 = load i32, i32* %7
%166 = icmp sgt i32 %165, 0
br i1 %166, label %167, label %192
167: ; preds = %164
%168 = load i8*, i8** %5
%169 = getelementptr inbounds i8, i8* %168, i32 -1
store i8* %169, i8** %5
%170 = load i8*, i8** %5
%171 = load i8, i8* %170
%172 = sext i8 %171 to i32
%173 = icmp eq i32 %172, 41
br i1 %173, label %174, label %177
174: ; preds = %167
%175 = load i32, i32* %7
%176 = add nsw i32 %175, 1
store i32 %176, i32* %7
br label %191
177: ; preds = %167
%178 = load i8*, i8** %5
%179 = load i8, i8* %178
%180 = sext i8 %179 to i32
%181 = icmp eq i32 %180, 40
br i1 %181, label %182, label %185
182: ; preds = %177
%183 = load i32, i32* %7
%184 = add nsw i32 %183, -1
store i32 %184, i32* %7
br label %190
185: ; preds = %177
%186 = load i8*, i8** %5
%187 = icmp eq i8* %186, getelementptr inbounds ([16384 x i8], [16384 x i8]* @get_function.newfunc, i64 0, i64 0)
br i1 %187, label %188, label %189
188: ; preds = %185
br label %192
189: ; preds = %185
br label %190
190: ; preds = %189, %182
br label %191
191: ; preds = %190, %174
br label %164
192: ; preds = %188, %164
br label %239
193: ; preds = %158
br label %194
194: ; preds = %229, %193
%195 = load i8*, i8** %5
%196 = load i8, i8* %195
%197 = sext i8 %196 to i32
%198 = icmp ne i32 %197, 33
br i1 %198, label %199, label %227
199: ; preds = %194
%200 = load i8*, i8** %5
%201 = load i8, i8* %200
%202 = sext i8 %201 to i32
%203 = icmp ne i32 %202, 42
br i1 %203, label %204, label %227
204: ; preds = %199
%205 = load i8*, i8** %5
%206 = load i8, i8* %205
%207 = sext i8 %206 to i32
%208 = icmp ne i32 %207, 43
br i1 %208, label %209, label %227
209: ; preds = %204
%210 = load i8*, i8** %5
%211 = load i8, i8* %210
%212 = call i64 @isspace(i8 signext %211)
%213 = icmp ne i64 %212, 0
br i1 %213, label %227, label %214
214: ; preds = %209
%215 = load i8*, i8** %5
%216 = icmp ugt i8* %215, getelementptr inbounds ([16384 x i8], [16384 x i8]* @get_function.newfunc, i64 0, i64 0)
br i1 %216, label %217, label %227
217: ; preds = %214
%218 = load i8*, i8** %5
%219 = load i8, i8* %218
%220 = sext i8 %219 to i32
%221 = icmp ne i32 %220, 40
br i1 %221, label %222, label %227
222: ; preds = %217
%223 = load i8*, i8** %5
%224 = load i8, i8* %223
%225 = sext i8 %224 to i32
%226 = icmp ne i32 %225, 41
br label %227
227: ; preds = %222, %217, %214, %209, %204, %199, %194
%228 = phi i1 [ false, %217 ], [ false, %214 ], [ false, %209 ], [ false, %204 ], [ false, %199 ], [ false, %194 ], [ %226, %222 ]
br i1 %228, label %229, label %232
229: ; preds = %227
%230 = load i8*, i8** %5
%231 = getelementptr inbounds i8, i8* %230, i32 -1
store i8* %231, i8** %5
br label %194
232: ; preds = %227
%233 = load i8*, i8** %5
%234 = icmp ugt i8* %233, getelementptr inbounds ([16384 x i8], [16384 x i8]* @get_function.newfunc, i64 0, i64 0)
br i1 %234, label %235, label %238
235: ; preds = %232
%236 = load i8*, i8** %5
%237 = getelementptr inbounds i8, i8* %236, i32 1
store i8* %237, i8** %5
br label %238
238: ; preds = %235, %232
br label %239
239: ; preds = %238, %192
%240 = load i8*, i8** %5
%241 = getelementptr inbounds i8, i8* %240, i64 1
%242 = load i8*, i8** %5
%243 = load i8*, i8** %6
%244 = load i8*, i8** %5
%245 = ptrtoint i8* %243 to i64
%246 = ptrtoint i8* %244 to i64
%247 = sub i64 %245, %246
%248 = call i32 @memmove(i8* %241, i8* %242, i64 %247)
%249 = load i8*, i8** %5
store i8 33, i8* %249
br label %144
250: ; preds = %144
ret i8* getelementptr inbounds ([16384 x i8], [16384 x i8]* @get_function.newfunc, i64 0, i64 0)
}

LLVM IR (-O2):
@get_function.newfunc = internal global [16384 x i8] zeroinitializer
define i8* @get_function(i8* nocapture %0, i8* %1) {
%3 = load i8, i8* %0
%4 = icmp eq i8 %3, 0
br i1 %4, label %13, label %5
5: ; preds = %2, %5
%6 = phi i8 [ %11, %5 ], [ %3, %2 ]
%7 = phi i8* [ %9, %5 ], [ %0, %2 ]
%8 = phi i8* [ %10, %5 ], [ getelementptr inbounds ([16384 x i8], [16384 x i8]* @get_function.newfunc, i64 0, i64 0), %2 ]
%9 = getelementptr inbounds i8, i8* %7, i64 1
%10 = getelementptr inbounds i8, i8* %8, i64 1
store i8 %6, i8* %8
%11 = load i8, i8* %9
%12 = icmp eq i8 %11, 0
br i1 %12, label %13, label %5
13: ; preds = %5, %2
%14 = phi i8* [ getelementptr inbounds ([16384 x i8], [16384 x i8]* @get_function.newfunc, i64 0, i64 0), %2 ], [ %10, %5 ]
%15 = getelementptr inbounds i8, i8* %14, i64 1
store i8 32, i8* %14
%16 = getelementptr inbounds i8, i8* %14, i64 2
store i8 61, i8* %15
%17 = getelementptr inbounds i8, i8* %14, i64 3
store i8 32, i8* %16
%18 = tail call i8* @xor_expand(i8* %1)
br label %19
19: ; preds = %37, %13
%20 = phi i8* [ %17, %13 ], [ %38, %37 ]
%21 = phi i8* [ %18, %13 ], [ %40, %37 ]
%22 = phi i32 [ 0, %13 ], [ %39, %37 ]
%23 = load i8, i8* %21
br label %24
24: ; preds = %19, %24
%25 = phi i32 [ 5, %24 ], [ %22, %19 ]
switch i8 %23, label %49 [
i8 0, label %60
i8 40, label %26
i8 41, label %41
i8 33, label %43
i8 42, label %43
i8 43, label %43
i8 39, label %43
i8 32, label %45
i8 9, label %45
i8 94, label %24
]
26: ; preds = %24
%27 = and i32 %25, -2
%28 = icmp eq i32 %27, 2
br i1 %28, label %29, label %33
29: ; preds = %26
%30 = getelementptr inbounds i8, i8* %20, i64 1
store i8 42, i8* %20
%31 = getelementptr inbounds i8, i8* %20, i64 2
store i8 32, i8* %30
%32 = load i8, i8* %21
br label %33
33: ; preds = %26, %29
%34 = phi i8 [ %32, %29 ], [ 40, %26 ]
%35 = phi i8* [ %31, %29 ], [ %20, %26 ]
%36 = getelementptr inbounds i8, i8* %35, i64 1
store i8 %34, i8* %35
br label %37
37: ; preds = %33, %41, %43, %45, %56
%38 = phi i8* [ %59, %56 ], [ %48, %45 ], [ %44, %43 ], [ %42, %41 ], [ %36, %33 ]
%39 = phi i32 [ 3, %56 ], [ %47, %45 ], [ 4, %43 ], [ 2, %41 ], [ 1, %33 ]
%40 = getelementptr inbounds i8, i8* %21, i64 1
br label %19
41: ; preds = %24
%42 = getelementptr inbounds i8, i8* %20, i64 1
store i8 41, i8* %20
br label %37
43: ; preds = %24, %24, %24, %24
%44 = getelementptr inbounds i8, i8* %20, i64 1
store i8 %23, i8* %20
br label %37
45: ; preds = %24, %24
%46 = icmp eq i32 %25, 3
%47 = select i1 %46, i32 6, i32 %25
%48 = getelementptr inbounds i8, i8* %20, i64 1
store i8 %23, i8* %20
br label %37
49: ; preds = %24
%50 = and i32 %25, -5
%51 = icmp eq i32 %50, 2
br i1 %51, label %52, label %56
52: ; preds = %49
%53 = getelementptr inbounds i8, i8* %20, i64 1
store i8 42, i8* %20
%54 = getelementptr inbounds i8, i8* %20, i64 2
store i8 32, i8* %53
%55 = load i8, i8* %21
br label %56
56: ; preds = %49, %52
%57 = phi i8 [ %55, %52 ], [ %23, %49 ]
%58 = phi i8* [ %54, %52 ], [ %20, %49 ]
%59 = getelementptr inbounds i8, i8* %58, i64 1
store i8 %57, i8* %58
br label %37
60: ; preds = %24
store i8 0, i8* %20
%61 = tail call i8* @strchr(i8* dereferenceable(1) getelementptr inbounds ([16384 x i8], [16384 x i8]* @get_function.newfunc, i64 0, i64 0), i8 signext 39)
%62 = icmp eq i8* %61, null
br i1 %62, label %116, label %63
63: ; preds = %60, %107
%64 = phi i8* [ %114, %107 ], [ %61, %60 ]
br label %65
65: ; preds = %63, %65
%66 = phi i8* [ %67, %65 ], [ %64, %63 ]
%67 = getelementptr inbounds i8, i8* %66, i64 -1
%68 = load i8, i8* %67
%69 = tail call i64 @isspace(i8 signext %68)
%70 = icmp eq i64 %69, 0
br i1 %70, label %71, label %65
71: ; preds = %65
%72 = load i8, i8* %67
%73 = icmp eq i8 %72, 41
br i1 %73, label %74, label %88
74: ; preds = %71, %85
%75 = phi i32 [ %86, %85 ], [ 1, %71 ]
%76 = phi i8* [ %77, %85 ], [ %67, %71 ]
%77 = getelementptr inbounds i8, i8* %76, i64 -1
%78 = load i8, i8* %77
switch i8 %78, label %83 [
i8 41, label %79
i8 40, label %81
]
79: ; preds = %74
%80 = add nuw nsw i32 %75, 1
br label %85
81: ; preds = %74
%82 = add nsw i32 %75, -1
br label %85
83: ; preds = %74
%84 = icmp eq i8* %77, getelementptr inbounds ([16384 x i8], [16384 x i8]* @get_function.newfunc, i64 0, i64 0)
br i1 %84, label %107, label %85
85: ; preds = %81, %83, %79
%86 = phi i32 [ %80, %79 ], [ %82, %81 ], [ %75, %83 ]
%87 = icmp sgt i32 %86, 0
br i1 %87, label %74, label %107
88: ; preds = %71, %100
%89 = phi i8 [ %102, %100 ], [ %72, %71 ]
%90 = phi i8* [ %101, %100 ], [ %67, %71 ]
switch i8 %89, label %91 [
i8 33, label %103
i8 42, label %103
i8 43, label %103
]
91: ; preds = %88
%92 = tail call i64 @isspace(i8 signext %89)
%93 = icmp eq i64 %92, 0
%94 = icmp ugt i8* %90, getelementptr inbounds ([16384 x i8], [16384 x i8]* @get_function.newfunc, i64 0, i64 0)
%95 = and i1 %94, %93
br i1 %95, label %96, label %103
96: ; preds = %91
%97 = load i8, i8* %90
%98 = and i8 %97, -2
%99 = icmp eq i8 %98, 40
br i1 %99, label %103, label %100
100: ; preds = %96
%101 = getelementptr inbounds i8, i8* %90, i64 -1
%102 = load i8, i8* %101
br label %88
103: ; preds = %96, %88, %88, %88, %91
%104 = icmp ugt i8* %90, getelementptr inbounds ([16384 x i8], [16384 x i8]* @get_function.newfunc, i64 0, i64 0)
%105 = zext i1 %104 to i64
%106 = getelementptr i8, i8* %90, i64 %105
br label %107
107: ; preds = %85, %83, %103
%108 = phi i8* [ %106, %103 ], [ %77, %85 ], [ getelementptr inbounds ([16384 x i8], [16384 x i8]* @get_function.newfunc, i64 0, i64 0), %83 ]
%109 = getelementptr inbounds i8, i8* %108, i64 1
%110 = ptrtoint i8* %64 to i64
%111 = ptrtoint i8* %108 to i64
%112 = sub i64 %110, %111
%113 = tail call i32 @memmove(i8* %109, i8* %108, i64 %112)
store i8 33, i8* %108
%114 = tail call i8* @strchr(i8* dereferenceable(1) getelementptr inbounds ([16384 x i8], [16384 x i8]* @get_function.newfunc, i64 0, i64 0), i8 signext 39)
%115 = icmp eq i8* %114, null
br i1 %115, label %116, label %63
116: ; preds = %107, %60
ret i8* getelementptr inbounds ([16384 x i8], [16384 x i8]* @get_function.newfunc, i64 0, i64 0)
}