#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 _instr(char *, int, int, int (*)(int, int), int (*)(int, int), int, int,
           int *);
scalar_t__ isdigit(char);
int stub1(int, int);
int stub2(int, int);
int stub3(int, int);
int stub4(int, int);
int stub5(int, int);
int _innum(int **ptr, int type, int len, int size, int (*getch)(int, int),
           int (*ungetch)(int, int), int arg1, int arg2, int *eofptr) {
  extern double atof(char *p);
  register char *np;
  char numbuf[64];
  register char c, base;
  int expseen, negflg, c1, ndigit;
  long lcval;
  if (type == 'c' || type == 's' || type == '[') {
    return (_instr(ptr ? *(char **)ptr : (char *)0, type, len, getch, ungetch,
                   arg1, arg2, eofptr));
  }
  lcval = 0;
  ndigit = 0;
  base = 10;
  if (type == 'o') {
    base = 8;
  } else if (type == 'x') {
    base = 16;
  }
  np = numbuf;
  expseen = 0;
  negflg = 0;
  while ((c = (*getch)(arg1, arg2)) == ' ' || c == '\t' || c == '\n') {
    ;
  }
  if (c == '-') {
    negflg++;
    *np++ = c;
    c = (*getch)(arg1, arg2);
    len--;
  } else if (c == '+') {
    len--;
    c = (*getch)(arg1, arg2);
  }
  for (; --len >= 0; *np++ = c, c = (*getch)(arg1, arg2)) {
    if (((isdigit(c)) || base == 16) &&
        (('a' <= c && c <= 'f') || ('A' <= c && c <= 'F'))) {
      ndigit++;
      if (base == 8) {
        lcval <<= 3;
      } else if (base == 10) {
        lcval = ((lcval << 2) + lcval) << 1;
      } else {
        lcval <<= 4;
      }
      c1 = c;
      if ('0' <= c && c <= '9') {
        c -= '0';
      } else if ('a' <= c && c <= 'f') {
        c -= 'a' - 10;
      } else {
        c -= 'A' - 10;
      }
      lcval += c;
      c = c1;
      continue;
    } else {
      break;
    }
  }
  if (negflg) {
    lcval = -lcval;
  }
  if (c != (char)(-2)) {
    (*ungetch)(arg1, arg2);
    *eofptr = 0;
  } else {
    *eofptr = 1;
  }
  if (ptr == 0 || np == numbuf) {
    return 0;
  }
  *np++ = 0;
  switch (size) {
  case 0:
    **(short **)ptr = lcval;
    break;
  case 1:
    **(int **)ptr = lcval;
    break;
  case 2:
    **(long **)ptr = lcval;
    break;
  }
  return 1;
}


x86 assembly (clang, -O0):
<_innum>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
cmpl   $0x63,-0x14(%rbp)
je     1168 <_innum+0x48>
cmpl   $0x73,-0x14(%rbp)
je     1168 <_innum+0x48>
cmpl   $0x5b,-0x14(%rbp)
jne    11cb <_innum+0xab>
cmpq   $0x0,-0x10(%rbp)
je     1186 <_innum+0x66>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xa8(%rbp)
jmp    1194 <_innum+0x74>
xor    %eax,%eax
mov    %rax,-0xa8(%rbp)
jmp    1194 <_innum+0x74>
mov    -0xa8(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
mov    0x10(%rbp),%r9d
mov    0x18(%rbp),%r10d
mov    0x20(%rbp),%rax
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
call   1040 <_instr@plt>
mov    %eax,-0x4(%rbp)
jmp    1622 <_innum+0x502>
movq   $0x0,-0xa0(%rbp)
movl   $0x0,-0x94(%rbp)
movb   $0xa,-0x82(%rbp)
cmpl   $0x6f,-0x14(%rbp)
jne    11fd <_innum+0xdd>
movb   $0x8,-0x82(%rbp)
jmp    1213 <_innum+0xf3>
cmpl   $0x78,-0x14(%rbp)
jne    120e <_innum+0xee>
movb   $0x10,-0x82(%rbp)
jmp    1213 <_innum+0xf3>
lea    -0x80(%rbp),%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x88(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x28(%rbp),%rax
mov    0x10(%rbp),%edi
mov    0x18(%rbp),%esi
call   *%rax
mov    %al,-0x81(%rbp)
movsbl %al,%ecx
mov    $0x1,%al
cmp    $0x20,%ecx
mov    %al,-0xa9(%rbp)
je     1280 <_innum+0x160>
movsbl -0x81(%rbp),%ecx
mov    $0x1,%al
cmp    $0x9,%ecx
mov    %al,-0xa9(%rbp)
je     1280 <_innum+0x160>
movsbl -0x81(%rbp),%eax
cmp    $0xa,%eax
sete   %al
mov    %al,-0xa9(%rbp)
mov    -0xa9(%rbp),%al
test   $0x1,%al
jne    1293 <_innum+0x173>
jmp    1298 <_innum+0x178>
jmp    122f <_innum+0x10f>
movsbl -0x81(%rbp),%eax
cmp    $0x2d,%eax
jne    12ee <_innum+0x1ce>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
mov    -0x81(%rbp),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%rax
mov    0x10(%rbp),%edi
mov    0x18(%rbp),%esi
call   *%rax
mov    %al,-0x81(%rbp)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    131e <_innum+0x1fe>
movsbl -0x81(%rbp),%eax
cmp    $0x2b,%eax
jne    1319 <_innum+0x1f9>
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
mov    0x10(%rbp),%edi
mov    0x18(%rbp),%esi
call   *%rax
mov    %al,-0x81(%rbp)
jmp    131e <_innum+0x1fe>
jmp    1323 <_innum+0x203>
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
cmp    $0x0,%eax
jl     1510 <_innum+0x3f0>
movsbl -0x81(%rbp),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
jne    135b <_innum+0x23b>
movsbl -0x82(%rbp),%eax
cmp    $0x10,%eax
jne    14dd <_innum+0x3bd>
movsbl -0x81(%rbp),%ecx
mov    $0x61,%eax
cmp    %ecx,%eax
jg     137f <_innum+0x25f>
movsbl -0x81(%rbp),%eax
cmp    $0x66,%eax
jle    13a3 <_innum+0x283>
movsbl -0x81(%rbp),%ecx
mov    $0x41,%eax
cmp    %ecx,%eax
jg     14dd <_innum+0x3bd>
movsbl -0x81(%rbp),%eax
cmp    $0x46,%eax
jg     14dd <_innum+0x3bd>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
movsbl -0x82(%rbp),%eax
cmp    $0x8,%eax
jne    13d9 <_innum+0x2b9>
mov    -0xa0(%rbp),%rax
shl    $0x3,%rax
mov    %rax,-0xa0(%rbp)
jmp    1422 <_innum+0x302>
movsbl -0x82(%rbp),%eax
cmp    $0xa,%eax
jne    140b <_innum+0x2eb>
mov    -0xa0(%rbp),%rax
shl    $0x2,%rax
add    -0xa0(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0xa0(%rbp)
jmp    141d <_innum+0x2fd>
mov    -0xa0(%rbp),%rax
shl    $0x4,%rax
mov    %rax,-0xa0(%rbp)
jmp    1422 <_innum+0x302>
movsbl -0x81(%rbp),%eax
mov    %eax,-0x90(%rbp)
movsbl -0x81(%rbp),%ecx
mov    $0x30,%eax
cmp    %ecx,%eax
jg     1468 <_innum+0x348>
movsbl -0x81(%rbp),%eax
cmp    $0x39,%eax
jg     1468 <_innum+0x348>
movsbl -0x81(%rbp),%eax
sub    $0x30,%eax
mov    %al,-0x81(%rbp)
jmp    14b6 <_innum+0x396>
movsbl -0x81(%rbp),%ecx
mov    $0x61,%eax
cmp    %ecx,%eax
jg     14a1 <_innum+0x381>
movsbl -0x81(%rbp),%eax
cmp    $0x66,%eax
jg     14a1 <_innum+0x381>
movsbl -0x81(%rbp),%eax
sub    $0x57,%eax
mov    %al,-0x81(%rbp)
jmp    14b1 <_innum+0x391>
movsbl -0x81(%rbp),%eax
sub    $0x37,%eax
mov    %al,-0x81(%rbp)
jmp    14b6 <_innum+0x396>
movsbq -0x81(%rbp),%rax
ff
add    -0xa0(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x90(%rbp),%eax
mov    %al,-0x81(%rbp)
jmp    14e2 <_innum+0x3c2>
jmp    1510 <_innum+0x3f0>
mov    -0x81(%rbp),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%rax
mov    0x10(%rbp),%edi
mov    0x18(%rbp),%esi
call   *%rax
mov    %al,-0x81(%rbp)
jmp    1323 <_innum+0x203>
cmpl   $0x0,-0x8c(%rbp)
je     152d <_innum+0x40d>
xor    %eax,%eax
sub    -0xa0(%rbp),%rax
mov    %rax,-0xa0(%rbp)
movsbl -0x81(%rbp),%eax
cmp    $0xfffffffe,%eax
je     1558 <_innum+0x438>
mov    -0x30(%rbp),%rax
mov    0x10(%rbp),%edi
mov    0x18(%rbp),%esi
call   *%rax
mov    0x20(%rbp),%rax
movl   $0x0,(%rax)
jmp    1562 <_innum+0x442>
mov    0x20(%rbp),%rax
movl   $0x1,(%rax)
cmpq   $0x0,-0x10(%rbp)
je     157e <_innum+0x45e>
mov    -0x38(%rbp),%rax
lea    -0x80(%rbp),%rcx
cmp    %rcx,%rax
jne    158a <_innum+0x46a>
movl   $0x0,-0x4(%rbp)
jmp    1622 <_innum+0x502>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x0,(%rax)
mov    -0x1c(%rbp),%eax
mov    %eax,-0xb0(%rbp)
test   %eax,%eax
je     15da <_innum+0x4ba>
jmp    15b2 <_innum+0x492>
mov    -0xb0(%rbp),%eax
sub    $0x1,%eax
je     15f3 <_innum+0x4d3>
jmp    15c6 <_innum+0x4a6>
mov    -0xb0(%rbp),%eax
sub    $0x2,%eax
je     160a <_innum+0x4ea>
jmp    161b <_innum+0x4fb>
mov    -0xa0(%rbp),%rax
mov    %ax,%cx
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %cx,(%rax)
jmp    161b <_innum+0x4fb>
mov    -0xa0(%rbp),%rax
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %ecx,(%rax)
jmp    161b <_innum+0x4fb>
mov    -0xa0(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rcx,(%rax)
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_innum>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r8,%rbp
mov    %ecx,%r12d
mov    %edx,%r14d
mov    %rdi,%r13
mov    0xb0(%rsp),%ebx
lea    -0x5b(%rsi),%eax
cmp    $0x1d,%eax
ja     1199 <_innum+0x79>
mov    $0x1,%dil
xor    %edx,%edx
lea    0xeab(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
xor    %ecx,%ecx
jmp    *%rax
test   %r13,%r13
je     116b <_innum+0x4b>
mov    0x0(%r13),%rdi
jmp    116d <_innum+0x4d>
xor    %edi,%edi
mov    %r14d,%edx
mov    %rbp,%rcx
mov    %r9,%r8
mov    %ebx,%r9d
push   0xc0(%rsp)
mov    0xc0(%rsp),%eax
push   %rax
call   1040 <_instr@plt>
add    $0x88,%rsp
jmp    138d <_innum+0x26d>
mov    $0x1,%cl
xor    %edx,%edx
xor    %edi,%edi
jmp    11a7 <_innum+0x87>
mov    $0x1,%dl
xor    %edi,%edi
xor    %ecx,%ecx
mov    %ecx,0x18(%rsp)
mov    %edi,0x1c(%rsp)
mov    %edx,0x10(%rsp)
mov    %r9,0x20(%rsp)
mov    %r12d,0x14(%rsp)
jmp    11c7 <_innum+0xa7>
nop
cmp    $0x20000000,%eax
jne    11ef <_innum+0xcf>
mov    %ebx,%edi
mov    0xb8(%rsp),%esi
call   *%rbp
mov    %eax,%r15d
shl    $0x18,%eax
cmp    $0x1fffffff,%eax
jg     11c0 <_innum+0xa0>
cmp    $0x9000000,%eax
je     11c7 <_innum+0xa7>
cmp    $0xa000000,%eax
je     11c7 <_innum+0xa7>
jmp    1238 <_innum+0x118>
cmp    $0x2b000000,%eax
je     121d <_innum+0xfd>
cmp    $0x2d000000,%eax
jne    1238 <_innum+0x118>
lea    0x31(%rsp),%r12
mov    %r15b,0x30(%rsp)
mov    %ebx,%edi
mov    0xb8(%rsp),%esi
call   *%rbp
mov    %eax,%r15d
add    $0xffffffff,%r14d
xor    %eax,%eax
jmp    123f <_innum+0x11f>
lea    0x30(%rsp),%r12
add    $0xffffffff,%r14d
mov    %ebx,%edi
mov    0xb8(%rsp),%esi
call   *%rbp
mov    %eax,%r15d
mov    $0x1,%al
jmp    123f <_innum+0x11f>
mov    $0x1,%al
lea    0x30(%rsp),%r12
test   %r14d,%r14d
mov    %r13,0x28(%rsp)
jle    130f <_innum+0x1ef>
mov    %eax,0xc(%rsp)
add    $0xffffffff,%r14d
add    $0x1,%r14
xor    %r13d,%r13d
mov    0x10(%rsp),%eax
not    %al
mov    %eax,0x10(%rsp)
jmp    12a7 <_innum+0x187>
nopl   0x0(%rax,%rax,1)
shl    $0x3,%r13
mov    %r13,%rcx
cmp    $0x6,%al
setae  %al
shl    $0x5,%al
add    %r15b,%al
add    $0xa9,%al
movzbl %al,%r13d
add    %rcx,%r13
mov    %r15b,(%r12)
add    $0x1,%r12
mov    %ebx,%edi
mov    0xb8(%rsp),%esi
call   *%rbp
mov    %eax,%r15d
add    $0xffffffffffffffff,%r14
je     1309 <_innum+0x1e9>
movsbl %r15b,%edi
call   1030 <isdigit@plt>
test   %rax,%rax
sete   %al
test   %al,0x10(%rsp)
jne    1309 <_innum+0x1e9>
lea    -0x41(%r15),%eax
cmp    $0x25,%al
ja     1309 <_innum+0x1e9>
movzbl %al,%eax
movabs $0x3f0000003f,%rcx
bt     %rax,%rcx
jae    1309 <_innum+0x1e9>
lea    -0x61(%r15),%eax
cmpb   $0x0,0x1c(%rsp)
jne    1270 <_innum+0x150>
cmpb   $0x0,0x18(%rsp)
je     1300 <_innum+0x1e0>
add    %r13,%r13
lea    0x0(,%r13,4),%rcx
add    %r13,%rcx
jmp    1277 <_innum+0x157>
nopl   0x0(%rax)
shl    $0x4,%r13
jmp    1274 <_innum+0x154>
mov    0xc(%rsp),%eax
jmp    1312 <_innum+0x1f2>
xor    %r13d,%r13d
mov    %r13,%rbp
neg    %rbp
test   %al,%al
cmovne %r13,%rbp
mov    $0x1,%eax
cmp    $0xfe,%r15b
je     1338 <_innum+0x218>
mov    %ebx,%edi
mov    0xb8(%rsp),%esi
call   *0x20(%rsp)
xor    %eax,%eax
mov    0xc0(%rsp),%rcx
mov    %eax,(%rcx)
xor    %eax,%eax
mov    0x28(%rsp),%rdx
test   %rdx,%rdx
je     1389 <_innum+0x269>
lea    0x30(%rsp),%rcx
cmp    %rcx,%r12
je     1389 <_innum+0x269>
movb   $0x0,(%r12)
mov    $0x1,%eax
mov    0x14(%rsp),%ecx
cmp    $0x2,%ecx
je     137c <_innum+0x25c>
cmp    $0x1,%ecx
je     1384 <_innum+0x264>
test   %ecx,%ecx
jne    1389 <_innum+0x269>
mov    (%rdx),%rcx
mov    %bp,(%rcx)
jmp    1389 <_innum+0x269>
mov    (%rdx),%rcx
mov    %rbp,(%rcx)
jmp    1389 <_innum+0x269>
mov    (%rdx),%rcx
mov    %ebp,(%rcx)
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @_innum(i32** %0, i32 %1, i32 %2, i32 %3, i32 (i32, i32)* %4, i32 (i32, i32)* %5, i32 %6, i32 %7, i32* %8) {
%10 = alloca [64 x i8]
%11 = getelementptr inbounds [64 x i8], [64 x i8]* %10, i64 0, i64 0
switch i32 %1, label %21 [
i32 115, label %12
i32 99, label %12
i32 91, label %12
i32 111, label %22
i32 120, label %20
]
12: ; preds = %9, %9, %9
%13 = icmp eq i32** %0, null
br i1 %13, label %17, label %14
14: ; preds = %12
%15 = bitcast i32** %0 to i8**
%16 = load i8*, i8** %15
br label %17
17: ; preds = %12, %14
%18 = phi i8* [ %16, %14 ], [ null, %12 ]
%19 = tail call i32 @_instr(i8* %18, i32 %1, i32 %2, i32 (i32, i32)* %4, i32 (i32, i32)* %5, i32 %6, i32 %7, i32* %8)
br label %104
20: ; preds = %9
br label %22
21: ; preds = %9
br label %22
22: ; preds = %9, %21, %20
%23 = phi i1 [ true, %20 ], [ false, %9 ], [ false, %21 ]
%24 = phi i1 [ false, %20 ], [ true, %9 ], [ false, %21 ]
%25 = phi i1 [ false, %20 ], [ false, %9 ], [ true, %21 ]
br label %26
26: ; preds = %29, %22
%27 = tail call i32 %4(i32 %6, i32 %7)
%28 = shl i32 %27, 24
switch i32 %28, label %38 [
i32 536870912, label %29
i32 167772160, label %29
i32 150994944, label %29
i32 754974720, label %30
i32 721420288, label %35
]
29: ; preds = %26, %26, %26
br label %26
30: ; preds = %26
%31 = trunc i32 %27 to i8
%32 = getelementptr inbounds [64 x i8], [64 x i8]* %10, i64 0, i64 1
store i8 %31, i8* %11
%33 = tail call i32 %4(i32 %6, i32 %7)
%34 = add nsw i32 %2, -1
br label %38
35: ; preds = %26
%36 = add nsw i32 %2, -1
%37 = tail call i32 %4(i32 %6, i32 %7)
br label %38
38: ; preds = %26, %35, %30
%39 = phi i8* [ %32, %30 ], [ %11, %35 ], [ %11, %26 ]
%40 = phi i32 [ %33, %30 ], [ %37, %35 ], [ %27, %26 ]
%41 = phi i32 [ %34, %30 ], [ %36, %35 ], [ %2, %26 ]
%42 = phi i1 [ false, %30 ], [ true, %35 ], [ true, %26 ]
%43 = trunc i32 %40 to i8
%44 = icmp sgt i32 %41, 0
br i1 %44, label %45, label %79
45: ; preds = %38
%46 = add nsw i32 %41, -1
%47 = zext i32 %46 to i64
%48 = getelementptr i8, i8* %39, i64 %47
br label %49
49: ; preds = %45, %67
%50 = phi i64 [ %72, %67 ], [ 0, %45 ]
%51 = phi i8 [ %75, %67 ], [ %43, %45 ]
%52 = phi i8* [ %73, %67 ], [ %39, %45 ]
%53 = tail call i64 @isdigit(i8 signext %51)
%54 = icmp ne i64 %53, 0
%55 = or i1 %23, %54
br i1 %55, label %56, label %79
56: ; preds = %49
%57 = add i8 %51, -97
%58 = icmp ult i8 %57, 6
switch i8 %51, label %79 [
i8 102, label %59
i8 101, label %59
i8 100, label %59
i8 99, label %59
i8 98, label %59
i8 97, label %59
i8 70, label %59
i8 69, label %59
i8 68, label %59
i8 67, label %59
i8 66, label %59
i8 65, label %59
]
59: ; preds = %56, %56, %56, %56, %56, %56, %56, %56, %56, %56, %56, %56
br i1 %24, label %60, label %62
60: ; preds = %59
%61 = shl i64 %50, 3
br label %67
62: ; preds = %59
br i1 %25, label %63, label %65
63: ; preds = %62
%64 = mul i64 %50, 10
br label %67
65: ; preds = %62
%66 = shl i64 %50, 4
br label %67
67: ; preds = %60, %65, %63
%68 = phi i64 [ %61, %60 ], [ %64, %63 ], [ %66, %65 ]
%69 = select i1 %58, i8 -87, i8 -55
%70 = add nsw i8 %69, %51
%71 = zext i8 %70 to i64
%72 = add nsw i64 %68, %71
%73 = getelementptr inbounds i8, i8* %52, i64 1
store i8 %51, i8* %52
%74 = tail call i32 %4(i32 %6, i32 %7)
%75 = trunc i32 %74 to i8
%76 = icmp eq i8* %52, %48
br i1 %76, label %77, label %49
77: ; preds = %67
%78 = trunc i32 %74 to i8
br label %79
79: ; preds = %56, %49, %77, %38
%80 = phi i8* [ %39, %38 ], [ %73, %77 ], [ %52, %49 ], [ %52, %56 ]
%81 = phi i8 [ %43, %38 ], [ %78, %77 ], [ %51, %49 ], [ %51, %56 ]
%82 = phi i64 [ 0, %38 ], [ %72, %77 ], [ %50, %49 ], [ %50, %56 ]
%83 = sub nsw i64 0, %82
%84 = select i1 %42, i64 %82, i64 %83
%85 = icmp eq i8 %81, -2
br i1 %85, label %88, label %86
86: ; preds = %79
%87 = tail call i32 %5(i32 %6, i32 %7)
br label %88
88: ; preds = %79, %86
%89 = phi i32 [ 0, %86 ], [ 1, %79 ]
store i32 %89, i32* %8
%90 = icmp eq i32** %0, null
%91 = icmp eq i8* %80, %11
%92 = select i1 %90, i1 true, i1 %91
br i1 %92, label %104, label %93
93: ; preds = %88
store i8 0, i8* %80
switch i32 %3, label %104 [
i32 0, label %94
i32 1, label %98
i32 2, label %101
]
94: ; preds = %93
%95 = trunc i64 %84 to i16
%96 = bitcast i32** %0 to i16**
%97 = load i16*, i16** %96
store i16 %95, i16* %97
br label %104
98: ; preds = %93
%99 = trunc i64 %84 to i32
%100 = load i32*, i32** %0
store i32 %99, i32* %100
br label %104
101: ; preds = %93
%102 = bitcast i32** %0 to i64**
%103 = load i64*, i64** %102
store i64 %84, i64* %103
br label %104
104: ; preds = %94, %98, %101, %93, %88, %17
%105 = phi i32 [ %19, %17 ], [ 0, %88 ], [ 1, %93 ], [ 1, %101 ], [ 1, %98 ], [ 1, %94 ]
ret i32 %105
}