#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*/ error(char *, ...);
scalar_t__ isdigit(char);
scalar_t__ isxdigit(char);
scalar_t__ strncmp(char *, char *, int);
char upcase(char);
int xtoi(char);
char *get_long(char *s, int *outnum) {
  char is_neg = 0, intel = 0, c_lang = 0, tld = 0;
  char hash_hex = 0;
  char *start;
  *outnum = 0;
  if (*s == '-') {
    is_neg = (!0);
    ++s;
  } else if (*s == '+')
    ++s;
  if (isdigit(*s)) {
    char *p = s;
    while (isxdigit(*++p))
      ;
    if (upcase(*p) == 'H')
      intel = (!0);
  }
  if (intel || (hash_hex = (*s == '#' && isxdigit(*(s + 1)))) ||
      (c_lang = (*s == '0' && upcase(*(s + 1)) == 'X')) ||
      (tld = strncmp(s, "16#", 3) == 0)) {
    s += hash_hex ? 1 : c_lang ? 2 : tld ? 3 : 0;
    start = s;
    while (isxdigit(*s)) {
      *outnum = (*outnum << 4) | xtoi(*s);
      ++s;
    }
    if (s - start > 8) {
      error("get_long -- number at '%s' too large", start);
      return NULL;
    }
    if (intel)
      s++;
    else if (tld) {
      if (*s != '#') {
        error("get_long -- expecting '#' at end of number");
        return NULL;
      }
      s++;
    }
  } else if (*s == '0' || (tld = (*s == '8' && *(s + 1) == '#'))) {
    s += tld ? 2 : 1;
    start = s;
    while (*s >= '0' && *s <= '7') {
      *outnum = (*outnum << 3) | (*s - '0');
      ++s;
    }
    if (s - start > 11) {
      error("get_long -- number at '%s' too large", start);
      return NULL;
    }
    if (tld) {
      if (*s != '#') {
        error("get_long -- expecting '#' at end of number");
        return NULL;
      }
      ++s;
    }
  } else if (*s == '@' || (tld = (*s == '2' && *(s + 1) == '#'))) {
    s += (tld ? 2 : 1);
    start = s;
    while (*s == '0' || *s == '1') {
      *outnum = (*outnum << 1) | (*s - '0');
      ++s;
    }
    if (s - start > 32) {
      error("get_long -- number at '%s' too large", start);
      return NULL;
    }
    if (tld) {
      if (*s != '#') {
        error("get_long -- expecting '#' at end of number");
        return NULL;
      }
      ++s;
    }
  } else if (isdigit(*s)) {
    start = s;
    while (isdigit(*s)) {
      *outnum = (*outnum * 10) + ((*s) - '0');
      ++s;
    }
    if (s - start > 10) {
      error("get_long -- number at '%s' too large", start);
      return NULL;
    }
  } else
    return NULL;
  if (is_neg)
    *outnum = -*outnum;
  return s;
}


x86 assembly (clang, -O0):
<get_long>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movb   $0x0,-0x19(%rbp)
movb   $0x0,-0x1a(%rbp)
movb   $0x0,-0x1b(%rbp)
movb   $0x0,-0x1c(%rbp)
movb   $0x0,-0x1d(%rbp)
mov    -0x18(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
jne    11b3 <get_long+0x53>
movb   $0x1,-0x19(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    11d4 <get_long+0x74>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2b,%eax
jne    11cf <get_long+0x6f>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    11d4 <get_long+0x74>
mov    -0x10(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isdigit@plt>
cmp    $0x0,%rax
je     123a <get_long+0xda>
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movsbl 0x1(%rax),%edi
call   1080 <isxdigit@plt>
cmp    $0x0,%rax
je     1219 <get_long+0xb9>
jmp    11f2 <get_long+0x92>
mov    -0x30(%rbp),%rax
movsbl (%rax),%edi
call   1050 <upcase@plt>
movsbl %al,%eax
cmp    $0x48,%eax
jne    1235 <get_long+0xd5>
movb   $0x1,-0x1a(%rbp)
jmp    123a <get_long+0xda>
movsbl -0x1a(%rbp),%eax
cmp    $0x0,%eax
jne    12ff <get_long+0x19f>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x23,%ecx
mov    %al,-0x31(%rbp)
jne    1273 <get_long+0x113>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%edi
call   1080 <isxdigit@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x31(%rbp)
mov    -0x31(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %al,-0x1d(%rbp)
movsbl %al,%eax
cmp    $0x0,%eax
jne    12ff <get_long+0x19f>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x30,%ecx
mov    %al,-0x32(%rbp)
jne    12b8 <get_long+0x158>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%edi
call   1050 <upcase@plt>
movsbl %al,%eax
cmp    $0x58,%eax
sete   %al
mov    %al,-0x32(%rbp)
mov    -0x32(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %al,-0x1b(%rbp)
movsbl %al,%eax
cmp    $0x0,%eax
jne    12ff <get_long+0x19f>
mov    -0x10(%rbp),%rdi
lea    0xd26(%rip),%rsi
mov    $0x3,%edx
call   1030 <strncmp@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %al,-0x1c(%rbp)
movsbl %al,%eax
cmp    $0x0,%eax
je     144a <get_long+0x2ea>
movsbl -0x1d(%rbp),%eax
cmp    $0x0,%eax
je     1319 <get_long+0x1b9>
mov    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    134d <get_long+0x1ed>
movsbl -0x1b(%rbp),%eax
cmp    $0x0,%eax
je     1333 <get_long+0x1d3>
mov    $0x2,%eax
mov    %eax,-0x3c(%rbp)
jmp    1347 <get_long+0x1e7>
movsbl -0x1c(%rbp),%edx
xor    %eax,%eax
mov    $0x3,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%edi
call   1080 <isxdigit@plt>
cmp    $0x0,%rax
je     13b0 <get_long+0x250>
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
shl    $0x4,%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%edi
call   1060 <xtoi@plt>
mov    -0x40(%rbp),%ecx
or     %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1366 <get_long+0x206>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
cmp    $0x8,%rax
jle    13e4 <get_long+0x284>
mov    -0x28(%rbp),%rsi
lea    0xc34(%rip),%rdi
mov    $0x0,%al
call   1070 <error@plt>
movq   $0x0,-0x8(%rbp)
jmp    17c1 <get_long+0x661>
cmpb   $0x0,-0x1a(%rbp)
je     13ff <get_long+0x29f>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1445 <get_long+0x2e5>
cmpb   $0x0,-0x1c(%rbp)
je     1440 <get_long+0x2e0>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x23,%eax
je     1434 <get_long+0x2d4>
lea    0xc09(%rip),%rdi
mov    $0x0,%al
call   1070 <error@plt>
movq   $0x0,-0x8(%rbp)
jmp    17c1 <get_long+0x661>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1445 <get_long+0x2e5>
jmp    17a1 <get_long+0x641>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
je     1497 <get_long+0x337>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x38,%ecx
mov    %al,-0x41(%rbp)
jne    1480 <get_long+0x320>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x23,%eax
sete   %al
mov    %al,-0x41(%rbp)
mov    -0x41(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %al,-0x1c(%rbp)
movsbl %al,%eax
cmp    $0x0,%eax
je     159c <get_long+0x43c>
movsbl -0x1c(%rbp),%edx
mov    $0x1,%ecx
mov    $0x2,%eax
cmp    $0x0,%edx
cmovne %eax,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x30,%ecx
mov    %al,-0x42(%rbp)
jl     14e6 <get_long+0x386>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x37,%eax
setle  %al
mov    %al,-0x42(%rbp)
mov    -0x42(%rbp),%al
test   $0x1,%al
jne    14f6 <get_long+0x396>
jmp    1522 <get_long+0x3c2>
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
shl    $0x3,%ecx
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
sub    $0x30,%eax
or     %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    14c1 <get_long+0x361>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
cmp    $0xb,%rax
jle    1556 <get_long+0x3f6>
mov    -0x28(%rbp),%rsi
lea    0xac2(%rip),%rdi
mov    $0x0,%al
call   1070 <error@plt>
movq   $0x0,-0x8(%rbp)
jmp    17c1 <get_long+0x661>
cmpb   $0x0,-0x1c(%rbp)
je     1597 <get_long+0x437>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x23,%eax
je     158b <get_long+0x42b>
lea    0xab2(%rip),%rdi
mov    $0x0,%al
call   1070 <error@plt>
movq   $0x0,-0x8(%rbp)
jmp    17c1 <get_long+0x661>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    179c <get_long+0x63c>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x40,%eax
je     15e9 <get_long+0x489>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x32,%ecx
mov    %al,-0x43(%rbp)
jne    15d2 <get_long+0x472>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x23,%eax
sete   %al
mov    %al,-0x43(%rbp)
mov    -0x43(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %al,-0x1c(%rbp)
movsbl %al,%eax
cmp    $0x0,%eax
je     16ee <get_long+0x58e>
movsbl -0x1c(%rbp),%edx
mov    $0x1,%ecx
mov    $0x2,%eax
cmp    $0x0,%edx
cmovne %eax,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x30,%ecx
mov    %al,-0x44(%rbp)
je     1638 <get_long+0x4d8>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x31,%eax
sete   %al
mov    %al,-0x44(%rbp)
mov    -0x44(%rbp),%al
test   $0x1,%al
jne    1648 <get_long+0x4e8>
jmp    1674 <get_long+0x514>
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
shl    $0x1,%ecx
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
sub    $0x30,%eax
or     %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1613 <get_long+0x4b3>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
cmp    $0x20,%rax
jle    16a8 <get_long+0x548>
mov    -0x28(%rbp),%rsi
lea    0x970(%rip),%rdi
mov    $0x0,%al
call   1070 <error@plt>
movq   $0x0,-0x8(%rbp)
jmp    17c1 <get_long+0x661>
cmpb   $0x0,-0x1c(%rbp)
je     16e9 <get_long+0x589>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x23,%eax
je     16dd <get_long+0x57d>
lea    0x960(%rip),%rdi
mov    $0x0,%al
call   1070 <error@plt>
movq   $0x0,-0x8(%rbp)
jmp    17c1 <get_long+0x661>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1797 <get_long+0x637>
mov    -0x10(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isdigit@plt>
cmp    $0x0,%rax
je     1785 <get_long+0x625>
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isdigit@plt>
cmp    $0x0,%rax
je     174c <get_long+0x5ec>
mov    -0x18(%rbp),%rax
imul   $0xa,(%rax),%ecx
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
sub    $0x30,%eax
add    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    170c <get_long+0x5ac>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
cmp    $0xa,%rax
jle    1780 <get_long+0x620>
mov    -0x28(%rbp),%rsi
lea    0x898(%rip),%rdi
mov    $0x0,%al
call   1070 <error@plt>
movq   $0x0,-0x8(%rbp)
jmp    17c1 <get_long+0x661>
jmp    1792 <get_long+0x632>
movq   $0x0,-0x8(%rbp)
jmp    17c1 <get_long+0x661>
jmp    1797 <get_long+0x637>
jmp    179c <get_long+0x63c>
jmp    17a1 <get_long+0x641>
cmpb   $0x0,-0x19(%rbp)
je     17b9 <get_long+0x659>
mov    -0x18(%rbp),%rax
xor    %ecx,%ecx
sub    (%rax),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_long>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %rdi,%r15
movl   $0x0,(%rsi)
mov    (%rdi),%al
mov    $0x1,%bpl
cmp    $0x2b,%al
je     118c <get_long+0x2c>
cmp    $0x2d,%al
jne    1190 <get_long+0x30>
add    $0x1,%r15
xor    %ebp,%ebp
jmp    1190 <get_long+0x30>
add    $0x1,%r15
movsbl (%r15),%edi
call   1040 <isdigit@plt>
test   %rax,%rax
je     11e1 <get_long+0x81>
lea    0x1(%r15),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsbl (%rbx),%edi
call   1080 <isxdigit@plt>
add    $0x1,%rbx
test   %rax,%rax
jne    11b0 <get_long+0x50>
movsbl -0x1(%rbx),%edi
call   1050 <upcase@plt>
cmp    $0x48,%al
jne    11e1 <get_long+0x81>
mov    %ebp,(%rsp)
mov    $0x1,%al
mov    %eax,0x4(%rsp)
xor    %r13d,%r13d
xor    %eax,%eax
jmp    12e5 <get_long+0x185>
mov    (%r15),%al
cmp    $0x23,%al
jne    1204 <get_long+0xa4>
movsbl 0x1(%r15),%edi
call   1080 <isxdigit@plt>
test   %rax,%rax
je     1201 <get_long+0xa1>
mov    %ebp,(%rsp)
mov    $0x1,%eax
jmp    121e <get_long+0xbe>
mov    (%r15),%al
cmp    $0x30,%al
jne    122c <get_long+0xcc>
movsbl 0x1(%r15),%edi
call   1050 <upcase@plt>
cmp    $0x58,%al
jne    122c <get_long+0xcc>
mov    %ebp,(%rsp)
mov    $0x2,%eax
mov    $0x1,%cl
mov    %ecx,0x4(%rsp)
mov    $0x1,%r13b
jmp    12e5 <get_long+0x185>
lea    0xdf1(%rip),%rsi
mov    %r15,%rdi
mov    $0x3,%edx
call   1030 <strncmp@plt>
test   %rax,%rax
je     12d2 <get_long+0x172>
mov    (%r15),%cl
lea    -0x30(%rcx),%esi
ror    %sil
cmp    $0x8,%sil
ja     13d5 <get_long+0x275>
mov    $0x1,%edx
mov    $0x1,%r8b
movzbl %sil,%esi
lea    0xd91(%rip),%rdi
movslq (%rdi,%rsi,4),%rsi
add    %rdi,%rsi
jmp    *%rsi
cmpb   $0x23,0x1(%r15)
jne    13d5 <get_long+0x275>
mov    $0x2,%edx
xor    %r8d,%r8d
lea    (%r15,%rdx,1),%rsi
mov    (%r15,%rdx,1),%cl
mov    %ecx,%eax
and    $0xfe,%al
cmp    $0x30,%al
jne    1445 <get_long+0x2e5>
mov    (%r14),%edx
mov    %rsi,%rbx
cs nopw 0x0(%rax,%rax,1)
nop
add    %edx,%edx
movzbl %cl,%eax
add    $0xffffffd0,%eax
or     %eax,%edx
mov    %edx,(%r14)
movzbl 0x1(%rbx),%ecx
add    $0x1,%rbx
mov    %ecx,%eax
and    $0xfe,%al
cmp    $0x30,%al
je     12b0 <get_long+0x150>
jmp    1448 <get_long+0x2e8>
mov    %ebp,(%rsp)
mov    $0x3,%eax
mov    $0x1,%r13b
movl   $0x0,0x4(%rsp)
lea    (%r15,%rax,1),%r12
movsbl (%r15,%rax,1),%edi
call   1080 <isxdigit@plt>
mov    %r12,%rbx
test   %rax,%rax
je     1325 <get_long+0x1c5>
mov    %r12,%rbx
xchg   %ax,%ax
mov    (%r14),%ebp
shl    $0x4,%ebp
movsbl (%rbx),%edi
call   1060 <xtoi@plt>
or     %ebp,%eax
mov    %eax,(%r14)
movsbl 0x1(%rbx),%edi
add    $0x1,%rbx
call   1080 <isxdigit@plt>
test   %rax,%rax
jne    1300 <get_long+0x1a0>
mov    %rbx,%rax
sub    %r12,%rax
cmp    $0x9,%rax
jl     1349 <get_long+0x1e9>
lea    0xcf0(%rip),%rdi
xor    %ebx,%ebx
mov    %r12,%rsi
xor    %eax,%eax
call   1070 <error@plt>
jmp    14aa <get_long+0x34a>
test   %r13b,%r13b
je     1367 <get_long+0x207>
cmpb   $0x0,0x4(%rsp)
mov    (%rsp),%ebp
jne    136e <get_long+0x20e>
cmpb   $0x23,(%rbx)
jne    149a <get_long+0x33a>
add    $0x1,%rbx
jmp    136e <get_long+0x20e>
add    $0x1,%rbx
mov    (%rsp),%ebp
test   %bpl,%bpl
jne    14aa <get_long+0x34a>
negl   (%r14)
jmp    14aa <get_long+0x34a>
cmpb   $0x23,0x1(%r15)
jne    13d5 <get_long+0x275>
mov    $0x2,%edx
xor    %r8d,%r8d
lea    (%r15,%rdx,1),%rsi
mov    (%r15,%rdx,1),%al
mov    %eax,%edx
and    $0xf8,%dl
cmp    $0x30,%dl
jne    1468 <get_long+0x308>
mov    (%r14),%edx
mov    %rsi,%rbx
nopw   0x0(%rax,%rax,1)
movzbl %al,%ecx
shl    $0x3,%edx
add    $0xffffffd0,%ecx
or     %ecx,%edx
mov    %edx,(%r14)
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
mov    %eax,%ecx
and    $0xf8,%cl
cmp    $0x30,%cl
je     13b0 <get_long+0x250>
jmp    146b <get_long+0x30b>
movsbl %cl,%edi
call   1040 <isdigit@plt>
test   %rax,%rax
je     1485 <get_long+0x325>
movsbl (%r15),%edi
call   1040 <isdigit@plt>
mov    %r15,%rbx
test   %rax,%rax
je     1424 <get_long+0x2c4>
mov    %r15,%rbx
nopw   0x0(%rax,%rax,1)
mov    (%r14),%eax
lea    (%rax,%rax,4),%eax
movsbl (%rbx),%ecx
lea    (%rcx,%rax,2),%eax
add    $0xffffffd0,%eax
mov    %eax,(%r14)
movsbl 0x1(%rbx),%edi
add    $0x1,%rbx
call   1040 <isdigit@plt>
test   %rax,%rax
jne    1400 <get_long+0x2a0>
mov    %rbx,%rax
sub    %r15,%rax
cmp    $0xb,%rax
jl     136e <get_long+0x20e>
lea    0xbed(%rip),%rdi
xor    %ebx,%ebx
mov    %r15,%rsi
jmp    133d <get_long+0x1dd>
mov    %rsi,%rbx
mov    %rbx,%rax
sub    %rsi,%rax
cmp    $0x21,%rax
jge    1477 <get_long+0x317>
test   %r8b,%r8b
jne    136e <get_long+0x20e>
cmp    $0x23,%cl
je     1361 <get_long+0x201>
jmp    149a <get_long+0x33a>
mov    %rsi,%rbx
mov    %rbx,%rcx
sub    %rsi,%rcx
cmp    $0xc,%rcx
jl     1489 <get_long+0x329>
lea    0xbaa(%rip),%rdi
xor    %ebx,%ebx
jmp    133d <get_long+0x1dd>
xor    %ebx,%ebx
jmp    14aa <get_long+0x34a>
test   %r8b,%r8b
jne    136e <get_long+0x20e>
cmp    $0x23,%al
je     1361 <get_long+0x201>
lea    0xbac(%rip),%rdi
xor    %ebx,%ebx
xor    %eax,%eax
call   1070 <error@plt>
mov    %rbx,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [4 x i8] c"16#\00"
@.str.1 = [37 x i8] c"get_long -- number at '%s' too large\00"
@.str.2 = [43 x i8] c"get_long -- expecting '#' at end of number\00"
define i8* @get_long(i8* %0, i32* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i32*
%6 = alloca i8
%7 = alloca i8
%8 = alloca i8
%9 = alloca i8
%10 = alloca i8
%11 = alloca i8*
%12 = alloca i8*
store i8* %0, i8** %4
store i32* %1, i32** %5
store i8 0, i8* %6
store i8 0, i8* %7
store i8 0, i8* %8
store i8 0, i8* %9
store i8 0, i8* %10
%13 = load i32*, i32** %5
store i32 0, i32* %13
%14 = load i8*, i8** %4
%15 = load i8, i8* %14
%16 = sext i8 %15 to i32
%17 = icmp eq i32 %16, 45
br i1 %17, label %18, label %21
18: ; preds = %2
store i8 1, i8* %6
%19 = load i8*, i8** %4
%20 = getelementptr inbounds i8, i8* %19, i32 1
store i8* %20, i8** %4
br label %30
21: ; preds = %2
%22 = load i8*, i8** %4
%23 = load i8, i8* %22
%24 = sext i8 %23 to i32
%25 = icmp eq i32 %24, 43
br i1 %25, label %26, label %29
26: ; preds = %21
%27 = load i8*, i8** %4
%28 = getelementptr inbounds i8, i8* %27, i32 1
store i8* %28, i8** %4
br label %29
29: ; preds = %26, %21
br label %30
30: ; preds = %29, %18
%31 = load i8*, i8** %4
%32 = load i8, i8* %31
%33 = call i64 @isdigit(i8 signext %32)
%34 = icmp ne i64 %33, 0
br i1 %34, label %35, label %52
35: ; preds = %30
%36 = load i8*, i8** %4
store i8* %36, i8** %12
br label %37
37: ; preds = %43, %35
%38 = load i8*, i8** %12
%39 = getelementptr inbounds i8, i8* %38, i32 1
store i8* %39, i8** %12
%40 = load i8, i8* %39
%41 = call i64 @isxdigit(i8 signext %40)
%42 = icmp ne i64 %41, 0
br i1 %42, label %43, label %44
43: ; preds = %37
br label %37
44: ; preds = %37
%45 = load i8*, i8** %12
%46 = load i8, i8* %45
%47 = call signext i8 @upcase(i8 signext %46)
%48 = sext i8 %47 to i32
%49 = icmp eq i32 %48, 72
br i1 %49, label %50, label %51
50: ; preds = %44
store i8 1, i8* %7
br label %51
51: ; preds = %50, %44
br label %52
52: ; preds = %51, %30
%53 = load i8, i8* %7
%54 = sext i8 %53 to i32
%55 = icmp ne i32 %54, 0
br i1 %55, label %99, label %56
56: ; preds = %52
%57 = load i8*, i8** %4
%58 = load i8, i8* %57
%59 = sext i8 %58 to i32
%60 = icmp eq i32 %59, 35
br i1 %60, label %61, label %67
61: ; preds = %56
%62 = load i8*, i8** %4
%63 = getelementptr inbounds i8, i8* %62, i64 1
%64 = load i8, i8* %63
%65 = call i64 @isxdigit(i8 signext %64)
%66 = icmp ne i64 %65, 0
br label %67
67: ; preds = %61, %56
%68 = phi i1 [ false, %56 ], [ %66, %61 ]
%69 = zext i1 %68 to i32
%70 = trunc i32 %69 to i8
store i8 %70, i8* %10
%71 = sext i8 %70 to i32
%72 = icmp ne i32 %71, 0
br i1 %72, label %99, label %73
73: ; preds = %67
%74 = load i8*, i8** %4
%75 = load i8, i8* %74
%76 = sext i8 %75 to i32
%77 = icmp eq i32 %76, 48
br i1 %77, label %78, label %85
78: ; preds = %73
%79 = load i8*, i8** %4
%80 = getelementptr inbounds i8, i8* %79, i64 1
%81 = load i8, i8* %80
%82 = call signext i8 @upcase(i8 signext %81)
%83 = sext i8 %82 to i32
%84 = icmp eq i32 %83, 88
br label %85
85: ; preds = %78, %73
%86 = phi i1 [ false, %73 ], [ %84, %78 ]
%87 = zext i1 %86 to i32
%88 = trunc i32 %87 to i8
store i8 %88, i8* %8
%89 = sext i8 %88 to i32
%90 = icmp ne i32 %89, 0
br i1 %90, label %99, label %91
91: ; preds = %85
%92 = load i8*, i8** %4
%93 = call i64 @strncmp(i8* %92, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 3)
%94 = icmp eq i64 %93, 0
%95 = zext i1 %94 to i32
%96 = trunc i32 %95 to i8
store i8 %96, i8* %9
%97 = sext i8 %96 to i32
%98 = icmp ne i32 %97, 0
br i1 %98, label %99, label %170
99: ; preds = %91, %85, %67, %52
%100 = load i8, i8* %10
%101 = sext i8 %100 to i32
%102 = icmp ne i32 %101, 0
br i1 %102, label %103, label %104
103: ; preds = %99
br label %117
104: ; preds = %99
%105 = load i8, i8* %8
%106 = sext i8 %105 to i32
%107 = icmp ne i32 %106, 0
br i1 %107, label %108, label %109
108: ; preds = %104
br label %115
109: ; preds = %104
%110 = load i8, i8* %9
%111 = sext i8 %110 to i32
%112 = icmp ne i32 %111, 0
%113 = zext i1 %112 to i64
%114 = select i1 %112, i32 3, i32 0
br label %115
115: ; preds = %109, %108
%116 = phi i32 [ 2, %108 ], [ %114, %109 ]
br label %117
117: ; preds = %115, %103
%118 = phi i32 [ 1, %103 ], [ %116, %115 ]
%119 = load i8*, i8** %4
%120 = sext i32 %118 to i64
%121 = getelementptr inbounds i8, i8* %119, i64 %120
store i8* %121, i8** %4
%122 = load i8*, i8** %4
store i8* %122, i8** %11
br label %123
123: ; preds = %128, %117
%124 = load i8*, i8** %4
%125 = load i8, i8* %124
%126 = call i64 @isxdigit(i8 signext %125)
%127 = icmp ne i64 %126, 0
br i1 %127, label %128, label %139
128: ; preds = %123
%129 = load i32*, i32** %5
%130 = load i32, i32* %129
%131 = shl i32 %130, 4
%132 = load i8*, i8** %4
%133 = load i8, i8* %132
%134 = call i32 @xtoi(i8 signext %133)
%135 = or i32 %131, %134
%136 = load i32*, i32** %5
store i32 %135, i32* %136
%137 = load i8*, i8** %4
%138 = getelementptr inbounds i8, i8* %137, i32 1
store i8* %138, i8** %4
br label %123
139: ; preds = %123
%140 = load i8*, i8** %4
%141 = load i8*, i8** %11
%142 = ptrtoint i8* %140 to i64
%143 = ptrtoint i8* %141 to i64
%144 = sub i64 %142, %143
%145 = icmp sgt i64 %144, 8
br i1 %145, label %146, label %149
146: ; preds = %139
%147 = load i8*, i8** %11
%148 = call i32 (i8*, ...) @error(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.1, i64 0, i64 0), i8* %147)
store i8* null, i8** %3
br label %379
149: ; preds = %139
%150 = load i8, i8* %7
%151 = icmp ne i8 %150, 0
br i1 %151, label %152, label %155
152: ; preds = %149
%153 = load i8*, i8** %4
%154 = getelementptr inbounds i8, i8* %153, i32 1
store i8* %154, i8** %4
br label %169
155: ; preds = %149
%156 = load i8, i8* %9
%157 = icmp ne i8 %156, 0
br i1 %157, label %158, label %168
158: ; preds = %155
%159 = load i8*, i8** %4
%160 = load i8, i8* %159
%161 = sext i8 %160 to i32
%162 = icmp ne i32 %161, 35
br i1 %162, label %163, label %165
163: ; preds = %158
%164 = call i32 (i8*, ...) @error(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.2, i64 0, i64 0))
store i8* null, i8** %3
br label %379
165: ; preds = %158
%166 = load i8*, i8** %4
%167 = getelementptr inbounds i8, i8* %166, i32 1
store i8* %167, i8** %4
br label %168
168: ; preds = %165, %155
br label %169
169: ; preds = %168, %152
br label %369
170: ; preds = %91
%171 = load i8*, i8** %4
%172 = load i8, i8* %171
%173 = sext i8 %172 to i32
%174 = icmp eq i32 %173, 48
br i1 %174, label %192, label %175
175: ; preds = %170
%176 = load i8*, i8** %4
%177 = load i8, i8* %176
%178 = sext i8 %177 to i32
%179 = icmp eq i32 %178, 56
br i1 %179, label %180, label %186
180: ; preds = %175
%181 = load i8*, i8** %4
%182 = getelementptr inbounds i8, i8* %181, i64 1
%183 = load i8, i8* %182
%184 = sext i8 %183 to i32
%185 = icmp eq i32 %184, 35
br label %186
186: ; preds = %180, %175
%187 = phi i1 [ false, %175 ], [ %185, %180 ]
%188 = zext i1 %187 to i32
%189 = trunc i32 %188 to i8
store i8 %189, i8* %9
%190 = sext i8 %189 to i32
%191 = icmp ne i32 %190, 0
br i1 %191, label %192, label %250
192: ; preds = %186, %170
%193 = load i8, i8* %9
%194 = sext i8 %193 to i32
%195 = icmp ne i32 %194, 0
%196 = zext i1 %195 to i64
%197 = select i1 %195, i32 2, i32 1
%198 = load i8*, i8** %4
%199 = sext i32 %197 to i64
%200 = getelementptr inbounds i8, i8* %198, i64 %199
store i8* %200, i8** %4
%201 = load i8*, i8** %4
store i8* %201, i8** %11
br label %202
202: ; preds = %214, %192
%203 = load i8*, i8** %4
%204 = load i8, i8* %203
%205 = sext i8 %204 to i32
%206 = icmp sge i32 %205, 48
br i1 %206, label %207, label %212
207: ; preds = %202
%208 = load i8*, i8** %4
%209 = load i8, i8* %208
%210 = sext i8 %209 to i32
%211 = icmp sle i32 %210, 55
br label %212
212: ; preds = %207, %202
%213 = phi i1 [ false, %202 ], [ %211, %207 ]
br i1 %213, label %214, label %226
214: ; preds = %212
%215 = load i32*, i32** %5
%216 = load i32, i32* %215
%217 = shl i32 %216, 3
%218 = load i8*, i8** %4
%219 = load i8, i8* %218
%220 = sext i8 %219 to i32
%221 = sub nsw i32 %220, 48
%222 = or i32 %217, %221
%223 = load i32*, i32** %5
store i32 %222, i32* %223
%224 = load i8*, i8** %4
%225 = getelementptr inbounds i8, i8* %224, i32 1
store i8* %225, i8** %4
br label %202
226: ; preds = %212
%227 = load i8*, i8** %4
%228 = load i8*, i8** %11
%229 = ptrtoint i8* %227 to i64
%230 = ptrtoint i8* %228 to i64
%231 = sub i64 %229, %230
%232 = icmp sgt i64 %231, 11
br i1 %232, label %233, label %236
233: ; preds = %226
%234 = load i8*, i8** %11
%235 = call i32 (i8*, ...) @error(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.1, i64 0, i64 0), i8* %234)
store i8* null, i8** %3
br label %379
236: ; preds = %226
%237 = load i8, i8* %9
%238 = icmp ne i8 %237, 0
br i1 %238, label %239, label %249
239: ; preds = %236
%240 = load i8*, i8** %4
%241 = load i8, i8* %240
%242 = sext i8 %241 to i32
%243 = icmp ne i32 %242, 35
br i1 %243, label %244, label %246
244: ; preds = %239
%245 = call i32 (i8*, ...) @error(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.2, i64 0, i64 0))
store i8* null, i8** %3
br label %379
246: ; preds = %239
%247 = load i8*, i8** %4
%248 = getelementptr inbounds i8, i8* %247, i32 1
store i8* %248, i8** %4
br label %249
249: ; preds = %246, %236
br label %368
250: ; preds = %186
%251 = load i8*, i8** %4
%252 = load i8, i8* %251
%253 = sext i8 %252 to i32
%254 = icmp eq i32 %253, 64
br i1 %254, label %272, label %255
255: ; preds = %250
%256 = load i8*, i8** %4
%257 = load i8, i8* %256
%258 = sext i8 %257 to i32
%259 = icmp eq i32 %258, 50
br i1 %259, label %260, label %266
260: ; preds = %255
%261 = load i8*, i8** %4
%262 = getelementptr inbounds i8, i8* %261, i64 1
%263 = load i8, i8* %262
%264 = sext i8 %263 to i32
%265 = icmp eq i32 %264, 35
br label %266
266: ; preds = %260, %255
%267 = phi i1 [ false, %255 ], [ %265, %260 ]
%268 = zext i1 %267 to i32
%269 = trunc i32 %268 to i8
store i8 %269, i8* %9
%270 = sext i8 %269 to i32
%271 = icmp ne i32 %270, 0
br i1 %271, label %272, label %330
272: ; preds = %266, %250
%273 = load i8, i8* %9
%274 = sext i8 %273 to i32
%275 = icmp ne i32 %274, 0
%276 = zext i1 %275 to i64
%277 = select i1 %275, i32 2, i32 1
%278 = load i8*, i8** %4
%279 = sext i32 %277 to i64
%280 = getelementptr inbounds i8, i8* %278, i64 %279
store i8* %280, i8** %4
%281 = load i8*, i8** %4
store i8* %281, i8** %11
br label %282
282: ; preds = %294, %272
%283 = load i8*, i8** %4
%284 = load i8, i8* %283
%285 = sext i8 %284 to i32
%286 = icmp eq i32 %285, 48
br i1 %286, label %292, label %287
287: ; preds = %282
%288 = load i8*, i8** %4
%289 = load i8, i8* %288
%290 = sext i8 %289 to i32
%291 = icmp eq i32 %290, 49
br label %292
292: ; preds = %287, %282
%293 = phi i1 [ true, %282 ], [ %291, %287 ]
br i1 %293, label %294, label %306
294: ; preds = %292
%295 = load i32*, i32** %5
%296 = load i32, i32* %295
%297 = shl i32 %296, 1
%298 = load i8*, i8** %4
%299 = load i8, i8* %298
%300 = sext i8 %299 to i32
%301 = sub nsw i32 %300, 48
%302 = or i32 %297, %301
%303 = load i32*, i32** %5
store i32 %302, i32* %303
%304 = load i8*, i8** %4
%305 = getelementptr inbounds i8, i8* %304, i32 1
store i8* %305, i8** %4
br label %282
306: ; preds = %292
%307 = load i8*, i8** %4
%308 = load i8*, i8** %11
%309 = ptrtoint i8* %307 to i64
%310 = ptrtoint i8* %308 to i64
%311 = sub i64 %309, %310
%312 = icmp sgt i64 %311, 32
br i1 %312, label %313, label %316
313: ; preds = %306
%314 = load i8*, i8** %11
%315 = call i32 (i8*, ...) @error(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.1, i64 0, i64 0), i8* %314)
store i8* null, i8** %3
br label %379
316: ; preds = %306
%317 = load i8, i8* %9
%318 = icmp ne i8 %317, 0
br i1 %318, label %319, label %329
319: ; preds = %316
%320 = load i8*, i8** %4
%321 = load i8, i8* %320
%322 = sext i8 %321 to i32
%323 = icmp ne i32 %322, 35
br i1 %323, label %324, label %326
324: ; preds = %319
%325 = call i32 (i8*, ...) @error(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.2, i64 0, i64 0))
store i8* null, i8** %3
br label %379
326: ; preds = %319
%327 = load i8*, i8** %4
%328 = getelementptr inbounds i8, i8* %327, i32 1
store i8* %328, i8** %4
br label %329
329: ; preds = %326, %316
br label %367
330: ; preds = %266
%331 = load i8*, i8** %4
%332 = load i8, i8* %331
%333 = call i64 @isdigit(i8 signext %332)
%334 = icmp ne i64 %333, 0
br i1 %334, label %335, label %365
335: ; preds = %330
%336 = load i8*, i8** %4
store i8* %336, i8** %11
br label %337
337: ; preds = %342, %335
%338 = load i8*, i8** %4
%339 = load i8, i8* %338
%340 = call i64 @isdigit(i8 signext %339)
%341 = icmp ne i64 %340, 0
br i1 %341, label %342, label %354
342: ; preds = %337
%343 = load i32*, i32** %5
%344 = load i32, i32* %343
%345 = mul nsw i32 %344, 10
%346 = load i8*, i8** %4
%347 = load i8, i8* %346
%348 = sext i8 %347 to i32
%349 = sub nsw i32 %348, 48
%350 = add nsw i32 %345, %349
%351 = load i32*, i32** %5
store i32 %350, i32* %351
%352 = load i8*, i8** %4
%353 = getelementptr inbounds i8, i8* %352, i32 1
store i8* %353, i8** %4
br label %337
354: ; preds = %337
%355 = load i8*, i8** %4
%356 = load i8*, i8** %11
%357 = ptrtoint i8* %355 to i64
%358 = ptrtoint i8* %356 to i64
%359 = sub i64 %357, %358
%360 = icmp sgt i64 %359, 10
br i1 %360, label %361, label %364
361: ; preds = %354
%362 = load i8*, i8** %11
%363 = call i32 (i8*, ...) @error(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.1, i64 0, i64 0), i8* %362)
store i8* null, i8** %3
br label %379
364: ; preds = %354
br label %366
365: ; preds = %330
store i8* null, i8** %3
br label %379
366: ; preds = %364
br label %367
367: ; preds = %366, %329
br label %368
368: ; preds = %367, %249
br label %369
369: ; preds = %368, %169
%370 = load i8, i8* %6
%371 = icmp ne i8 %370, 0
br i1 %371, label %372, label %377
372: ; preds = %369
%373 = load i32*, i32** %5
%374 = load i32, i32* %373
%375 = sub nsw i32 0, %374
%376 = load i32*, i32** %5
store i32 %375, i32* %376
br label %377
377: ; preds = %372, %369
%378 = load i8*, i8** %4
store i8* %378, i8** %3
br label %379
379: ; preds = %377, %365, %361, %324, %313, %244, %233, %163, %146
%380 = load i8*, i8** %3
ret i8* %380
}

LLVM IR (-O2):
@.str = [4 x i8] c"16#\00"
@.str.1 = [37 x i8] c"get_long -- number at '%s' too large\00"
@.str.2 = [43 x i8] c"get_long -- expecting '#' at end of number\00"
define i8* @get_long(i8* %0, i32* nocapture %1) {
store i32 0, i32* %1
%3 = load i8, i8* %0
switch i8 %3, label %8 [
i8 45, label %4
i8 43, label %6
]
4: ; preds = %2
%5 = getelementptr inbounds i8, i8* %0, i64 1
br label %8
6: ; preds = %2
%7 = getelementptr inbounds i8, i8* %0, i64 1
br label %8
8: ; preds = %2, %6, %4
%9 = phi i8* [ %5, %4 ], [ %7, %6 ], [ %0, %2 ]
%10 = phi i1 [ false, %4 ], [ true, %6 ], [ true, %2 ]
%11 = load i8, i8* %9
%12 = tail call i64 @isdigit(i8 signext %11)
%13 = icmp eq i64 %12, 0
br i1 %13, label %24, label %14
14: ; preds = %8, %14
%15 = phi i8* [ %16, %14 ], [ %9, %8 ]
%16 = getelementptr inbounds i8, i8* %15, i64 1
%17 = load i8, i8* %16
%18 = tail call i64 @isxdigit(i8 signext %17)
%19 = icmp eq i64 %18, 0
br i1 %19, label %20, label %14
20: ; preds = %14
%21 = load i8, i8* %16
%22 = tail call signext i8 @upcase(i8 signext %21)
%23 = icmp eq i8 %22, 72
br i1 %23, label %45, label %24
24: ; preds = %20, %8
%25 = load i8, i8* %9
%26 = icmp eq i8 %25, 35
br i1 %26, label %27, label %34
27: ; preds = %24
%28 = getelementptr inbounds i8, i8* %9, i64 1
%29 = load i8, i8* %28
%30 = tail call i64 @isxdigit(i8 signext %29)
%31 = icmp eq i64 %30, 0
br i1 %31, label %32, label %45
32: ; preds = %27
%33 = load i8, i8* %9
br label %34
34: ; preds = %24, %32
%35 = phi i8 [ %33, %32 ], [ %25, %24 ]
%36 = icmp eq i8 %35, 48
br i1 %36, label %37, label %42
37: ; preds = %34
%38 = getelementptr inbounds i8, i8* %9, i64 1
%39 = load i8, i8* %38
%40 = tail call signext i8 @upcase(i8 signext %39)
%41 = icmp eq i8 %40, 88
br i1 %41, label %45, label %42
42: ; preds = %34, %37
%43 = tail call i64 @strncmp(i8* %9, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 3)
%44 = icmp eq i64 %43, 0
br i1 %44, label %45, label %83
45: ; preds = %37, %27, %42, %20
%46 = phi i1 [ false, %42 ], [ true, %20 ], [ true, %27 ], [ true, %37 ]
%47 = phi i1 [ true, %42 ], [ false, %20 ], [ true, %27 ], [ true, %37 ]
%48 = phi i64 [ 3, %42 ], [ 0, %20 ], [ 1, %27 ], [ 2, %37 ]
%49 = getelementptr inbounds i8, i8* %9, i64 %48
%50 = load i8, i8* %49
%51 = tail call i64 @isxdigit(i8 signext %50)
%52 = icmp eq i64 %51, 0
br i1 %52, label %64, label %53
53: ; preds = %45, %53
%54 = phi i8* [ %60, %53 ], [ %49, %45 ]
%55 = load i32, i32* %1
%56 = shl i32 %55, 4
%57 = load i8, i8* %54
%58 = tail call i32 @xtoi(i8 signext %57)
%59 = or i32 %58, %56
store i32 %59, i32* %1
%60 = getelementptr inbounds i8, i8* %54, i64 1
%61 = load i8, i8* %60
%62 = tail call i64 @isxdigit(i8 signext %61)
%63 = icmp eq i64 %62, 0
br i1 %63, label %64, label %53
64: ; preds = %53, %45
%65 = phi i8* [ %49, %45 ], [ %60, %53 ]
%66 = ptrtoint i8* %65 to i64
%67 = ptrtoint i8* %49 to i64
%68 = sub i64 %66, %67
%69 = icmp sgt i64 %68, 8
br i1 %69, label %70, label %72
70: ; preds = %64
%71 = tail call i32 (i8*, ...) @error(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.1, i64 0, i64 0), i8* %49)
br label %201
72: ; preds = %64
br i1 %47, label %75, label %73
73: ; preds = %72
%74 = getelementptr inbounds i8, i8* %65, i64 1
br label %196
75: ; preds = %72
br i1 %46, label %196, label %76
76: ; preds = %75
%77 = load i8, i8* %65
%78 = icmp eq i8 %77, 35
br i1 %78, label %81, label %79
79: ; preds = %76
%80 = tail call i32 (i8*, ...) @error(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.2, i64 0, i64 0))
br label %201
81: ; preds = %76
%82 = getelementptr inbounds i8, i8* %65, i64 1
br label %196
83: ; preds = %42
%84 = load i8, i8* %9
%85 = add i8 %84, -48
%86 = tail call i8 @llvm.fshl.i8(i8 %85, i8 %85, i8 7)
switch i8 %86, label %169 [
i8 0, label %91
i8 4, label %87
i8 8, label %132
i8 1, label %128
]
87: ; preds = %83
%88 = getelementptr inbounds i8, i8* %9, i64 1
%89 = load i8, i8* %88
%90 = icmp eq i8 %89, 35
br i1 %90, label %91, label %169
91: ; preds = %83, %87
%92 = phi i1 [ false, %87 ], [ true, %83 ]
%93 = phi i64 [ 2, %87 ], [ 1, %83 ]
%94 = getelementptr inbounds i8, i8* %9, i64 %93
%95 = load i8, i8* %94
%96 = and i8 %95, -8
%97 = icmp eq i8 %96, 48
br i1 %97, label %98, label %112
98: ; preds = %91
%99 = load i32, i32* %1
br label %100
100: ; preds = %98, %100
%101 = phi i32 [ %107, %100 ], [ %99, %98 ]
%102 = phi i8 [ %109, %100 ], [ %95, %98 ]
%103 = phi i8* [ %108, %100 ], [ %94, %98 ]
%104 = zext i8 %102 to i32
%105 = shl i32 %101, 3
%106 = add nsw i32 %104, -48
%107 = or i32 %105, %106
store i32 %107, i32* %1
%108 = getelementptr inbounds i8, i8* %103, i64 1
%109 = load i8, i8* %108
%110 = and i8 %109, -8
%111 = icmp eq i8 %110, 48
br i1 %111, label %100, label %112
112: ; preds = %100, %91
%113 = phi i8* [ %94, %91 ], [ %108, %100 ]
%114 = phi i8 [ %95, %91 ], [ %109, %100 ]
%115 = ptrtoint i8* %113 to i64
%116 = ptrtoint i8* %94 to i64
%117 = sub i64 %115, %116
%118 = icmp sgt i64 %117, 11
br i1 %118, label %119, label %121
119: ; preds = %112
%120 = tail call i32 (i8*, ...) @error(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.1, i64 0, i64 0), i8* %94)
br label %201
121: ; preds = %112
br i1 %92, label %196, label %122
122: ; preds = %121
%123 = icmp eq i8 %114, 35
br i1 %123, label %126, label %124
124: ; preds = %122
%125 = tail call i32 (i8*, ...) @error(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.2, i64 0, i64 0))
br label %201
126: ; preds = %122
%127 = getelementptr inbounds i8, i8* %113, i64 1
br label %196
128: ; preds = %83
%129 = getelementptr inbounds i8, i8* %9, i64 1
%130 = load i8, i8* %129
%131 = icmp eq i8 %130, 35
br i1 %131, label %132, label %169
132: ; preds = %83, %128
%133 = phi i1 [ false, %128 ], [ true, %83 ]
%134 = phi i64 [ 2, %128 ], [ 1, %83 ]
%135 = getelementptr inbounds i8, i8* %9, i64 %134
%136 = load i8, i8* %135
%137 = and i8 %136, -2
%138 = icmp eq i8 %137, 48
br i1 %138, label %139, label %153
139: ; preds = %132
%140 = load i32, i32* %1
br label %141
141: ; preds = %139, %141
%142 = phi i32 [ %148, %141 ], [ %140, %139 ]
%143 = phi i8 [ %150, %141 ], [ %136, %139 ]
%144 = phi i8* [ %149, %141 ], [ %135, %139 ]
%145 = shl i32 %142, 1
%146 = zext i8 %143 to i32
%147 = add nsw i32 %146, -48
%148 = or i32 %145, %147
store i32 %148, i32* %1
%149 = getelementptr inbounds i8, i8* %144, i64 1
%150 = load i8, i8* %149
%151 = and i8 %150, -2
%152 = icmp eq i8 %151, 48
br i1 %152, label %141, label %153
153: ; preds = %141, %132
%154 = phi i8* [ %135, %132 ], [ %149, %141 ]
%155 = phi i8 [ %136, %132 ], [ %150, %141 ]
%156 = ptrtoint i8* %154 to i64
%157 = ptrtoint i8* %135 to i64
%158 = sub i64 %156, %157
%159 = icmp sgt i64 %158, 32
br i1 %159, label %160, label %162
160: ; preds = %153
%161 = tail call i32 (i8*, ...) @error(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.1, i64 0, i64 0), i8* %135)
br label %201
162: ; preds = %153
br i1 %133, label %196, label %163
163: ; preds = %162
%164 = icmp eq i8 %155, 35
br i1 %164, label %167, label %165
165: ; preds = %163
%166 = tail call i32 (i8*, ...) @error(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.2, i64 0, i64 0))
br label %201
167: ; preds = %163
%168 = getelementptr inbounds i8, i8* %154, i64 1
br label %196
169: ; preds = %83, %87, %128
%170 = tail call i64 @isdigit(i8 signext %84)
%171 = icmp eq i64 %170, 0
br i1 %171, label %201, label %172
172: ; preds = %169
%173 = load i8, i8* %9
%174 = tail call i64 @isdigit(i8 signext %173)
%175 = icmp eq i64 %174, 0
br i1 %175, label %188, label %176
176: ; preds = %172, %176
%177 = phi i8* [ %184, %176 ], [ %9, %172 ]
%178 = load i32, i32* %1
%179 = mul nsw i32 %178, 10
%180 = load i8, i8* %177
%181 = sext i8 %180 to i32
%182 = add i32 %179, -48
%183 = add i32 %182, %181
store i32 %183, i32* %1
%184 = getelementptr inbounds i8, i8* %177, i64 1
%185 = load i8, i8* %184
%186 = tail call i64 @isdigit(i8 signext %185)
%187 = icmp eq i64 %186, 0
br i1 %187, label %188, label %176
188: ; preds = %176, %172
%189 = phi i8* [ %9, %172 ], [ %184, %176 ]
%190 = ptrtoint i8* %189 to i64
%191 = ptrtoint i8* %9 to i64
%192 = sub i64 %190, %191
%193 = icmp sgt i64 %192, 10
br i1 %193, label %194, label %196
194: ; preds = %188
%195 = tail call i32 (i8*, ...) @error(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.1, i64 0, i64 0), i8* %9)
br label %201
196: ; preds = %126, %121, %188, %162, %167, %73, %81, %75
%197 = phi i8* [ %74, %73 ], [ %82, %81 ], [ %65, %75 ], [ %127, %126 ], [ %113, %121 ], [ %168, %167 ], [ %154, %162 ], [ %189, %188 ]
br i1 %10, label %201, label %198
198: ; preds = %196
%199 = load i32, i32* %1
%200 = sub nsw i32 0, %199
store i32 %200, i32* %1
br label %201
201: ; preds = %196, %198, %169, %194, %165, %160, %124, %119, %79, %70
%202 = phi i8* [ null, %70 ], [ null, %79 ], [ null, %119 ], [ null, %124 ], [ null, %160 ], [ null, %165 ], [ null, %194 ], [ null, %169 ], [ %197, %198 ], [ %197, %196 ]
ret i8* %202
}