#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*/ eat_ws(char **);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ stderr;
int parse_numeric(long *val, char *str, int lineno) {
  char *start = str;
  int isneg = 0;
  eat_ws(&str);
  if (*str == '-') {
    isneg = 1;
    str++;
    eat_ws(&str);
    *val = 0;
    while ((*str >= '0') && (*str <= '9')) {
      *val *= 10;
      *val += (*str - '0');
      str++;
    }
    if (isneg)
      *val *= -1;
    eat_ws(&str);
    switch (*str) {
    case 0:
    case ')':
    case '+':
    case '-':
    case '*':
    case '/':
      return ((int)(str - start));
      break;
    default:
      fprintf(stderr, "--------------------------------------------------------"
                      "-----------------------\n");
      fprintf(stderr, "Problems parsing negative decimal \"%s\" at line %d.\n",
              start, lineno);
      return (-1);
      break;
    }
  }
  if (*str == '0') {
    *val = 0;
    str++;
    if ((*str == 'x') || (*str == 'X')) {
      str++;
      while ((*str != ' ') && (*str != '\t') && (*str != 0) && (*str != ')')) {
        if ((*str >= '0') && (*str <= '9')) {
          *val *= 16;
          *val += (*str - '0');
          str++;
        } else if ((*str >= 'a') && (*str <= 'f')) {
          *val *= 16;
          *val += ((*str - 'a') + 10);
          str++;
        } else if ((*str >= 'A') && (*str <= 'F')) {
          *val *= 16;
          *val += ((*str - 'A') + 10);
          str++;
        } else {
          *val = 0;
          fprintf(stderr, "----------------------------------------------------"
                          "---------------------------\n");
          fprintf(stderr, "Invalid character \"%c\" in hex \"%s\" line %d.\n",
                  *str, start, lineno);
          return (-1);
        }
      }
      return ((int)(str - start));
    }
    if ((*str == ' ') || (*str == '\t') || (*str == 0) || (*str == ')')) {
      *val = 0;
      return ((int)(str - start));
    }
  }
  if ((*str >= '0') && (*str <= '9')) {
    *val = 0;
    while ((*str >= '0') && (*str <= '9')) {
      *val *= 10;
      *val += (*str - '0');
      str++;
    }
    switch (*str) {
    case ' ':
    case '\t':
      eat_ws(&str);
      return ((int)(str - start));
      break;
    case 0:
    case ')':
    case '+':
    case '-':
    case '*':
    case '/':
      return ((int)(str - start));
      break;
    default:
      fprintf(stderr, "--------------------------------------------------------"
                      "-----------------------\n");
      fprintf(
          stderr,
          "Numeric value \"%s\" contained illegal char \"%c\" on line %d.\n",
          start, *str, lineno);
      return (-1);
      break;
    }
  }
  return (0);
}


x86 assembly (clang, -O0):
<parse_numeric>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
lea    -0x18(%rbp),%rdi
call   1030 <eat_ws@plt>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
jne    12a9 <parse_numeric+0x189>
movl   $0x1,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
lea    -0x18(%rbp),%rdi
call   1030 <eat_ws@plt>
mov    -0x10(%rbp),%rax
movq   $0x0,(%rax)
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x30,%ecx
mov    %al,-0x2d(%rbp)
jl     11a7 <parse_numeric+0x87>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x39,%eax
setle  %al
mov    %al,-0x2d(%rbp)
mov    -0x2d(%rbp),%al
test   $0x1,%al
jne    11b7 <parse_numeric+0x97>
jmp    11ea <parse_numeric+0xca>
mov    -0x10(%rbp),%rax
imul   $0xa,(%rax),%rcx
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
sub    $0x30,%eax
movslq %eax,%rcx
mov    -0x10(%rbp),%rax
add    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1182 <parse_numeric+0x62>
cmpl   $0x0,-0x2c(%rbp)
je     11ff <parse_numeric+0xdf>
mov    -0x10(%rbp),%rax
imul   $0xffffffffffffffff,(%rax),%rcx
mov    %rcx,(%rax)
lea    -0x18(%rbp),%rdi
call   1030 <eat_ws@plt>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x34(%rbp)
test   %eax,%eax
je     1255 <parse_numeric+0x135>
jmp    121f <parse_numeric+0xff>
mov    -0x34(%rbp),%eax
add    $0xffffffd7,%eax
sub    $0x3,%eax
jb     1255 <parse_numeric+0x135>
jmp    1233 <parse_numeric+0x113>
mov    -0x34(%rbp),%eax
sub    $0x2d,%eax
je     1255 <parse_numeric+0x135>
jmp    1244 <parse_numeric+0x124>
mov    -0x34(%rbp),%eax
sub    $0x2f,%eax
jne    1268 <parse_numeric+0x148>
jmp    1255 <parse_numeric+0x135>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x4(%rbp)
jmp    16bd <parse_numeric+0x59d>
mov    0x2d71(%rip),%rax
mov    (%rax),%edi
lea    0xd88(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    0x2d5a(%rip),%rax
mov    (%rax),%edi
mov    -0x28(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
lea    0xdbb(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    16bd <parse_numeric+0x59d>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jne    153c <parse_numeric+0x41c>
mov    -0x10(%rbp),%rax
movq   $0x0,(%rax)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x78,%eax
je     12f0 <parse_numeric+0x1d0>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x58,%eax
jne    14d9 <parse_numeric+0x3b9>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x20,%ecx
mov    %al,-0x35(%rbp)
je     134b <parse_numeric+0x22b>
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x9,%ecx
mov    %al,-0x35(%rbp)
je     134b <parse_numeric+0x22b>
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x35(%rbp)
je     134b <parse_numeric+0x22b>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x29,%eax
setne  %al
mov    %al,-0x35(%rbp)
mov    -0x35(%rbp),%al
test   $0x1,%al
jne    135b <parse_numeric+0x23b>
jmp    14c6 <parse_numeric+0x3a6>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jl     13b1 <parse_numeric+0x291>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x39,%eax
jg     13b1 <parse_numeric+0x291>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
shl    $0x4,%rcx
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
sub    $0x30,%eax
movslq %eax,%rcx
mov    -0x10(%rbp),%rax
add    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    14c1 <parse_numeric+0x3a1>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x61,%eax
jl     140a <parse_numeric+0x2ea>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x66,%eax
jg     140a <parse_numeric+0x2ea>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
shl    $0x4,%rcx
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
sub    $0x61,%eax
add    $0xa,%eax
movslq %eax,%rcx
mov    -0x10(%rbp),%rax
add    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    14bc <parse_numeric+0x39c>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x41,%eax
jl     1463 <parse_numeric+0x343>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x46,%eax
jg     1463 <parse_numeric+0x343>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
shl    $0x4,%rcx
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
sub    $0x41,%eax
add    $0xa,%eax
movslq %eax,%rcx
mov    -0x10(%rbp),%rax
add    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    14b7 <parse_numeric+0x397>
mov    -0x10(%rbp),%rax
movq   $0x0,(%rax)
mov    0x2b6b(%rip),%rax
mov    (%rax),%edi
lea    0xb82(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    0x2b54(%rip),%rax
mov    (%rax),%edi
mov    -0x18(%rbp),%rax
movsbl (%rax),%edx
mov    -0x28(%rbp),%rcx
mov    -0x1c(%rbp),%r8d
lea    0xbe1(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    16bd <parse_numeric+0x59d>
jmp    14bc <parse_numeric+0x39c>
jmp    14c1 <parse_numeric+0x3a1>
jmp    12fc <parse_numeric+0x1dc>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x4(%rbp)
jmp    16bd <parse_numeric+0x59d>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
je     1519 <parse_numeric+0x3f9>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x9,%eax
je     1519 <parse_numeric+0x3f9>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     1519 <parse_numeric+0x3f9>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x29,%eax
jne    1537 <parse_numeric+0x417>
mov    -0x10(%rbp),%rax
movq   $0x0,(%rax)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x4(%rbp)
jmp    16bd <parse_numeric+0x59d>
jmp    153c <parse_numeric+0x41c>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jl     16b6 <parse_numeric+0x596>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x39,%eax
jg     16b6 <parse_numeric+0x596>
mov    -0x10(%rbp),%rax
movq   $0x0,(%rax)
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x30,%ecx
mov    %al,-0x36(%rbp)
jl     158c <parse_numeric+0x46c>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x39,%eax
setle  %al
mov    %al,-0x36(%rbp)
mov    -0x36(%rbp),%al
test   $0x1,%al
jne    159c <parse_numeric+0x47c>
jmp    15cf <parse_numeric+0x4af>
mov    -0x10(%rbp),%rax
imul   $0xa,(%rax),%rcx
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
sub    $0x30,%eax
movslq %eax,%rcx
mov    -0x10(%rbp),%rax
add    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1567 <parse_numeric+0x447>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x3c(%rbp)
test   %eax,%eax
je     165a <parse_numeric+0x53a>
jmp    15e6 <parse_numeric+0x4c6>
mov    -0x3c(%rbp),%eax
sub    $0x9,%eax
je     163e <parse_numeric+0x51e>
jmp    15f7 <parse_numeric+0x4d7>
mov    -0x3c(%rbp),%eax
sub    $0x20,%eax
je     163e <parse_numeric+0x51e>
jmp    1608 <parse_numeric+0x4e8>
mov    -0x3c(%rbp),%eax
add    $0xffffffd7,%eax
sub    $0x3,%eax
jb     165a <parse_numeric+0x53a>
jmp    161c <parse_numeric+0x4fc>
mov    -0x3c(%rbp),%eax
sub    $0x2d,%eax
je     165a <parse_numeric+0x53a>
jmp    162d <parse_numeric+0x50d>
mov    -0x3c(%rbp),%eax
sub    $0x2f,%eax
je     165a <parse_numeric+0x53a>
jmp    166d <parse_numeric+0x54d>
lea    -0x18(%rbp),%rdi
call   1030 <eat_ws@plt>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x4(%rbp)
jmp    16bd <parse_numeric+0x59d>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x4(%rbp)
jmp    16bd <parse_numeric+0x59d>
mov    0x296c(%rip),%rax
mov    (%rax),%edi
lea    0x983(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    0x2955(%rip),%rax
mov    (%rax),%edi
mov    -0x28(%rbp),%rdx
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
mov    -0x1c(%rbp),%r8d
lea    0xa0f(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    16bd <parse_numeric+0x59d>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<parse_numeric>:
push   %rbp
push   %r14
push   %rbx
sub    $0x10,%rsp
mov    %edx,%r14d
mov    %rsi,%rbx
mov    %rdi,%rbp
mov    %rsi,0x8(%rsp)
lea    0x8(%rsp),%rdi
call   1030 <eat_ws@plt>
mov    0x8(%rsp),%rax
mov    (%rax),%dl
cmp    $0x30,%dl
je     11c4 <parse_numeric+0xa4>
cmp    $0x2d,%dl
jne    129d <parse_numeric+0x17d>
add    $0x1,%rax
mov    %rax,0x8(%rsp)
lea    0x8(%rsp),%rdi
call   1030 <eat_ws@plt>
movq   $0x0,0x0(%rbp)
mov    0x8(%rsp),%rax
mov    (%rax),%cl
add    $0xd0,%cl
cmp    $0x9,%cl
ja     1326 <parse_numeric+0x206>
add    $0x1,%rax
xor    %ecx,%ecx
nopl   0x0(%rax)
add    %rcx,%rcx
lea    (%rcx,%rcx,4),%rcx
mov    %rcx,0x0(%rbp)
movsbq -0x1(%rax),%rdx
add    %rdx,%rcx
add    $0xffffffffffffffd0,%rcx
mov    %rcx,0x0(%rbp)
mov    %rax,0x8(%rsp)
movzbl (%rax),%edx
add    $0xd0,%dl
add    $0x1,%rax
cmp    $0xa,%dl
jb     1190 <parse_numeric+0x70>
jmp    1328 <parse_numeric+0x208>
movq   $0x0,0x0(%rbp)
lea    0x1(%rax),%rcx
mov    %rcx,0x8(%rsp)
movzbl 0x1(%rax),%edx
cmp    $0x29,%rdx
ja     11f3 <parse_numeric+0xd3>
movabs $0x20100000201,%rsi
bt     %rdx,%rsi
jb     1320 <parse_numeric+0x200>
cmp    $0x78,%dl
je     1201 <parse_numeric+0xe1>
cmp    $0x58,%dl
jne    12a0 <parse_numeric+0x180>
add    $0x2,%rax
mov    %rax,0x8(%rsp)
xor    %ecx,%ecx
movabs $0x20100000201,%rdx
jmp    1240 <parse_numeric+0x120>
nopl   0x0(%rax,%rax,1)
shl    $0x4,%rcx
mov    %rcx,0x0(%rbp)
movsbq (%rax),%rsi
add    %rsi,%rcx
add    $0xffffffffffffffd0,%rcx
mov    %rcx,0x0(%rbp)
add    $0x1,%rax
mov    %rax,0x8(%rsp)
movzbl (%rax),%esi
cmp    $0x29,%rsi
ja     1253 <parse_numeric+0x133>
bt     %rsi,%rdx
jb     1356 <parse_numeric+0x236>
lea    -0x30(%rsi),%edi
cmp    $0x9,%dil
jbe    1220 <parse_numeric+0x100>
lea    -0x61(%rsi),%edi
cmp    $0x5,%dil
ja     127a <parse_numeric+0x15a>
shl    $0x4,%rcx
mov    %rcx,0x0(%rbp)
movsbq (%rax),%rsi
add    %rsi,%rcx
add    $0xffffffffffffffa9,%rcx
jmp    1233 <parse_numeric+0x113>
add    $0xbf,%sil
cmp    $0x5,%sil
ja     13ed <parse_numeric+0x2cd>
shl    $0x4,%rcx
mov    %rcx,0x0(%rbp)
movsbq (%rax),%rsi
add    %rsi,%rcx
add    $0xffffffffffffffc9,%rcx
jmp    1233 <parse_numeric+0x113>
mov    %rax,%rcx
add    $0xd0,%dl
xor    %eax,%eax
cmp    $0x9,%dl
ja     1358 <parse_numeric+0x238>
movq   $0x0,0x0(%rbp)
mov    (%rcx),%al
lea    -0x30(%rax),%edx
cmp    $0x9,%dl
ja     1304 <parse_numeric+0x1e4>
add    $0x1,%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
add    %rdx,%rdx
lea    (%rdx,%rdx,4),%rax
mov    %rax,0x0(%rbp)
movsbq -0x1(%rcx),%rdx
add    %rax,%rdx
add    $0xffffffffffffffd0,%rdx
mov    %rdx,0x0(%rbp)
mov    %rcx,0x8(%rsp)
movzbl (%rcx),%eax
lea    -0x30(%rax),%esi
add    $0x1,%rcx
cmp    $0xa,%sil
jb     12d0 <parse_numeric+0x1b0>
add    $0xffffffffffffffff,%rcx
movsbl %al,%eax
cmp    $0x2f,%eax
ja     13b4 <parse_numeric+0x294>
movabs $0xae0000000001,%rdx
bt     %rax,%rdx
jae    1361 <parse_numeric+0x241>
sub    %ebx,%ecx
mov    %ecx,%eax
jmp    1358 <parse_numeric+0x238>
xor    %ecx,%ecx
neg    %rcx
mov    %rcx,0x0(%rbp)
lea    0x8(%rsp),%rdi
call   1030 <eat_ws@plt>
mov    0x8(%rsp),%rax
movsbl (%rax),%ecx
cmp    $0x2f,%ecx
ja     1383 <parse_numeric+0x263>
movabs $0xae0000000001,%rdx
bt     %rcx,%rdx
jae    1383 <parse_numeric+0x263>
sub    %ebx,%eax
add    $0x10,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret
movabs $0x100000200,%rcx
bt     %rax,%rcx
jae    13b4 <parse_numeric+0x294>
lea    0x8(%rsp),%rdi
call   1030 <eat_ws@plt>
mov    0x8(%rsp),%eax
sub    %ebx,%eax
jmp    1358 <parse_numeric+0x238>
mov    0x2c56(%rip),%rbp
mov    0x0(%rbp),%edi
lea    0xc6c(%rip),%rsi
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0x0(%rbp),%edi
lea    0xcac(%rip),%rsi
mov    %rbx,%rdx
mov    %r14d,%ecx
xor    %eax,%eax
call   1040 <fprintf@plt>
jmp    142c <parse_numeric+0x30c>
mov    0x2c25(%rip),%rbp
mov    0x0(%rbp),%edi
lea    0xc3b(%rip),%rsi
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0x0(%rbp),%edi
mov    0x8(%rsp),%rax
movsbl (%rax),%ecx
lea    0xcd4(%rip),%rsi
mov    %rbx,%rdx
mov    %r14d,%r8d
xor    %eax,%eax
call   1040 <fprintf@plt>
jmp    142c <parse_numeric+0x30c>
movq   $0x0,0x0(%rbp)
mov    0x2be4(%rip),%rbp
mov    0x0(%rbp),%edi
lea    0xbfa(%rip),%rsi
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0x0(%rbp),%edi
mov    0x8(%rsp),%rax
movsbl (%rax),%edx
lea    0xc66(%rip),%rsi
mov    %rbx,%rcx
mov    %r14d,%r8d
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    $0xffffffff,%eax
jmp    1358 <parse_numeric+0x238>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [81 x i8] c"-------------------------------------------------------------------------------\0A\00"
@.str.1 = [52 x i8] c"Problems parsing negative decimal \22%s\22 at line %d.\0A\00"
@.str.2 = [45 x i8] c"Invalid character \22%c\22 in hex \22%s\22 line %d.\0A\00"
@.str.3 = [60 x i8] c"Numeric value \22%s\22 contained illegal char \22%c\22 on line %d.\0A\00"
define i32 @parse_numeric(i64* %0, i8* %1, i32 %2) {
%4 = alloca i32
%5 = alloca i64*
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i32
store i64* %0, i64** %5
store i8* %1, i8** %6
store i32 %2, i32* %7
%10 = load i8*, i8** %6
store i8* %10, i8** %8
store i32 0, i32* %9
%11 = call i32 @eat_ws(i8** %6)
%12 = load i8*, i8** %6
%13 = load i8, i8* %12
%14 = sext i8 %13 to i32
%15 = icmp eq i32 %14, 45
br i1 %15, label %16, label %73
16: ; preds = %3
store i32 1, i32* %9
%17 = load i8*, i8** %6
%18 = getelementptr inbounds i8, i8* %17, i32 1
store i8* %18, i8** %6
%19 = call i32 @eat_ws(i8** %6)
%20 = load i64*, i64** %5
store i64 0, i64* %20
br label %21
21: ; preds = %33, %16
%22 = load i8*, i8** %6
%23 = load i8, i8* %22
%24 = sext i8 %23 to i32
%25 = icmp sge i32 %24, 48
br i1 %25, label %26, label %31
26: ; preds = %21
%27 = load i8*, i8** %6
%28 = load i8, i8* %27
%29 = sext i8 %28 to i32
%30 = icmp sle i32 %29, 57
br label %31
31: ; preds = %26, %21
%32 = phi i1 [ false, %21 ], [ %30, %26 ]
br i1 %32, label %33, label %47
33: ; preds = %31
%34 = load i64*, i64** %5
%35 = load i64, i64* %34
%36 = mul nsw i64 %35, 10
store i64 %36, i64* %34
%37 = load i8*, i8** %6
%38 = load i8, i8* %37
%39 = sext i8 %38 to i32
%40 = sub nsw i32 %39, 48
%41 = sext i32 %40 to i64
%42 = load i64*, i64** %5
%43 = load i64, i64* %42
%44 = add nsw i64 %43, %41
store i64 %44, i64* %42
%45 = load i8*, i8** %6
%46 = getelementptr inbounds i8, i8* %45, i32 1
store i8* %46, i8** %6
br label %21
47: ; preds = %31
%48 = load i32, i32* %9
%49 = icmp ne i32 %48, 0
br i1 %49, label %50, label %54
50: ; preds = %47
%51 = load i64*, i64** %5
%52 = load i64, i64* %51
%53 = mul nsw i64 %52, -1
store i64 %53, i64* %51
br label %54
54: ; preds = %50, %47
%55 = call i32 @eat_ws(i8** %6)
%56 = load i8*, i8** %6
%57 = load i8, i8* %56
%58 = sext i8 %57 to i32
switch i32 %58, label %66 [
i32 0, label %59
i32 41, label %59
i32 43, label %59
i32 45, label %59
i32 42, label %59
i32 47, label %59
]
59: ; preds = %54, %54, %54, %54, %54, %54
%60 = load i8*, i8** %6
%61 = load i8*, i8** %8
%62 = ptrtoint i8* %60 to i64
%63 = ptrtoint i8* %61 to i64
%64 = sub i64 %62, %63
%65 = trunc i64 %64 to i32
store i32 %65, i32* %4
br label %308
66: ; preds = %54
%67 = load i32, i32* @stderr
%68 = call i32 (i32, i8*, ...) @fprintf(i32 %67, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str, i64 0, i64 0))
%69 = load i32, i32* @stderr
%70 = load i8*, i8** %8
%71 = load i32, i32* %7
%72 = call i32 (i32, i8*, ...) @fprintf(i32 %69, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.1, i64 0, i64 0), i8* %70, i32 %71)
store i32 -1, i32* %4
br label %308
73: ; preds = %3
%74 = load i8*, i8** %6
%75 = load i8, i8* %74
%76 = sext i8 %75 to i32
%77 = icmp eq i32 %76, 48
br i1 %77, label %78, label %240
78: ; preds = %73
%79 = load i64*, i64** %5
store i64 0, i64* %79
%80 = load i8*, i8** %6
%81 = getelementptr inbounds i8, i8* %80, i32 1
store i8* %81, i8** %6
%82 = load i8*, i8** %6
%83 = load i8, i8* %82
%84 = sext i8 %83 to i32
%85 = icmp eq i32 %84, 120
br i1 %85, label %91, label %86
86: ; preds = %78
%87 = load i8*, i8** %6
%88 = load i8, i8* %87
%89 = sext i8 %88 to i32
%90 = icmp eq i32 %89, 88
br i1 %90, label %91, label %211
91: ; preds = %86, %78
%92 = load i8*, i8** %6
%93 = getelementptr inbounds i8, i8* %92, i32 1
store i8* %93, i8** %6
br label %94
94: ; preds = %203, %91
%95 = load i8*, i8** %6
%96 = load i8, i8* %95
%97 = sext i8 %96 to i32
%98 = icmp ne i32 %97, 32
br i1 %98, label %99, label %114
99: ; preds = %94
%100 = load i8*, i8** %6
%101 = load i8, i8* %100
%102 = sext i8 %101 to i32
%103 = icmp ne i32 %102, 9
br i1 %103, label %104, label %114
104: ; preds = %99
%105 = load i8*, i8** %6
%106 = load i8, i8* %105
%107 = sext i8 %106 to i32
%108 = icmp ne i32 %107, 0
br i1 %108, label %109, label %114
109: ; preds = %104
%110 = load i8*, i8** %6
%111 = load i8, i8* %110
%112 = sext i8 %111 to i32
%113 = icmp ne i32 %112, 41
br label %114
114: ; preds = %109, %104, %99, %94
%115 = phi i1 [ false, %104 ], [ false, %99 ], [ false, %94 ], [ %113, %109 ]
br i1 %115, label %116, label %204
116: ; preds = %114
%117 = load i8*, i8** %6
%118 = load i8, i8* %117
%119 = sext i8 %118 to i32
%120 = icmp sge i32 %119, 48
br i1 %120, label %121, label %140
121: ; preds = %116
%122 = load i8*, i8** %6
%123 = load i8, i8* %122
%124 = sext i8 %123 to i32
%125 = icmp sle i32 %124, 57
br i1 %125, label %126, label %140
126: ; preds = %121
%127 = load i64*, i64** %5
%128 = load i64, i64* %127
%129 = mul nsw i64 %128, 16
store i64 %129, i64* %127
%130 = load i8*, i8** %6
%131 = load i8, i8* %130
%132 = sext i8 %131 to i32
%133 = sub nsw i32 %132, 48
%134 = sext i32 %133 to i64
%135 = load i64*, i64** %5
%136 = load i64, i64* %135
%137 = add nsw i64 %136, %134
store i64 %137, i64* %135
%138 = load i8*, i8** %6
%139 = getelementptr inbounds i8, i8* %138, i32 1
store i8* %139, i8** %6
br label %203
140: ; preds = %121, %116
%141 = load i8*, i8** %6
%142 = load i8, i8* %141
%143 = sext i8 %142 to i32
%144 = icmp sge i32 %143, 97
br i1 %144, label %145, label %165
145: ; preds = %140
%146 = load i8*, i8** %6
%147 = load i8, i8* %146
%148 = sext i8 %147 to i32
%149 = icmp sle i32 %148, 102
br i1 %149, label %150, label %165
150: ; preds = %145
%151 = load i64*, i64** %5
%152 = load i64, i64* %151
%153 = mul nsw i64 %152, 16
store i64 %153, i64* %151
%154 = load i8*, i8** %6
%155 = load i8, i8* %154
%156 = sext i8 %155 to i32
%157 = sub nsw i32 %156, 97
%158 = add nsw i32 %157, 10
%159 = sext i32 %158 to i64
%160 = load i64*, i64** %5
%161 = load i64, i64* %160
%162 = add nsw i64 %161, %159
store i64 %162, i64* %160
%163 = load i8*, i8** %6
%164 = getelementptr inbounds i8, i8* %163, i32 1
store i8* %164, i8** %6
br label %202
165: ; preds = %145, %140
%166 = load i8*, i8** %6
%167 = load i8, i8* %166
%168 = sext i8 %167 to i32
%169 = icmp sge i32 %168, 65
br i1 %169, label %170, label %190
170: ; preds = %165
%171 = load i8*, i8** %6
%172 = load i8, i8* %171
%173 = sext i8 %172 to i32
%174 = icmp sle i32 %173, 70
br i1 %174, label %175, label %190
175: ; preds = %170
%176 = load i64*, i64** %5
%177 = load i64, i64* %176
%178 = mul nsw i64 %177, 16
store i64 %178, i64* %176
%179 = load i8*, i8** %6
%180 = load i8, i8* %179
%181 = sext i8 %180 to i32
%182 = sub nsw i32 %181, 65
%183 = add nsw i32 %182, 10
%184 = sext i32 %183 to i64
%185 = load i64*, i64** %5
%186 = load i64, i64* %185
%187 = add nsw i64 %186, %184
store i64 %187, i64* %185
%188 = load i8*, i8** %6
%189 = getelementptr inbounds i8, i8* %188, i32 1
store i8* %189, i8** %6
br label %201
190: ; preds = %170, %165
%191 = load i64*, i64** %5
store i64 0, i64* %191
%192 = load i32, i32* @stderr
%193 = call i32 (i32, i8*, ...) @fprintf(i32 %192, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str, i64 0, i64 0))
%194 = load i32, i32* @stderr
%195 = load i8*, i8** %6
%196 = load i8, i8* %195
%197 = sext i8 %196 to i32
%198 = load i8*, i8** %8
%199 = load i32, i32* %7
%200 = call i32 (i32, i8*, ...) @fprintf(i32 %194, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.2, i64 0, i64 0), i32 %197, i8* %198, i32 %199)
store i32 -1, i32* %4
br label %308
201: ; preds = %175
br label %202
202: ; preds = %201, %150
br label %203
203: ; preds = %202, %126
br label %94
204: ; preds = %114
%205 = load i8*, i8** %6
%206 = load i8*, i8** %8
%207 = ptrtoint i8* %205 to i64
%208 = ptrtoint i8* %206 to i64
%209 = sub i64 %207, %208
%210 = trunc i64 %209 to i32
store i32 %210, i32* %4
br label %308
211: ; preds = %86
%212 = load i8*, i8** %6
%213 = load i8, i8* %212
%214 = sext i8 %213 to i32
%215 = icmp eq i32 %214, 32
br i1 %215, label %231, label %216
216: ; preds = %211
%217 = load i8*, i8** %6
%218 = load i8, i8* %217
%219 = sext i8 %218 to i32
%220 = icmp eq i32 %219, 9
br i1 %220, label %231, label %221
221: ; preds = %216
%222 = load i8*, i8** %6
%223 = load i8, i8* %222
%224 = sext i8 %223 to i32
%225 = icmp eq i32 %224, 0
br i1 %225, label %231, label %226
226: ; preds = %221
%227 = load i8*, i8** %6
%228 = load i8, i8* %227
%229 = sext i8 %228 to i32
%230 = icmp eq i32 %229, 41
br i1 %230, label %231, label %239
231: ; preds = %226, %221, %216, %211
%232 = load i64*, i64** %5
store i64 0, i64* %232
%233 = load i8*, i8** %6
%234 = load i8*, i8** %8
%235 = ptrtoint i8* %233 to i64
%236 = ptrtoint i8* %234 to i64
%237 = sub i64 %235, %236
%238 = trunc i64 %237 to i32
store i32 %238, i32* %4
br label %308
239: ; preds = %226
br label %240
240: ; preds = %239, %73
%241 = load i8*, i8** %6
%242 = load i8, i8* %241
%243 = sext i8 %242 to i32
%244 = icmp sge i32 %243, 48
br i1 %244, label %245, label %307
245: ; preds = %240
%246 = load i8*, i8** %6
%247 = load i8, i8* %246
%248 = sext i8 %247 to i32
%249 = icmp sle i32 %248, 57
br i1 %249, label %250, label %307
250: ; preds = %245
%251 = load i64*, i64** %5
store i64 0, i64* %251
br label %252
252: ; preds = %264, %250
%253 = load i8*, i8** %6
%254 = load i8, i8* %253
%255 = sext i8 %254 to i32
%256 = icmp sge i32 %255, 48
br i1 %256, label %257, label %262
257: ; preds = %252
%258 = load i8*, i8** %6
%259 = load i8, i8* %258
%260 = sext i8 %259 to i32
%261 = icmp sle i32 %260, 57
br label %262
262: ; preds = %257, %252
%263 = phi i1 [ false, %252 ], [ %261, %257 ]
br i1 %263, label %264, label %278
264: ; preds = %262
%265 = load i64*, i64** %5
%266 = load i64, i64* %265
%267 = mul nsw i64 %266, 10
store i64 %267, i64* %265
%268 = load i8*, i8** %6
%269 = load i8, i8* %268
%270 = sext i8 %269 to i32
%271 = sub nsw i32 %270, 48
%272 = sext i32 %271 to i64
%273 = load i64*, i64** %5
%274 = load i64, i64* %273
%275 = add nsw i64 %274, %272
store i64 %275, i64* %273
%276 = load i8*, i8** %6
%277 = getelementptr inbounds i8, i8* %276, i32 1
store i8* %277, i8** %6
br label %252
278: ; preds = %262
%279 = load i8*, i8** %6
%280 = load i8, i8* %279
%281 = sext i8 %280 to i32
switch i32 %281, label %297 [
i32 32, label %282
i32 9, label %282
i32 0, label %290
i32 41, label %290
i32 43, label %290
i32 45, label %290
i32 42, label %290
i32 47, label %290
]
282: ; preds = %278, %278
%283 = call i32 @eat_ws(i8** %6)
%284 = load i8*, i8** %6
%285 = load i8*, i8** %8
%286 = ptrtoint i8* %284 to i64
%287 = ptrtoint i8* %285 to i64
%288 = sub i64 %286, %287
%289 = trunc i64 %288 to i32
store i32 %289, i32* %4
br label %308
290: ; preds = %278, %278, %278, %278, %278, %278
%291 = load i8*, i8** %6
%292 = load i8*, i8** %8
%293 = ptrtoint i8* %291 to i64
%294 = ptrtoint i8* %292 to i64
%295 = sub i64 %293, %294
%296 = trunc i64 %295 to i32
store i32 %296, i32* %4
br label %308
297: ; preds = %278
%298 = load i32, i32* @stderr
%299 = call i32 (i32, i8*, ...) @fprintf(i32 %298, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str, i64 0, i64 0))
%300 = load i32, i32* @stderr
%301 = load i8*, i8** %8
%302 = load i8*, i8** %6
%303 = load i8, i8* %302
%304 = sext i8 %303 to i32
%305 = load i32, i32* %7
%306 = call i32 (i32, i8*, ...) @fprintf(i32 %300, i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.3, i64 0, i64 0), i8* %301, i32 %304, i32 %305)
store i32 -1, i32* %4
br label %308
307: ; preds = %245, %240
store i32 0, i32* %4
br label %308
308: ; preds = %307, %297, %290, %282, %231, %204, %190, %66, %59
%309 = load i32, i32* %4
ret i32 %309
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [81 x i8] c"-------------------------------------------------------------------------------\0A\00"
@.str.1 = [52 x i8] c"Problems parsing negative decimal \22%s\22 at line %d.\0A\00"
@.str.2 = [45 x i8] c"Invalid character \22%c\22 in hex \22%s\22 line %d.\0A\00"
@.str.3 = [60 x i8] c"Numeric value \22%s\22 contained illegal char \22%c\22 on line %d.\0A\00"
define i32 @parse_numeric(i64* %0, i8* %1, i32 %2) {
%4 = alloca i8*
store i8* %1, i8** %4
%5 = call i32 @eat_ws(i8** %4)
%6 = load i8*, i8** %4
%7 = load i8, i8* %6
switch i8 %7, label %104 [
i8 45, label %8
i8 48, label %44
]
8: ; preds = %3
%9 = getelementptr inbounds i8, i8* %6, i64 1
store i8* %9, i8** %4
%10 = call i32 @eat_ws(i8** %4)
store i64 0, i64* %0
%11 = load i8*, i8** %4
%12 = load i8, i8* %11
%13 = add i8 %12, -48
%14 = icmp ult i8 %13, 10
br i1 %14, label %15, label %27
15: ; preds = %8, %15
%16 = phi i64 [ %22, %15 ], [ 0, %8 ]
%17 = phi i8* [ %23, %15 ], [ %11, %8 ]
%18 = mul nsw i64 %16, 10
store i64 %18, i64* %0
%19 = load i8, i8* %17
%20 = sext i8 %19 to i64
%21 = add i64 %18, -48
%22 = add i64 %21, %20
store i64 %22, i64* %0
%23 = getelementptr inbounds i8, i8* %17, i64 1
store i8* %23, i8** %4
%24 = load i8, i8* %23
%25 = add i8 %24, -48
%26 = icmp ult i8 %25, 10
br i1 %26, label %15, label %27
27: ; preds = %15, %8
%28 = phi i64 [ 0, %8 ], [ %22, %15 ]
%29 = sub nsw i64 0, %28
store i64 %29, i64* %0
%30 = call i32 @eat_ws(i8** %4)
%31 = load i8*, i8** %4
%32 = load i8, i8* %31
%33 = sext i8 %32 to i32
switch i32 %33, label %39 [
i32 0, label %34
i32 41, label %34
i32 43, label %34
i32 45, label %34
i32 42, label %34
i32 47, label %34
]
34: ; preds = %27, %27, %27, %27, %27, %27
%35 = ptrtoint i8* %31 to i64
%36 = ptrtoint i8* %1 to i64
%37 = sub i64 %35, %36
%38 = trunc i64 %37 to i32
br label %149
39: ; preds = %27
%40 = load i32, i32* @stderr
%41 = call i32 (i32, i8*, ...) @fprintf(i32 %40, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str, i64 0, i64 0))
%42 = load i32, i32* @stderr
%43 = call i32 (i32, i8*, ...) @fprintf(i32 %42, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.1, i64 0, i64 0), i8* %1, i32 %2)
br label %149
44: ; preds = %3
store i64 0, i64* %0
%45 = getelementptr inbounds i8, i8* %6, i64 1
store i8* %45, i8** %4
%46 = load i8, i8* %45
switch i8 %46, label %104 [
i8 120, label %47
i8 88, label %47
i8 32, label %99
i8 9, label %99
i8 0, label %99
i8 41, label %99
]
47: ; preds = %44, %44
%48 = getelementptr inbounds i8, i8* %6, i64 2
store i8* %48, i8** %4
br label %49
49: ; preds = %73, %47
%50 = phi i64 [ 0, %47 ], [ %74, %73 ]
%51 = phi i8* [ %48, %47 ], [ %75, %73 ]
%52 = load i8, i8* %51
switch i8 %52, label %53 [
i8 32, label %94
i8 9, label %94
i8 0, label %94
i8 41, label %94
]
53: ; preds = %49
%54 = add i8 %52, -48
%55 = icmp ult i8 %54, 10
br i1 %55, label %56, label %63
56: ; preds = %53
%57 = shl nsw i64 %50, 4
store i64 %57, i64* %0
%58 = load i8, i8* %51
%59 = sext i8 %58 to i64
%60 = add i64 %57, -48
%61 = add i64 %60, %59
store i64 %61, i64* %0
%62 = getelementptr inbounds i8, i8* %51, i64 1
store i8* %62, i8** %4
br label %73
63: ; preds = %53
%64 = add i8 %52, -97
%65 = icmp ult i8 %64, 6
br i1 %65, label %66, label %76
66: ; preds = %63
%67 = shl nsw i64 %50, 4
store i64 %67, i64* %0
%68 = load i8, i8* %51
%69 = sext i8 %68 to i64
%70 = add i64 %67, -87
%71 = add i64 %70, %69
store i64 %71, i64* %0
%72 = getelementptr inbounds i8, i8* %51, i64 1
store i8* %72, i8** %4
br label %73
73: ; preds = %66, %79, %56
%74 = phi i64 [ %71, %66 ], [ %84, %79 ], [ %61, %56 ]
%75 = phi i8* [ %72, %66 ], [ %85, %79 ], [ %62, %56 ]
br label %49
76: ; preds = %63
%77 = add i8 %52, -65
%78 = icmp ult i8 %77, 6
br i1 %78, label %79, label %86
79: ; preds = %76
%80 = shl nsw i64 %50, 4
store i64 %80, i64* %0
%81 = load i8, i8* %51
%82 = sext i8 %81 to i64
%83 = add i64 %80, -55
%84 = add i64 %83, %82
store i64 %84, i64* %0
%85 = getelementptr inbounds i8, i8* %51, i64 1
store i8* %85, i8** %4
br label %73
86: ; preds = %76
store i64 0, i64* %0
%87 = load i32, i32* @stderr
%88 = call i32 (i32, i8*, ...) @fprintf(i32 %87, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str, i64 0, i64 0))
%89 = load i32, i32* @stderr
%90 = load i8*, i8** %4
%91 = load i8, i8* %90
%92 = sext i8 %91 to i32
%93 = call i32 (i32, i8*, ...) @fprintf(i32 %89, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.2, i64 0, i64 0), i32 %92, i8* %1, i32 %2)
br label %149
94: ; preds = %49, %49, %49, %49
%95 = ptrtoint i8* %51 to i64
%96 = ptrtoint i8* %1 to i64
%97 = sub i64 %95, %96
%98 = trunc i64 %97 to i32
br label %149
99: ; preds = %44, %44, %44, %44
%100 = ptrtoint i8* %45 to i64
%101 = ptrtoint i8* %1 to i64
%102 = sub i64 %100, %101
%103 = trunc i64 %102 to i32
br label %149
104: ; preds = %44, %3
%105 = phi i8 [ %46, %44 ], [ %7, %3 ]
%106 = phi i8* [ %45, %44 ], [ %6, %3 ]
%107 = add i8 %105, -48
%108 = icmp ult i8 %107, 10
br i1 %108, label %109, label %149
109: ; preds = %104
store i64 0, i64* %0
%110 = load i8, i8* %106
%111 = add i8 %110, -48
%112 = icmp ult i8 %111, 10
br i1 %112, label %113, label %125
113: ; preds = %109, %113
%114 = phi i64 [ %120, %113 ], [ 0, %109 ]
%115 = phi i8* [ %121, %113 ], [ %106, %109 ]
%116 = mul nsw i64 %114, 10
store i64 %116, i64* %0
%117 = load i8, i8* %115
%118 = sext i8 %117 to i64
%119 = add i64 %116, -48
%120 = add i64 %119, %118
store i64 %120, i64* %0
%121 = getelementptr inbounds i8, i8* %115, i64 1
store i8* %121, i8** %4
%122 = load i8, i8* %121
%123 = add i8 %122, -48
%124 = icmp ult i8 %123, 10
br i1 %124, label %113, label %125
125: ; preds = %113, %109
%126 = phi i8* [ %106, %109 ], [ %121, %113 ]
%127 = phi i8 [ %110, %109 ], [ %122, %113 ]
%128 = sext i8 %127 to i32
switch i32 %128, label %141 [
i32 32, label %129
i32 9, label %129
i32 0, label %136
i32 41, label %136
i32 43, label %136
i32 45, label %136
i32 42, label %136
i32 47, label %136
]
129: ; preds = %125, %125
%130 = call i32 @eat_ws(i8** %4)
%131 = load i8*, i8** %4
%132 = ptrtoint i8* %131 to i64
%133 = ptrtoint i8* %1 to i64
%134 = sub i64 %132, %133
%135 = trunc i64 %134 to i32
br label %149
136: ; preds = %125, %125, %125, %125, %125, %125
%137 = ptrtoint i8* %126 to i64
%138 = ptrtoint i8* %1 to i64
%139 = sub i64 %137, %138
%140 = trunc i64 %139 to i32
br label %149
141: ; preds = %125
%142 = load i32, i32* @stderr
%143 = call i32 (i32, i8*, ...) @fprintf(i32 %142, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str, i64 0, i64 0))
%144 = load i32, i32* @stderr
%145 = load i8*, i8** %4
%146 = load i8, i8* %145
%147 = sext i8 %146 to i32
%148 = call i32 (i32, i8*, ...) @fprintf(i32 %144, i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.3, i64 0, i64 0), i8* %1, i32 %147, i32 %2)
br label %149
149: ; preds = %104, %141, %136, %129, %99, %94, %86, %39, %34
%150 = phi i32 [ -1, %39 ], [ %38, %34 ], [ -1, %86 ], [ %98, %94 ], [ %103, %99 ], [ -1, %141 ], [ %140, %136 ], [ %135, %129 ], [ 0, %104 ]
ret i32 %150
}