#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 *BGBCC_SHXA_EatWhite(char *);
char *BGBCC_SHXA_ParseTokenBasic(char *, char *);
char *BGBCC_SHXA_ParseTokenBasicAltn(char *s, char *tb) {
  char *t, *te;
  int i, j, k;
  t = tb;
  te = tb + 252;
  s = BGBCC_SHXA_EatWhite(s);
  if (!(*s)) {
    *t++ = 0;
    *t++ = 0;
    return (s);
  }
  if ((*s == '_') || (*s == '$') || (*s == '.') || (*s == '/') ||
      ((*s >= 'A') && (*s <= 'Z')) || ((*s >= 'a') && (*s <= 'z'))) {
    *t++ = 'I';
    while (*s && (t < te) &&
           ((*s == '_') || (*s == '$') || (*s == '.') || (*s == '/') ||
            ((*s >= 'A') && (*s <= 'Z')) || ((*s >= 'a') && (*s <= 'z')) ||
            ((*s >= '0') && (*s <= '9'))))
      *t++ = *s++;
    *t++ = 0;
    return (s);
  }
  if ((*s == '-') && ((s[1] >= '0') && (s[1] <= '9'))) {
    *t++ = '|';
    *t++ = *s++;
    while (*s && (t < te) && ((*s == '_') || ((*s >= '0') && (*s <= '9'))))
      *t++ = *s++;
    *t++ = 0;
    return (s);
  }
  s = BGBCC_SHXA_ParseTokenBasic(s, tb);
  return (s);
}


x86 assembly (clang, -O0):
<BGBCC_SHXA_ParseTokenBasicAltn>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
add    $0xfc,%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <BGBCC_SHXA_EatWhite@plt>
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
cmpb   $0x0,(%rax)
jne    1191 <BGBCC_SHXA_ParseTokenBasicAltn+0x71>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movb   $0x0,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movb   $0x0,(%rax)
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    14b3 <BGBCC_SHXA_ParseTokenBasicAltn+0x393>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5f,%eax
je     1211 <BGBCC_SHXA_ParseTokenBasicAltn+0xf1>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x24,%eax
je     1211 <BGBCC_SHXA_ParseTokenBasicAltn+0xf1>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
je     1211 <BGBCC_SHXA_ParseTokenBasicAltn+0xf1>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2f,%eax
je     1211 <BGBCC_SHXA_ParseTokenBasicAltn+0xf1>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x41,%eax
jl     11f1 <BGBCC_SHXA_ParseTokenBasicAltn+0xd1>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5a,%eax
jle    1211 <BGBCC_SHXA_ParseTokenBasicAltn+0xf1>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x61,%eax
jl     1370 <BGBCC_SHXA_ParseTokenBasicAltn+0x250>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x7a,%eax
jg     1370 <BGBCC_SHXA_ParseTokenBasicAltn+0x250>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movb   $0x49,(%rax)
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x35(%rbp)
je     131a <BGBCC_SHXA_ParseTokenBasicAltn+0x1fa>
mov    -0x20(%rbp),%rcx
xor    %eax,%eax
cmp    -0x28(%rbp),%rcx
mov    %al,-0x35(%rbp)
jae    131a <BGBCC_SHXA_ParseTokenBasicAltn+0x1fa>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x5f,%ecx
mov    %al,-0x36(%rbp)
je     1314 <BGBCC_SHXA_ParseTokenBasicAltn+0x1f4>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x24,%ecx
mov    %al,-0x36(%rbp)
je     1314 <BGBCC_SHXA_ParseTokenBasicAltn+0x1f4>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x2e,%ecx
mov    %al,-0x36(%rbp)
je     1314 <BGBCC_SHXA_ParseTokenBasicAltn+0x1f4>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x2f,%ecx
mov    %al,-0x36(%rbp)
je     1314 <BGBCC_SHXA_ParseTokenBasicAltn+0x1f4>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x41,%eax
jl     12c4 <BGBCC_SHXA_ParseTokenBasicAltn+0x1a4>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x5a,%ecx
mov    %al,-0x36(%rbp)
jle    1314 <BGBCC_SHXA_ParseTokenBasicAltn+0x1f4>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x61,%eax
jl     12e9 <BGBCC_SHXA_ParseTokenBasicAltn+0x1c9>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x7a,%ecx
mov    %al,-0x36(%rbp)
jle    1314 <BGBCC_SHXA_ParseTokenBasicAltn+0x1f4>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x30,%ecx
mov    %al,-0x37(%rbp)
jl     130e <BGBCC_SHXA_ParseTokenBasicAltn+0x1ee>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x39,%eax
setle  %al
mov    %al,-0x37(%rbp)
mov    -0x37(%rbp),%al
mov    %al,-0x36(%rbp)
mov    -0x36(%rbp),%al
mov    %al,-0x35(%rbp)
mov    -0x35(%rbp),%al
test   $0x1,%al
jne    132a <BGBCC_SHXA_ParseTokenBasicAltn+0x20a>
jmp    1351 <BGBCC_SHXA_ParseTokenBasicAltn+0x231>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
jmp    1223 <BGBCC_SHXA_ParseTokenBasicAltn+0x103>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movb   $0x0,(%rax)
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    14b3 <BGBCC_SHXA_ParseTokenBasicAltn+0x393>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
jne    149a <BGBCC_SHXA_ParseTokenBasicAltn+0x37a>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x30,%eax
jl     149a <BGBCC_SHXA_ParseTokenBasicAltn+0x37a>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x39,%eax
jg     149a <BGBCC_SHXA_ParseTokenBasicAltn+0x37a>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movb   $0x7c,(%rax)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x38(%rbp)
je     1444 <BGBCC_SHXA_ParseTokenBasicAltn+0x324>
mov    -0x20(%rbp),%rcx
xor    %eax,%eax
cmp    -0x28(%rbp),%rcx
mov    %al,-0x38(%rbp)
jae    1444 <BGBCC_SHXA_ParseTokenBasicAltn+0x324>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x5f,%ecx
mov    %al,-0x39(%rbp)
je     143e <BGBCC_SHXA_ParseTokenBasicAltn+0x31e>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x30,%ecx
mov    %al,-0x3a(%rbp)
jl     1438 <BGBCC_SHXA_ParseTokenBasicAltn+0x318>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x39,%eax
setle  %al
mov    %al,-0x3a(%rbp)
mov    -0x3a(%rbp),%al
mov    %al,-0x39(%rbp)
mov    -0x39(%rbp),%al
mov    %al,-0x38(%rbp)
mov    -0x38(%rbp),%al
test   $0x1,%al
jne    1454 <BGBCC_SHXA_ParseTokenBasicAltn+0x334>
jmp    147b <BGBCC_SHXA_ParseTokenBasicAltn+0x35b>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
jmp    13d6 <BGBCC_SHXA_ParseTokenBasicAltn+0x2b6>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movb   $0x0,(%rax)
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    14b3 <BGBCC_SHXA_ParseTokenBasicAltn+0x393>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
call   1040 <BGBCC_SHXA_ParseTokenBasic@plt>
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<BGBCC_SHXA_ParseTokenBasicAltn>:
push   %rbx
mov    %rsi,%rbx
call   1030 <BGBCC_SHXA_EatWhite@plt>
mov    %rax,%r8
mov    (%rax),%sil
lea    -0x24(%rsi),%edi
movabs $0x800000000000c01,%r9
cmp    $0x3b,%dil
ja     11bf <BGBCC_SHXA_ParseTokenBasicAltn+0x9f>
movzbl %dil,%edi
bt     %rdi,%r9
jae    11bf <BGBCC_SHXA_ParseTokenBasicAltn+0x9f>
movb   $0x49,(%rbx)
mov    (%rax),%cl
test   %cl,%cl
je     11cb <BGBCC_SHXA_ParseTokenBasicAltn+0xab>
mov    $0x1,%esi
nopw   0x0(%rax,%rax,1)
lea    -0x24(%rcx),%edi
cmp    $0x3b,%dil
ja     11a0 <BGBCC_SHXA_ParseTokenBasicAltn+0x80>
movzbl %dil,%edi
bt     %rdi,%r9
jae    11a0 <BGBCC_SHXA_ParseTokenBasicAltn+0x80>
lea    0x1(%rsi),%rdi
mov    %cl,(%rbx,%rsi,1)
movzbl 0x1(%rax),%ecx
add    $0x1,%rax
test   %cl,%cl
je     11ba <BGBCC_SHXA_ParseTokenBasicAltn+0x9a>
cmp    $0xfb,%rsi
mov    %rdi,%rsi
jb     1160 <BGBCC_SHXA_ParseTokenBasicAltn+0x40>
jmp    11ba <BGBCC_SHXA_ParseTokenBasicAltn+0x9a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %ecx,%edx
and    $0xdf,%dl
add    $0xbf,%dl
cmp    $0x1a,%dl
jb     1173 <BGBCC_SHXA_ParseTokenBasicAltn+0x53>
lea    -0x30(%rcx),%edx
cmp    $0x9,%dl
jbe    1173 <BGBCC_SHXA_ParseTokenBasicAltn+0x53>
add    %rsi,%rbx
jmp    11cf <BGBCC_SHXA_ParseTokenBasicAltn+0xaf>
add    %rdi,%rbx
jmp    11cf <BGBCC_SHXA_ParseTokenBasicAltn+0xaf>
test   %sil,%sil
jne    11d4 <BGBCC_SHXA_ParseTokenBasicAltn+0xb4>
movw   $0x0,(%rbx)
pop    %rbx
ret
add    $0x1,%rbx
movb   $0x0,(%rbx)
pop    %rbx
ret
mov    %esi,%ecx
and    $0xdf,%cl
add    $0xbf,%cl
cmp    $0x19,%cl
jbe    114c <BGBCC_SHXA_ParseTokenBasicAltn+0x2c>
cmp    $0x2d,%sil
jne    1241 <BGBCC_SHXA_ParseTokenBasicAltn+0x121>
mov    0x1(%rax),%cl
add    $0xd0,%cl
cmp    $0x9,%cl
ja     1241 <BGBCC_SHXA_ParseTokenBasicAltn+0x121>
add    $0x1,%r8
movb   $0x7c,(%rbx)
mov    (%rax),%cl
mov    %cl,0x1(%rbx)
mov    0x1(%rax),%al
test   %al,%al
je     124d <BGBCC_SHXA_ParseTokenBasicAltn+0x12d>
mov    $0x2,%edx
xchg   %ax,%ax
cmp    $0x5f,%al
je     121c <BGBCC_SHXA_ParseTokenBasicAltn+0xfc>
lea    -0x30(%rax),%ecx
cmp    $0x9,%cl
ja     1253 <BGBCC_SHXA_ParseTokenBasicAltn+0x133>
lea    0x1(%rdx),%rsi
mov    %al,(%rbx,%rdx,1)
movzbl 0x1(%r8),%eax
add    $0x1,%r8
test   %al,%al
je     123c <BGBCC_SHXA_ParseTokenBasicAltn+0x11c>
cmp    $0xfb,%rdx
mov    %rsi,%rdx
jb     1210 <BGBCC_SHXA_ParseTokenBasicAltn+0xf0>
add    %rsi,%rbx
jmp    1256 <BGBCC_SHXA_ParseTokenBasicAltn+0x136>
mov    %rax,%rdi
mov    %rbx,%rsi
pop    %rbx
jmp    1040 <BGBCC_SHXA_ParseTokenBasic@plt>
add    $0x2,%rbx
jmp    1256 <BGBCC_SHXA_ParseTokenBasicAltn+0x136>
add    %rdx,%rbx
movb   $0x0,(%rbx)
mov    %r8,%rax
pop    %rbx
ret

LLVM IR (-O0):
define i8* @BGBCC_SHXA_ParseTokenBasicAltn(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
store i8* %0, i8** %4
store i8* %1, i8** %5
%11 = load i8*, i8** %5
store i8* %11, i8** %6
%12 = load i8*, i8** %5
%13 = getelementptr inbounds i8, i8* %12, i64 252
store i8* %13, i8** %7
%14 = load i8*, i8** %4
%15 = call i8* @BGBCC_SHXA_EatWhite(i8* %14)
store i8* %15, i8** %4
%16 = load i8*, i8** %4
%17 = load i8, i8* %16
%18 = icmp ne i8 %17, 0
br i1 %18, label %25, label %19
19: ; preds = %2
%20 = load i8*, i8** %6
%21 = getelementptr inbounds i8, i8* %20, i32 1
store i8* %21, i8** %6
store i8 0, i8* %20
%22 = load i8*, i8** %6
%23 = getelementptr inbounds i8, i8* %22, i32 1
store i8* %23, i8** %6
store i8 0, i8* %22
%24 = load i8*, i8** %4
store i8* %24, i8** %3
br label %213
25: ; preds = %2
%26 = load i8*, i8** %4
%27 = load i8, i8* %26
%28 = sext i8 %27 to i32
%29 = icmp eq i32 %28, 95
br i1 %29, label %65, 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, 36
br i1 %34, label %65, label %35
35: ; preds = %30
%36 = load i8*, i8** %4
%37 = load i8, i8* %36
%38 = sext i8 %37 to i32
%39 = icmp eq i32 %38, 46
br i1 %39, label %65, label %40
40: ; preds = %35
%41 = load i8*, i8** %4
%42 = load i8, i8* %41
%43 = sext i8 %42 to i32
%44 = icmp eq i32 %43, 47
br i1 %44, label %65, label %45
45: ; preds = %40
%46 = load i8*, i8** %4
%47 = load i8, i8* %46
%48 = sext i8 %47 to i32
%49 = icmp sge i32 %48, 65
br i1 %49, label %50, label %55
50: ; preds = %45
%51 = load i8*, i8** %4
%52 = load i8, i8* %51
%53 = sext i8 %52 to i32
%54 = icmp sle i32 %53, 90
br i1 %54, label %65, label %55
55: ; preds = %50, %45
%56 = load i8*, i8** %4
%57 = load i8, i8* %56
%58 = sext i8 %57 to i32
%59 = icmp sge i32 %58, 97
br i1 %59, label %60, label %143
60: ; preds = %55
%61 = load i8*, i8** %4
%62 = load i8, i8* %61
%63 = sext i8 %62 to i32
%64 = icmp sle i32 %63, 122
br i1 %64, label %65, label %143
65: ; preds = %60, %50, %40, %35, %30, %25
%66 = load i8*, i8** %6
%67 = getelementptr inbounds i8, i8* %66, i32 1
store i8* %67, i8** %6
store i8 73, i8* %66
br label %68
68: ; preds = %133, %65
%69 = load i8*, i8** %4
%70 = load i8, i8* %69
%71 = sext i8 %70 to i32
%72 = icmp ne i32 %71, 0
br i1 %72, label %73, label %131
73: ; preds = %68
%74 = load i8*, i8** %6
%75 = load i8*, i8** %7
%76 = icmp ult i8* %74, %75
br i1 %76, label %77, label %131
77: ; preds = %73
%78 = load i8*, i8** %4
%79 = load i8, i8* %78
%80 = sext i8 %79 to i32
%81 = icmp eq i32 %80, 95
br i1 %81, label %129, label %82
82: ; preds = %77
%83 = load i8*, i8** %4
%84 = load i8, i8* %83
%85 = sext i8 %84 to i32
%86 = icmp eq i32 %85, 36
br i1 %86, label %129, label %87
87: ; preds = %82
%88 = load i8*, i8** %4
%89 = load i8, i8* %88
%90 = sext i8 %89 to i32
%91 = icmp eq i32 %90, 46
br i1 %91, label %129, label %92
92: ; preds = %87
%93 = load i8*, i8** %4
%94 = load i8, i8* %93
%95 = sext i8 %94 to i32
%96 = icmp eq i32 %95, 47
br i1 %96, label %129, label %97
97: ; preds = %92
%98 = load i8*, i8** %4
%99 = load i8, i8* %98
%100 = sext i8 %99 to i32
%101 = icmp sge i32 %100, 65
br i1 %101, label %102, label %107
102: ; preds = %97
%103 = load i8*, i8** %4
%104 = load i8, i8* %103
%105 = sext i8 %104 to i32
%106 = icmp sle i32 %105, 90
br i1 %106, label %129, label %107
107: ; preds = %102, %97
%108 = load i8*, i8** %4
%109 = load i8, i8* %108
%110 = sext i8 %109 to i32
%111 = icmp sge i32 %110, 97
br i1 %111, label %112, label %117
112: ; preds = %107
%113 = load i8*, i8** %4
%114 = load i8, i8* %113
%115 = sext i8 %114 to i32
%116 = icmp sle i32 %115, 122
br i1 %116, label %129, label %117
117: ; preds = %112, %107
%118 = load i8*, i8** %4
%119 = load i8, i8* %118
%120 = sext i8 %119 to i32
%121 = icmp sge i32 %120, 48
br i1 %121, label %122, label %127
122: ; preds = %117
%123 = load i8*, i8** %4
%124 = load i8, i8* %123
%125 = sext i8 %124 to i32
%126 = icmp sle i32 %125, 57
br label %127
127: ; preds = %122, %117
%128 = phi i1 [ false, %117 ], [ %126, %122 ]
br label %129
129: ; preds = %127, %112, %102, %92, %87, %82, %77
%130 = phi i1 [ true, %112 ], [ true, %102 ], [ true, %92 ], [ true, %87 ], [ true, %82 ], [ true, %77 ], [ %128, %127 ]
br label %131
131: ; preds = %129, %73, %68
%132 = phi i1 [ false, %73 ], [ false, %68 ], [ %130, %129 ]
br i1 %132, label %133, label %139
133: ; preds = %131
%134 = load i8*, i8** %4
%135 = getelementptr inbounds i8, i8* %134, i32 1
store i8* %135, i8** %4
%136 = load i8, i8* %134
%137 = load i8*, i8** %6
%138 = getelementptr inbounds i8, i8* %137, i32 1
store i8* %138, i8** %6
store i8 %136, i8* %137
br label %68
139: ; preds = %131
%140 = load i8*, i8** %6
%141 = getelementptr inbounds i8, i8* %140, i32 1
store i8* %141, i8** %6
store i8 0, i8* %140
%142 = load i8*, i8** %4
store i8* %142, i8** %3
br label %213
143: ; preds = %60, %55
%144 = load i8*, i8** %4
%145 = load i8, i8* %144
%146 = sext i8 %145 to i32
%147 = icmp eq i32 %146, 45
br i1 %147, label %148, label %208
148: ; preds = %143
%149 = load i8*, i8** %4
%150 = getelementptr inbounds i8, i8* %149, i64 1
%151 = load i8, i8* %150
%152 = sext i8 %151 to i32
%153 = icmp sge i32 %152, 48
br i1 %153, label %154, label %208
154: ; preds = %148
%155 = load i8*, i8** %4
%156 = getelementptr inbounds i8, i8* %155, i64 1
%157 = load i8, i8* %156
%158 = sext i8 %157 to i32
%159 = icmp sle i32 %158, 57
br i1 %159, label %160, label %208
160: ; preds = %154
%161 = load i8*, i8** %6
%162 = getelementptr inbounds i8, i8* %161, i32 1
store i8* %162, i8** %6
store i8 124, i8* %161
%163 = load i8*, i8** %4
%164 = getelementptr inbounds i8, i8* %163, i32 1
store i8* %164, i8** %4
%165 = load i8, i8* %163
%166 = load i8*, i8** %6
%167 = getelementptr inbounds i8, i8* %166, i32 1
store i8* %167, i8** %6
store i8 %165, i8* %166
br label %168
168: ; preds = %198, %160
%169 = load i8*, i8** %4
%170 = load i8, i8* %169
%171 = sext i8 %170 to i32
%172 = icmp ne i32 %171, 0
br i1 %172, label %173, label %196
173: ; preds = %168
%174 = load i8*, i8** %6
%175 = load i8*, i8** %7
%176 = icmp ult i8* %174, %175
br i1 %176, label %177, label %196
177: ; preds = %173
%178 = load i8*, i8** %4
%179 = load i8, i8* %178
%180 = sext i8 %179 to i32
%181 = icmp eq i32 %180, 95
br i1 %181, label %194, label %182
182: ; preds = %177
%183 = load i8*, i8** %4
%184 = load i8, i8* %183
%185 = sext i8 %184 to i32
%186 = icmp sge i32 %185, 48
br i1 %186, label %187, label %192
187: ; preds = %182
%188 = load i8*, i8** %4
%189 = load i8, i8* %188
%190 = sext i8 %189 to i32
%191 = icmp sle i32 %190, 57
br label %192
192: ; preds = %187, %182
%193 = phi i1 [ false, %182 ], [ %191, %187 ]
br label %194
194: ; preds = %192, %177
%195 = phi i1 [ true, %177 ], [ %193, %192 ]
br label %196
196: ; preds = %194, %173, %168
%197 = phi i1 [ false, %173 ], [ false, %168 ], [ %195, %194 ]
br i1 %197, label %198, label %204
198: ; preds = %196
%199 = load i8*, i8** %4
%200 = getelementptr inbounds i8, i8* %199, i32 1
store i8* %200, i8** %4
%201 = load i8, i8* %199
%202 = load i8*, i8** %6
%203 = getelementptr inbounds i8, i8* %202, i32 1
store i8* %203, i8** %6
store i8 %201, i8* %202
br label %168
204: ; preds = %196
%205 = load i8*, i8** %6
%206 = getelementptr inbounds i8, i8* %205, i32 1
store i8* %206, i8** %6
store i8 0, i8* %205
%207 = load i8*, i8** %4
store i8* %207, i8** %3
br label %213
208: ; preds = %154, %148, %143
%209 = load i8*, i8** %4
%210 = load i8*, i8** %5
%211 = call i8* @BGBCC_SHXA_ParseTokenBasic(i8* %209, i8* %210)
store i8* %211, i8** %4
%212 = load i8*, i8** %4
store i8* %212, i8** %3
br label %213
213: ; preds = %208, %204, %139, %19
%214 = load i8*, i8** %3
ret i8* %214
}

LLVM IR (-O2):
define i8* @BGBCC_SHXA_ParseTokenBasicAltn(i8* %0, i8* %1) {
%3 = tail call i8* @BGBCC_SHXA_EatWhite(i8* %0)
%4 = load i8, i8* %3
switch i8 %4, label %7 [
i8 0, label %5
i8 95, label %11
i8 36, label %11
i8 46, label %11
i8 47, label %11
]
5: ; preds = %2
%6 = getelementptr inbounds i8, i8* %1, i64 1
store i8 0, i8* %1
store i8 0, i8* %6
br label %73
7: ; preds = %2
%8 = and i8 %4, -33
%9 = add i8 %8, -65
%10 = icmp ult i8 %9, 26
br i1 %10, label %11, label %38
11: ; preds = %7, %2, %2, %2, %2
store i8 73, i8* %1
%12 = getelementptr inbounds i8, i8* %1, i64 1
%13 = load i8, i8* %3
%14 = icmp eq i8 %13, 0
br i1 %14, label %35, label %15
15: ; preds = %11, %27
%16 = phi i8 [ %31, %27 ], [ %13, %11 ]
%17 = phi i8* [ %30, %27 ], [ %12, %11 ]
%18 = phi i8* [ %28, %27 ], [ %3, %11 ]
%19 = phi i64 [ %29, %27 ], [ 1, %11 ]
switch i8 %16, label %20 [
i8 95, label %27
i8 36, label %27
i8 46, label %27
i8 47, label %27
]
20: ; preds = %15
%21 = and i8 %16, -33
%22 = add i8 %21, -65
%23 = icmp ult i8 %22, 26
%24 = add i8 %16, -48
%25 = icmp ult i8 %24, 10
%26 = select i1 %23, i1 true, i1 %25
br i1 %26, label %27, label %35
27: ; preds = %20, %15, %15, %15, %15
%28 = getelementptr inbounds i8, i8* %18, i64 1
%29 = add nuw nsw i64 %19, 1
store i8 %16, i8* %17
%30 = getelementptr inbounds i8, i8* %1, i64 %29
%31 = load i8, i8* %28
%32 = icmp ne i8 %31, 0
%33 = icmp ult i64 %19, 251
%34 = select i1 %32, i1 %33, i1 false
br i1 %34, label %15, label %35
35: ; preds = %27, %20, %11
%36 = phi i8* [ %3, %11 ], [ %18, %20 ], [ %28, %27 ]
%37 = phi i8* [ %12, %11 ], [ %17, %20 ], [ %30, %27 ]
store i8 0, i8* %37
br label %73
38: ; preds = %7
%39 = icmp eq i8 %4, 45
br i1 %39, label %40, label %71
40: ; preds = %38
%41 = getelementptr inbounds i8, i8* %3, i64 1
%42 = load i8, i8* %41
%43 = add i8 %42, -48
%44 = icmp ult i8 %43, 10
br i1 %44, label %45, label %71
45: ; preds = %40
%46 = getelementptr inbounds i8, i8* %1, i64 1
store i8 124, i8* %1
%47 = load i8, i8* %3
store i8 %47, i8* %46
%48 = getelementptr inbounds i8, i8* %1, i64 2
%49 = load i8, i8* %41
%50 = icmp eq i8 %49, 0
br i1 %50, label %68, label %51
51: ; preds = %45, %60
%52 = phi i8 [ %64, %60 ], [ %49, %45 ]
%53 = phi i8* [ %63, %60 ], [ %48, %45 ]
%54 = phi i8* [ %62, %60 ], [ %41, %45 ]
%55 = phi i64 [ %61, %60 ], [ 2, %45 ]
%56 = icmp eq i8 %52, 95
%57 = add i8 %52, -48
%58 = icmp ult i8 %57, 10
%59 = or i1 %56, %58
br i1 %59, label %60, label %68
60: ; preds = %51
%61 = add nuw nsw i64 %55, 1
store i8 %52, i8* %53
%62 = getelementptr inbounds i8, i8* %54, i64 1
%63 = getelementptr inbounds i8, i8* %1, i64 %61
%64 = load i8, i8* %62
%65 = icmp ne i8 %64, 0
%66 = icmp ult i64 %55, 251
%67 = select i1 %65, i1 %66, i1 false
br i1 %67, label %51, label %68
68: ; preds = %60, %51, %45
%69 = phi i8* [ %41, %45 ], [ %54, %51 ], [ %62, %60 ]
%70 = phi i8* [ %48, %45 ], [ %53, %51 ], [ %63, %60 ]
store i8 0, i8* %70
br label %73
71: ; preds = %40, %38
%72 = tail call i8* @BGBCC_SHXA_ParseTokenBasic(i8* %3, i8* %1)
br label %73
73: ; preds = %71, %68, %35, %5
%74 = phi i8* [ %36, %35 ], [ %69, %68 ], [ %72, %71 ], [ %3, %5 ]
ret i8* %74
}