#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 */
int /*<<< orphan*/ is_sep(char);
int nextchar(char *, int);
char *getval(char *a, unsigned int *par) {
  static int i, cnt;
  static unsigned int val;
  cnt = 0;
  *par = 0;
  i = 0;
  if (a[i] == '#' || (a[i] >= '0' && a[i] <= '9')) {
    if (a[i] == '#')
      i = nextchar(a, i);
    while (!is_sep(a[i])) {
      if (a[i] >= '0' && a[i] <= '9')
        val = a[i] - '0';
      else
        return NULL;
      *par = *par * 10 + val;
      cnt = cnt + 1;
      i = i + 1;
    }
    if (cnt == 0)
      return NULL;
    return &a[i];
  }
  if (a[i] == '$') {
    i = nextchar(a, i + 1);
    while (!is_sep(a[i])) {
      if (a[i] >= '0' && a[i] <= '9')
        val = a[i] - '0';
      else if (a[i] >= 'a' && a[i] <= 'f')
        val = a[i] - 'a' + 10;
      else
        return NULL;
      *par = *par * 16 + val;
      cnt = cnt + 1;
      i = i + 1;
    }
    if (cnt == 0)
      return NULL;
    return &a[i];
  }
  if (a[i] == '%') {
    i = nextchar(a, i + 1);
    while (!is_sep(a[i])) {
      if (a[i] == '0')
        val = 0;
      else if (a[i] == '1')
        val = 1;
      else
        return NULL;
      *par = *par * 2 + val;
      cnt = cnt + 1;
      i = i + 1;
    }
    if (cnt == 0)
      return NULL;
    return &a[i];
  }
  return NULL;
}


x86 assembly (clang, -O0):
<getval>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movl   $0x0,0x2efe(%rip)
mov    -0x18(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,0x2ee6(%rip)
mov    -0x10(%rbp),%rax
movslq 0x2edb(%rip),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x23,%eax
je     1196 <getval+0x76>
mov    -0x10(%rbp),%rax
movslq 0x2ec3(%rip),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
jl     12b2 <getval+0x192>
mov    -0x10(%rbp),%rax
movslq 0x2eab(%rip),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x39,%eax
jg     12b2 <getval+0x192>
mov    -0x10(%rbp),%rax
movslq 0x2e93(%rip),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x23,%eax
jne    11c3 <getval+0xa3>
mov    -0x10(%rbp),%rdi
mov    0x2e7c(%rip),%esi
call   1040 <nextchar@plt>
mov    %eax,0x2e71(%rip)
jmp    11c8 <getval+0xa8>
mov    -0x10(%rbp),%rax
movslq 0x2e61(%rip),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <is_sep@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    11f1 <getval+0xd1>
jmp    1281 <getval+0x161>
mov    -0x10(%rbp),%rax
movslq 0x2e38(%rip),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
jl     123e <getval+0x11e>
mov    -0x10(%rbp),%rax
movslq 0x2e20(%rip),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x39,%eax
jg     123e <getval+0x11e>
mov    -0x10(%rbp),%rax
movslq 0x2e08(%rip),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
mov    %eax,0x2e03(%rip)
jmp    124b <getval+0x12b>
movq   $0x0,-0x8(%rbp)
jmp    154d <getval+0x42d>
mov    -0x18(%rbp),%rax
imul   $0xa,(%rax),%ecx
add    0x2de4(%rip),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    0x2dd4(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2dcb(%rip)
mov    0x2dc1(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2db8(%rip)
jmp    11c8 <getval+0xa8>
cmpl   $0x0,0x2db0(%rip)
jne    129b <getval+0x17b>
movq   $0x0,-0x8(%rbp)
jmp    154d <getval+0x42d>
mov    -0x10(%rbp),%rax
movslq 0x2d8e(%rip),%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
jmp    154d <getval+0x42d>
mov    -0x10(%rbp),%rax
movslq 0x2d77(%rip),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x24,%eax
jne    1423 <getval+0x303>
mov    -0x10(%rbp),%rdi
mov    0x2d60(%rip),%esi
add    $0x1,%esi
call   1040 <nextchar@plt>
mov    %eax,0x2d52(%rip)
mov    -0x10(%rbp),%rax
movslq 0x2d47(%rip),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <is_sep@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    130b <getval+0x1eb>
jmp    13f2 <getval+0x2d2>
mov    -0x10(%rbp),%rax
movslq 0x2d1e(%rip),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
jl     1358 <getval+0x238>
mov    -0x10(%rbp),%rax
movslq 0x2d06(%rip),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x39,%eax
jg     1358 <getval+0x238>
mov    -0x10(%rbp),%rax
movslq 0x2cee(%rip),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
mov    %eax,0x2ce9(%rip)
jmp    13ba <getval+0x29a>
mov    -0x10(%rbp),%rax
movslq 0x2cd1(%rip),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x61,%eax
jl     13a8 <getval+0x288>
mov    -0x10(%rbp),%rax
movslq 0x2cb9(%rip),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x66,%eax
jg     13a8 <getval+0x288>
mov    -0x10(%rbp),%rax
movslq 0x2ca1(%rip),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x61,%eax
add    $0xa,%eax
mov    %eax,0x2c99(%rip)
jmp    13b5 <getval+0x295>
movq   $0x0,-0x8(%rbp)
jmp    154d <getval+0x42d>
jmp    13ba <getval+0x29a>
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
shl    $0x4,%ecx
add    0x2c73(%rip),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    0x2c63(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2c5a(%rip)
mov    0x2c50(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2c47(%rip)
jmp    12e2 <getval+0x1c2>
cmpl   $0x0,0x2c3f(%rip)
jne    140c <getval+0x2ec>
movq   $0x0,-0x8(%rbp)
jmp    154d <getval+0x42d>
mov    -0x10(%rbp),%rax
movslq 0x2c1d(%rip),%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
jmp    154d <getval+0x42d>
mov    -0x10(%rbp),%rax
movslq 0x2c06(%rip),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x25,%eax
jne    1545 <getval+0x425>
mov    -0x10(%rbp),%rdi
mov    0x2bef(%rip),%esi
add    $0x1,%esi
call   1040 <nextchar@plt>
mov    %eax,0x2be1(%rip)
mov    -0x10(%rbp),%rax
movslq 0x2bd6(%rip),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <is_sep@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    147c <getval+0x35c>
jmp    1514 <getval+0x3f4>
mov    -0x10(%rbp),%rax
movslq 0x2bad(%rip),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
jne    14a3 <getval+0x383>
movl   $0x0,0x2b9e(%rip)
jmp    14dc <getval+0x3bc>
mov    -0x10(%rbp),%rax
movslq 0x2b86(%rip),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x31,%eax
jne    14ca <getval+0x3aa>
movl   $0x1,0x2b77(%rip)
jmp    14d7 <getval+0x3b7>
movq   $0x0,-0x8(%rbp)
jmp    154d <getval+0x42d>
jmp    14dc <getval+0x3bc>
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
shl    $0x1,%ecx
add    0x2b51(%rip),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    0x2b41(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2b38(%rip)
mov    0x2b2e(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2b25(%rip)
jmp    1453 <getval+0x333>
cmpl   $0x0,0x2b1d(%rip)
jne    152e <getval+0x40e>
movq   $0x0,-0x8(%rbp)
jmp    154d <getval+0x42d>
mov    -0x10(%rbp),%rax
movslq 0x2afb(%rip),%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
jmp    154d <getval+0x42d>
movq   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getval>:
push   %r15
push   %r14
push   %rbx
mov    %rsi,%r14
mov    %rdi,%rbx
movl   $0x0,0x2f03(%rip)
movl   $0x0,(%rsi)
movl   $0x0,0x2eef(%rip)
mov    (%rdi),%al
cmp    $0x23,%al
jne    1162 <getval+0x42>
mov    %rbx,%rdi
xor    %esi,%esi
call   1040 <nextchar@plt>
mov    %eax,0x2ed9(%rip)
cltq
mov    (%rbx,%rax,1),%al
jmp    116a <getval+0x4a>
lea    -0x30(%rax),%ecx
cmp    $0xa,%cl
jae    11c7 <getval+0xa7>
movsbl %al,%edi
call   1030 <is_sep@plt>
test   %eax,%eax
jne    11f9 <getval+0xd9>
xor    %r15d,%r15d
nopl   (%rax)
movslq 0x2ead(%rip),%rax
movzbl (%rbx,%rax,1),%ecx
lea    -0x30(%rcx),%edx
cmp    $0x9,%dl
ja     1279 <getval+0x159>
mov    (%r14),%edx
lea    (%rdx,%rdx,4),%edx
lea    (%rcx,%rdx,2),%ecx
add    $0xffffffd0,%ecx
mov    %ecx,(%r14)
addl   $0x1,0x2e8b(%rip)
lea    0x1(%rax),%rcx
mov    %ecx,0x2e7d(%rip)
movsbl 0x1(%rbx,%rax,1),%edi
call   1030 <is_sep@plt>
test   %eax,%eax
je     1180 <getval+0x60>
jmp    11f9 <getval+0xd9>
cmp    $0x25,%al
je     1211 <getval+0xf1>
cmp    $0x24,%al
jne    1276 <getval+0x156>
mov    %rbx,%rdi
mov    $0x1,%esi
call   1040 <nextchar@plt>
mov    %eax,0x2e4e(%rip)
cltq
movsbl (%rbx,%rax,1),%edi
call   1030 <is_sep@plt>
test   %eax,%eax
je     1282 <getval+0x162>
cmpl   $0x0,0x2e38(%rip)
je     1276 <getval+0x156>
movslq 0x2e2b(%rip),%rax
add    %rax,%rbx
mov    %rbx,%r15
jmp    1279 <getval+0x159>
mov    %rbx,%rdi
mov    $0x1,%esi
call   1040 <nextchar@plt>
mov    %eax,0x2e10(%rip)
cltq
movsbl (%rbx,%rax,1),%edi
jmp    124f <getval+0x12f>
nopl   0x0(%rax)
mov    (%r14),%edx
lea    (%rcx,%rdx,2),%ecx
mov    %ecx,(%r14)
addl   $0x1,0x2df8(%rip)
lea    0x1(%rax),%rcx
mov    %ecx,0x2dea(%rip)
movsbl 0x1(%rbx,%rax,1),%edi
call   1030 <is_sep@plt>
test   %eax,%eax
jne    11f9 <getval+0xd9>
movslq 0x2dd5(%rip),%rax
movzbl (%rbx,%rax,1),%edx
xor    %ecx,%ecx
cmp    $0x30,%dl
je     1230 <getval+0x110>
cmp    $0x31,%dl
jne    1276 <getval+0x156>
mov    $0x1,%ecx
jmp    1230 <getval+0x110>
xor    %r15d,%r15d
mov    %r15,%rax
pop    %rbx
pop    %r14
pop    %r15
ret
xor    %r15d,%r15d
jmp    12c0 <getval+0x1a0>
nopw   0x0(%rax,%rax,1)
add    %ecx,%edx
mov    (%r14),%ecx
shl    $0x4,%ecx
add    %edx,%ecx
mov    %ecx,(%r14)
addl   $0x1,0x2d94(%rip)
lea    0x1(%rax),%rcx
mov    %ecx,0x2d86(%rip)
movsbl 0x1(%rbx,%rax,1),%edi
call   1030 <is_sep@plt>
test   %eax,%eax
jne    11f9 <getval+0xd9>
movslq 0x2d6d(%rip),%rax
movsbl (%rbx,%rax,1),%ecx
lea    -0x30(%rcx),%esi
mov    $0xffffffd0,%edx
cmp    $0xa,%sil
jb     1290 <getval+0x170>
lea    -0x61(%rcx),%esi
mov    $0xffffffa9,%edx
cmp    $0x5,%sil
jbe    1290 <getval+0x170>
jmp    1279 <getval+0x159>

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

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