#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 */
scalar_t__ ERANGE;
int /*<<< orphan*/ assert(int);
scalar_t__ errno;
int strtol(char *, char **, int);
int strtoul(char *, char **, int /*<<< orphan*/);
int main() {
  char *c, *s;
  assert(strtol(s = "123", &c, 0) == 123 && c == s + 3);
  assert(strtol(s = "+123", &c, 0) == 123 && c == s + 4);
  assert(strtol(s = "  123", &c, 0) == 123 && c == s + 5);
  assert(strtol(s = " 123 ", &c, 0) == 123 && c == s + 4);
  assert(strtol(s = "   -17", &c, 0) == -17 && c == s + 6);
  assert(strtol(s = "0123", &c, 0) == 0123 && c == s + 4);
  assert(strtol(s = "0123a", &c, 0) == 0123 && c == s + 4);
  assert(strtol(s = "01239", &c, 0) == 0123 && c == s + 4);
  assert(strtol(s = "0x123", &c, 0) == 0x123 && c == s + 5);
  assert(strtol(s = "-0x123", &c, 0) == -0x123 && c == s + 6);
  assert(strtol(s = "0x0xc", &c, 0) == 0 && c == s + 3);
  assert(strtol(s = " +0x123fg", &c, 0) == 0x123f && c == s + 8);
  assert(strtol(s = "123", &c, 16) == 0x123 && c == s + 3);
  assert(strtol(s = "0x123", &c, 16) == 0x123 && c == s + 5);
  assert(strtol(s = "123", &c, 8) == 0123 && c == s + 3);
  assert(strtol(s = "0123", &c, 8) == 0123 && c == s + 4);
  assert(strtol(s = "0123", &c, 10) == 123 && c == s + 4);
  assert(strtol(s = "0x123", &c, 10) == 0 && c == s + 1);
  assert(strtol(s = "abcd", &c, 16) == 0xabcd && c == s + 4);
  assert(strtol(s = "AbCd", &c, 16) == 0xabcd && c == s + 4);
  assert(strtol(s = "0xABCD", &c, 16) == 0xabcd && c == s + 6);
  assert(strtol(s = "0Xabcd", &c, 16) == 0xabcd && c == s + 6);
  assert(strtol(s = "0xyz", &c, 35) == 33 * 35 + 34 && c == s + 3);
  assert(strtol(s = "yz!", &c, 36) == 34 * 36 + 35 && c == s + 2);
  assert(strtol(s = "-yz", &c, 36) == -(34 * 36 + 35) && c == s + 3);
  assert(strtol(s = "GhI4", &c, 20) == ((16 * 20 + 17) * 20 + 18) * 20 + 4 &&
         c == s + 4);
  assert(strtol(s = "9223372036854775807", &c, 0) == 9223372036854775807 &&
         c == s + 19 && errno == 0);
  assert(strtol(s = "9223372036854775808", &c, 0) == 9223372036854775807 &&
         c == s + 19 && errno == ERANGE);
  assert(strtol(s = "922337203685477580777", &c, 0) == 9223372036854775807 &&
         c == s + 21 && errno == ERANGE);
  assert(strtol(s = "9223372036854775810", &c, 0) == 9223372036854775807 &&
         c == s + 19 && errno == ERANGE);
  errno = 0;
  assert(strtol(s = "-2147483648", &c, 0) == -2147483648 && c == s + 11 &&
         errno == 0);
  assert(strtol(s = "-9223372036854775808", &c, 0) == 0x8000000000000000 &&
         c == s + 20 && errno == 0);
  assert(strtol(s = "-9223372036854775809", &c, 0) == 0x8000000000000000 &&
         c == s + 20 && errno == ERANGE);
  assert(strtol(s = "0x112233445566778899z", &c, 0) == 9223372036854775807 &&
         c == s + 20 && errno == ERANGE);
  assert(strtol(s = "0xFFFFFFFFFFFF00FF", &c, 0) == 9223372036854775807 &&
         c == s + 18 && errno == ERANGE);
  assert(strtoul(s = "  0", &c, 0) == 0 && c == s + 3);
  errno = 0;
  assert(strtoul(s = "0xffffffffg", &c, 0) == 0xffffffff && c == s + 10 &&
         errno == 0);
  assert(strtoul(s = "0xffffffffffffffffg", &c, 0) == 0xffffffffffffffff &&
         c == s + 18 && errno == 0);
  assert(strtoul(s = "-0xfedcba987654321", &c, 0) == 0xf0123456789abcdf &&
         c == s + 18 && errno == 0);
  assert(strtoul(s = "0xf1f2f3f4f5f6f7f8f9", &c, 0) == 0xffffffffffffffff &&
         c == s + 20 && errno == ERANGE);
  assert(strtoul(s = "-0x123456789abcdef01", &c, 0) == 0xffffffffffffffff &&
         c == s + 20 && errno == ERANGE);
  assert(strtoul(s = "0x,", &c, 0) == 0 && c == s + 1);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
movl   $0x0,-0x4(%rbp)
lea    0x1ec1(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x1eb6(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x7b,%ecx
mov    %al,-0x19(%rbp)
jne    1181 <main+0x51>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x3,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x19(%rbp)
mov    -0x19(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1e6b(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x1e60(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x7b,%ecx
mov    %al,-0x1a(%rbp)
jne    11d0 <main+0xa0>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x4,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x1a(%rbp)
mov    -0x1a(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1e21(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x1e16(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x7b,%ecx
mov    %al,-0x1b(%rbp)
jne    121f <main+0xef>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x5,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x1b(%rbp)
mov    -0x1b(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1dd8(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x1dcd(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x7b,%ecx
mov    %al,-0x1c(%rbp)
jne    126e <main+0x13e>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x4,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x1c(%rbp)
mov    -0x1c(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1d8f(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x1d84(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0xffffffef,%ecx
mov    %al,-0x1d(%rbp)
jne    12bd <main+0x18d>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x6,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x1d(%rbp)
mov    -0x1d(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1d47(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x1d3c(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x53,%ecx
mov    %al,-0x1e(%rbp)
jne    130c <main+0x1dc>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x4,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x1e(%rbp)
mov    -0x1e(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1cfd(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x1cf2(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x53,%ecx
mov    %al,-0x1f(%rbp)
jne    135b <main+0x22b>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x4,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x1f(%rbp)
mov    -0x1f(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1cb4(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x1ca9(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x53,%ecx
mov    %al,-0x20(%rbp)
jne    13aa <main+0x27a>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x4,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x20(%rbp)
mov    -0x20(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1c6c(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x1c61(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x123,%ecx
mov    %al,-0x21(%rbp)
jne    13fc <main+0x2cc>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x5,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x21(%rbp)
mov    -0x21(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1c19(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x1c0e(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0xfffffedd,%ecx
mov    %al,-0x22(%rbp)
jne    144e <main+0x31e>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x6,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x22(%rbp)
mov    -0x22(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1bce(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x1bc3(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x23(%rbp)
jne    149d <main+0x36d>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x3,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x23(%rbp)
mov    -0x23(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1b85(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x1b7a(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x123f,%ecx
mov    %al,-0x24(%rbp)
jne    14ef <main+0x3bf>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x8,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x24(%rbp)
mov    -0x24(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1b04(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x1af9(%rip),%rdi
lea    -0x10(%rbp),%rsi
mov    $0x10,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x123,%ecx
mov    %al,-0x25(%rbp)
jne    1544 <main+0x414>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x3,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x25(%rbp)
mov    -0x25(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1ad2(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x1ac7(%rip),%rdi
lea    -0x10(%rbp),%rsi
mov    $0x10,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x123,%ecx
mov    %al,-0x26(%rbp)
jne    1599 <main+0x469>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x5,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x26(%rbp)
mov    -0x26(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1a5a(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x1a4f(%rip),%rdi
lea    -0x10(%rbp),%rsi
mov    $0x8,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x53,%ecx
mov    %al,-0x27(%rbp)
jne    15eb <main+0x4bb>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x3,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x27(%rbp)
mov    -0x27(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1a19(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x1a0e(%rip),%rdi
lea    -0x10(%rbp),%rsi
mov    $0x8,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x53,%ecx
mov    %al,-0x28(%rbp)
jne    163d <main+0x50d>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x4,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x28(%rbp)
mov    -0x28(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x19c7(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x19bc(%rip),%rdi
lea    -0x10(%rbp),%rsi
mov    $0xa,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x7b,%ecx
mov    %al,-0x29(%rbp)
jne    168f <main+0x55f>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x4,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x29(%rbp)
mov    -0x29(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1987(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x197c(%rip),%rdi
lea    -0x10(%rbp),%rsi
mov    $0xa,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x2a(%rbp)
jne    16e1 <main+0x5b1>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x1,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x2a(%rbp)
mov    -0x2a(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1959(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x194e(%rip),%rdi
lea    -0x10(%rbp),%rsi
mov    $0x10,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0xabcd,%ecx
mov    %al,-0x2b(%rbp)
jne    1736 <main+0x606>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x4,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x2b(%rbp)
mov    -0x2b(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x18f6(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x18eb(%rip),%rdi
lea    -0x10(%rbp),%rsi
mov    $0x10,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0xabcd,%ecx
mov    %al,-0x2c(%rbp)
jne    178b <main+0x65b>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x4,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x2c(%rbp)
mov    -0x2c(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x18a6(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x189b(%rip),%rdi
lea    -0x10(%rbp),%rsi
mov    $0x10,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0xabcd,%ecx
mov    %al,-0x2d(%rbp)
jne    17e0 <main+0x6b0>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x6,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x2d(%rbp)
mov    -0x2d(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1858(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x184d(%rip),%rdi
lea    -0x10(%rbp),%rsi
mov    $0x10,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0xabcd,%ecx
mov    %al,-0x2e(%rbp)
jne    1835 <main+0x705>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x6,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x2e(%rbp)
mov    -0x2e(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x180a(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x17ff(%rip),%rdi
lea    -0x10(%rbp),%rsi
mov    $0x23,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x4a5,%ecx
mov    %al,-0x2f(%rbp)
jne    188a <main+0x75a>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x3,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x2f(%rbp)
mov    -0x2f(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x17ba(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x17af(%rip),%rdi
lea    -0x10(%rbp),%rsi
mov    $0x24,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x4eb,%ecx
mov    %al,-0x30(%rbp)
jne    18df <main+0x7af>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x2,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x30(%rbp)
mov    -0x30(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1769(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x175e(%rip),%rdi
lea    -0x10(%rbp),%rsi
mov    $0x24,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0xfffffb15,%ecx
mov    %al,-0x31(%rbp)
jne    1934 <main+0x804>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x3,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x31(%rbp)
mov    -0x31(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1718(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x170d(%rip),%rdi
lea    -0x10(%rbp),%rsi
mov    $0x14,%edx
call   1040 <strtol@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x20ffc,%ecx
mov    %al,-0x32(%rbp)
jne    1989 <main+0x859>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x4,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x32(%rbp)
mov    -0x32(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x16c8(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x16bd(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
movslq %eax,%rcx
xor    %eax,%eax
movabs $0x7fffffffffffffff,%rdx
ff ff 7f
cmp    %rdx,%rcx
mov    %al,-0x33(%rbp)
jne    19f9 <main+0x8c9>
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%rdx
add    $0x13,%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x33(%rbp)
jne    19f9 <main+0x8c9>
mov    0x35e9(%rip),%rax
cmpq   $0x0,(%rax)
sete   %al
mov    %al,-0x33(%rbp)
mov    -0x33(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x16a3(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x1698(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
movslq %eax,%rcx
xor    %eax,%eax
movabs $0x7fffffffffffffff,%rdx
ff ff 7f
cmp    %rdx,%rcx
mov    %al,-0x34(%rbp)
jne    1a72 <main+0x942>
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%rdx
add    $0x13,%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x34(%rbp)
jne    1a72 <main+0x942>
mov    0x3579(%rip),%rax
mov    (%rax),%rax
mov    0x357f(%rip),%rcx
cmp    (%rcx),%rax
sete   %al
mov    %al,-0x34(%rbp)
mov    -0x34(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x15f3(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x15e8(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
movslq %eax,%rcx
xor    %eax,%eax
movabs $0x7fffffffffffffff,%rdx
ff ff 7f
cmp    %rdx,%rcx
mov    %al,-0x35(%rbp)
jne    1aeb <main+0x9bb>
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%rdx
add    $0x15,%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x35(%rbp)
jne    1aeb <main+0x9bb>
mov    0x3500(%rip),%rax
mov    (%rax),%rax
mov    0x3506(%rip),%rcx
cmp    (%rcx),%rax
sete   %al
mov    %al,-0x35(%rbp)
mov    -0x35(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1590(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x1585(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
movslq %eax,%rcx
xor    %eax,%eax
movabs $0x7fffffffffffffff,%rdx
ff ff 7f
cmp    %rdx,%rcx
mov    %al,-0x36(%rbp)
jne    1b64 <main+0xa34>
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%rdx
add    $0x13,%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x36(%rbp)
jne    1b64 <main+0xa34>
mov    0x3487(%rip),%rax
mov    (%rax),%rax
mov    0x348d(%rip),%rcx
cmp    (%rcx),%rax
sete   %al
mov    %al,-0x36(%rbp)
mov    -0x36(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    0x3460(%rip),%rax
movq   $0x0,(%rax)
lea    0x151d(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x1512(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
movslq %eax,%rcx
xor    %eax,%eax
cmp    $0xffffffff80000000,%rcx
mov    %al,-0x37(%rbp)
jne    1bdc <main+0xaac>
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%rdx
add    $0xb,%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x37(%rbp)
jne    1bdc <main+0xaac>
mov    0x3406(%rip),%rax
cmpq   $0x0,(%rax)
sete   %al
mov    %al,-0x37(%rbp)
mov    -0x37(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x14bf(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x14b4(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
movslq %eax,%rcx
xor    %eax,%eax
movabs $0x8000000000000000,%rdx
cmp    %rdx,%rcx
mov    %al,-0x38(%rbp)
jne    1c4c <main+0xb1c>
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%rdx
add    $0x14,%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x38(%rbp)
jne    1c4c <main+0xb1c>
mov    0x3396(%rip),%rax
cmpq   $0x0,(%rax)
sete   %al
mov    %al,-0x38(%rbp)
mov    -0x38(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1464(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x1459(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
movslq %eax,%rcx
xor    %eax,%eax
movabs $0x8000000000000000,%rdx
cmp    %rdx,%rcx
mov    %al,-0x39(%rbp)
jne    1cc5 <main+0xb95>
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%rdx
add    $0x14,%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x39(%rbp)
jne    1cc5 <main+0xb95>
mov    0x3326(%rip),%rax
mov    (%rax),%rax
mov    0x332c(%rip),%rcx
cmp    (%rcx),%rax
sete   %al
mov    %al,-0x39(%rbp)
mov    -0x39(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1400(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x13f5(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
movslq %eax,%rcx
xor    %eax,%eax
movabs $0x7fffffffffffffff,%rdx
ff ff 7f
cmp    %rdx,%rcx
mov    %al,-0x3a(%rbp)
jne    1d3e <main+0xc0e>
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%rdx
add    $0x14,%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x3a(%rbp)
jne    1d3e <main+0xc0e>
mov    0x32ad(%rip),%rax
mov    (%rax),%rax
mov    0x32b3(%rip),%rcx
cmp    (%rcx),%rax
sete   %al
mov    %al,-0x3a(%rbp)
mov    -0x3a(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x139d(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x1392(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
movslq %eax,%rcx
xor    %eax,%eax
movabs $0x7fffffffffffffff,%rdx
ff ff 7f
cmp    %rdx,%rcx
mov    %al,-0x3b(%rbp)
jne    1db7 <main+0xc87>
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%rdx
add    $0x12,%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x3b(%rbp)
jne    1db7 <main+0xc87>
mov    0x3234(%rip),%rax
mov    (%rax),%rax
mov    0x323a(%rip),%rcx
cmp    (%rcx),%rax
sete   %al
mov    %al,-0x3b(%rbp)
mov    -0x3b(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1337(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x132c(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1050 <strtoul@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x3c(%rbp)
jne    1e06 <main+0xcd6>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x3,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x3c(%rbp)
mov    -0x3c(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    0x31be(%rip),%rax
movq   $0x0,(%rax)
lea    0x12de(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x12d3(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1050 <strtoul@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0xffffffff,%ecx
mov    %al,-0x3d(%rbp)
jne    1e79 <main+0xd49>
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%rdx
add    $0xa,%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x3d(%rbp)
jne    1e79 <main+0xd49>
mov    0x3169(%rip),%rax
cmpq   $0x0,(%rax)
sete   %al
mov    %al,-0x3d(%rbp)
mov    -0x3d(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1285(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x127a(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1050 <strtoul@plt>
movslq %eax,%rcx
xor    %eax,%eax
cmp    $0xffffffffffffffff,%rcx
mov    %al,-0x3e(%rbp)
jne    1ee0 <main+0xdb0>
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%rdx
add    $0x12,%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x3e(%rbp)
jne    1ee0 <main+0xdb0>
mov    0x3102(%rip),%rax
cmpq   $0x0,(%rax)
sete   %al
mov    %al,-0x3e(%rbp)
mov    -0x3e(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x1232(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x1227(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1050 <strtoul@plt>
movslq %eax,%rcx
xor    %eax,%eax
movabs $0xf0123456789abcdf,%rdx
34 12 f0
cmp    %rdx,%rcx
mov    %al,-0x3f(%rbp)
jne    1f50 <main+0xe20>
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%rdx
add    $0x12,%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x3f(%rbp)
jne    1f50 <main+0xe20>
mov    0x3092(%rip),%rax
cmpq   $0x0,(%rax)
sete   %al
mov    %al,-0x3f(%rbp)
mov    -0x3f(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x11d5(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x11ca(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1050 <strtoul@plt>
movslq %eax,%rcx
xor    %eax,%eax
cmp    $0xffffffffffffffff,%rcx
mov    %al,-0x40(%rbp)
jne    1fc0 <main+0xe90>
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%rdx
add    $0x14,%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x40(%rbp)
jne    1fc0 <main+0xe90>
mov    0x302b(%rip),%rax
mov    (%rax),%rax
mov    0x3031(%rip),%rcx
cmp    (%rcx),%rax
sete   %al
mov    %al,-0x40(%rbp)
mov    -0x40(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x117a(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x116f(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1050 <strtoul@plt>
movslq %eax,%rcx
xor    %eax,%eax
cmp    $0xffffffffffffffff,%rcx
mov    %al,-0x41(%rbp)
jne    2030 <main+0xf00>
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%rdx
add    $0x14,%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x41(%rbp)
jne    2030 <main+0xf00>
mov    0x2fbb(%rip),%rax
mov    (%rax),%rax
mov    0x2fc1(%rip),%rcx
cmp    (%rcx),%rax
sete   %al
mov    %al,-0x41(%rbp)
mov    -0x41(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x111f(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0x1114(%rip),%rdi
lea    -0x10(%rbp),%rsi
xor    %edx,%edx
call   1050 <strtoul@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x42(%rbp)
jne    207f <main+0xf4f>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x1,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x42(%rbp)
mov    -0x42(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
xor    %eax,%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
lea    0xec5(%rip),%rbp
mov    %rsp,%rbx
mov    %rbp,%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
cmp    $0x7b,%eax
sete   %al
lea    0xeab(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
lea    0xe89(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
cmp    $0x7b,%eax
sete   %al
lea    0xe76(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
lea    0xe5f(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
cmp    $0x7b,%eax
sete   %al
lea    0xe4d(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
lea    0xe36(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
cmp    $0x7b,%eax
sete   %al
lea    0xe23(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
lea    0xe0d(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
cmp    $0xffffffef,%eax
sete   %al
lea    0xdfc(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
lea    0xde5(%rip),%r15
mov    %r15,%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
cmp    $0x53,%eax
sete   %al
lea    0xdcf(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
lea    0xdb8(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
cmp    $0x53,%eax
sete   %al
lea    0xda5(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
lea    0xd8f(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
cmp    $0x53,%eax
sete   %al
lea    0xd7c(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
lea    0xd67(%rip),%r12
mov    %r12,%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
cmp    $0x123,%eax
sete   %al
lea    0xd50(%rip),%r13
cmp    %r13,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
lea    0xd32(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
cmp    $0xfffffedd,%eax
sete   %al
lea    0xd1f(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
lea    0xd08(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
test   %eax,%eax
sete   %al
lea    0xcf5(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
lea    0xce0(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
cmp    $0x123f,%eax
sete   %al
lea    0xccf(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    $0x10,%edx
call   1040 <strtol@plt>
cmp    $0x123,%eax
sete   %al
lea    0xc6b(%rip),%r14
cmp    %r14,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
mov    %r12,%rdi
mov    %rbx,%rsi
mov    $0x10,%edx
call   1040 <strtol@plt>
cmp    $0x123,%eax
sete   %al
cmp    %r13,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    $0x8,%edx
call   1040 <strtol@plt>
cmp    $0x53,%eax
sete   %al
cmp    %r14,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
mov    $0x8,%edx
call   1040 <strtol@plt>
cmp    $0x53,%eax
sete   %al
lea    0xbff(%rip),%rbp
cmp    %rbp,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
mov    $0xa,%edx
call   1040 <strtol@plt>
cmp    $0x7b,%eax
sete   %al
cmp    %rbp,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
mov    %r12,%rdi
mov    %rbx,%rsi
mov    $0xa,%edx
call   1040 <strtol@plt>
test   %eax,%eax
sete   %al
lea    0xbba(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
lea    0xbc5(%rip),%rdi
mov    %rbx,%rsi
mov    $0x10,%edx
call   1040 <strtol@plt>
cmp    $0xabcd,%eax
sete   %al
lea    0xbad(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
lea    0xb83(%rip),%rdi
mov    %rbx,%rsi
mov    $0x10,%edx
call   1040 <strtol@plt>
cmp    $0xabcd,%eax
sete   %al
lea    0xb6b(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
lea    0xb54(%rip),%rdi
mov    %rbx,%rsi
mov    $0x10,%edx
call   1040 <strtol@plt>
cmp    $0xabcd,%eax
sete   %al
lea    0xb3e(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
lea    0xb27(%rip),%rdi
mov    %rbx,%rsi
mov    $0x10,%edx
call   1040 <strtol@plt>
cmp    $0xabcd,%eax
sete   %al
lea    0xb11(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
lea    0xafa(%rip),%rdi
mov    %rbx,%rsi
mov    $0x23,%edx
call   1040 <strtol@plt>
cmp    $0x4a5,%eax
sete   %al
lea    0xae1(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
lea    0xacb(%rip),%rdi
mov    %rbx,%rsi
mov    $0x24,%edx
call   1040 <strtol@plt>
cmp    $0x4eb,%eax
sete   %al
lea    0xab1(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
lea    0xa9b(%rip),%rdi
mov    %rbx,%rsi
mov    $0x24,%edx
call   1040 <strtol@plt>
cmp    $0xfffffb15,%eax
sete   %al
lea    0xa82(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
lea    0xa6b(%rip),%rdi
mov    %rbx,%rsi
mov    $0x14,%edx
call   1040 <strtol@plt>
cmp    $0x20ffc,%eax
sete   %al
lea    0xa53(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
lea    0xa3c(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
xor    %edi,%edi
call   1030 <assert@plt>
lea    0xa6f(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
xor    %edi,%edi
call   1030 <assert@plt>
lea    0xa20(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
xor    %edi,%edi
call   1030 <assert@plt>
lea    0xa1e(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
xor    %edi,%edi
call   1030 <assert@plt>
mov    0x294f(%rip),%r14
movq   $0x0,(%r14)
lea    0xa0c(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
cmp    $0x80000000,%eax
sete   %al
lea    0x9fe(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
cmpq   $0x0,(%r14)
sete   %al
and    %cl,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x9de(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
xor    %edi,%edi
call   1030 <assert@plt>
lea    0x9db(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
xor    %edi,%edi
call   1030 <assert@plt>
lea    0x9d8(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
xor    %edi,%edi
call   1030 <assert@plt>
lea    0x9d6(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1040 <strtol@plt>
xor    %edi,%edi
call   1030 <assert@plt>
lea    0x9d1(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1050 <strtoul@plt>
test   %eax,%eax
sete   %al
lea    0x9be(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
movq   $0x0,(%r14)
lea    0x9a0(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1050 <strtoul@plt>
cmp    $0xffffffff,%eax
sete   %al
lea    0x993(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
cmpq   $0x0,(%r14)
sete   %al
and    %cl,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x974(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1050 <strtoul@plt>
cmp    $0xffffffff,%eax
sete   %al
lea    0x96f(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
cmpq   $0x0,(%r14)
sete   %al
and    %cl,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x950(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1050 <strtoul@plt>
xor    %edi,%edi
call   1030 <assert@plt>
lea    0x94b(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1050 <strtoul@plt>
cmp    $0xffffffff,%eax
sete   %al
lea    0x948(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
mov    (%r14),%rax
mov    0x27d0(%rip),%rbp
cmp    0x0(%rbp),%rax
sete   %al
and    %cl,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x91e(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1050 <strtoul@plt>
cmp    $0xffffffff,%eax
sete   %al
lea    0x91b(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
mov    (%r14),%rax
cmp    0x0(%rbp),%rax
sete   %al
and    %cl,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    0x8f8(%rip),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
call   1050 <strtoul@plt>
test   %eax,%eax
sete   %al
lea    0x8e3(%rip),%rcx
cmp    %rcx,(%rsp)
sete   %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [4 x i8] c"123\00"
@.str.1 = [5 x i8] c"+123\00"
@.str.2 = [6 x i8] c" 123\00"
@.str.3 = [6 x i8] c" 123 \00"
@.str.4 = [7 x i8] c" -17\00"
@.str.5 = [5 x i8] c"0123\00"
@.str.6 = [6 x i8] c"0123a\00"
@.str.7 = [6 x i8] c"01239\00"
@.str.8 = [6 x i8] c"0x123\00"
@.str.9 = [7 x i8] c"-0x123\00"
@.str.10 = [6 x i8] c"0x0xc\00"
@.str.11 = [10 x i8] c" +0x123fg\00"
@.str.12 = [5 x i8] c"abcd\00"
@.str.13 = [5 x i8] c"AbCd\00"
@.str.14 = [7 x i8] c"0xABCD\00"
@.str.15 = [7 x i8] c"0Xabcd\00"
@.str.16 = [5 x i8] c"0xyz\00"
@.str.17 = [4 x i8] c"yz!\00"
@.str.18 = [4 x i8] c"-yz\00"
@.str.19 = [5 x i8] c"GhI4\00"
@.str.20 = [20 x i8] c"9223372036854775807\00"
@errno = global i64 0
@.str.21 = [20 x i8] c"9223372036854775808\00"
@ERANGE = global i64 0
@.str.22 = [22 x i8] c"922337203685477580777\00"
@.str.23 = [20 x i8] c"9223372036854775810\00"
@.str.24 = [12 x i8] c"-2147483648\00"
@.str.25 = [21 x i8] c"-9223372036854775808\00"
@.str.26 = [21 x i8] c"-9223372036854775809\00"
@.str.27 = [22 x i8] c"0x112233445566778899z\00"
@.str.28 = [19 x i8] c"0xFFFFFFFFFFFF00FF\00"
@.str.29 = [4 x i8] c" 0\00"
@.str.30 = [12 x i8] c"0xffffffffg\00"
@.str.31 = [20 x i8] c"0xffffffffffffffffg\00"
@.str.32 = [19 x i8] c"-0xfedcba987654321\00"
@.str.33 = [21 x i8] c"0xf1f2f3f4f5f6f7f8f9\00"
@.str.34 = [21 x i8] c"-0x123456789abcdef01\00"
@.str.35 = [4 x i8] c"0x,\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i8*
%3 = alloca i8*
store i32 0, i32* %1
store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8** %3
%4 = call i32 @strtol(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8** %2, i32 0)
%5 = icmp eq i32 %4, 123
br i1 %5, label %6, label %11
6: ; preds = %0
%7 = load i8*, i8** %2
%8 = load i8*, i8** %3
%9 = getelementptr inbounds i8, i8* %8, i64 3
%10 = icmp eq i8* %7, %9
br label %11
11: ; preds = %6, %0
%12 = phi i1 [ false, %0 ], [ %10, %6 ]
%13 = zext i1 %12 to i32
%14 = call i32 @assert(i32 %13)
store i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8** %3
%15 = call i32 @strtol(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8** %2, i32 0)
%16 = icmp eq i32 %15, 123
br i1 %16, label %17, label %22
17: ; preds = %11
%18 = load i8*, i8** %2
%19 = load i8*, i8** %3
%20 = getelementptr inbounds i8, i8* %19, i64 4
%21 = icmp eq i8* %18, %20
br label %22
22: ; preds = %17, %11
%23 = phi i1 [ false, %11 ], [ %21, %17 ]
%24 = zext i1 %23 to i32
%25 = call i32 @assert(i32 %24)
store i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), i8** %3
%26 = call i32 @strtol(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), i8** %2, i32 0)
%27 = icmp eq i32 %26, 123
br i1 %27, label %28, label %33
28: ; preds = %22
%29 = load i8*, i8** %2
%30 = load i8*, i8** %3
%31 = getelementptr inbounds i8, i8* %30, i64 5
%32 = icmp eq i8* %29, %31
br label %33
33: ; preds = %28, %22
%34 = phi i1 [ false, %22 ], [ %32, %28 ]
%35 = zext i1 %34 to i32
%36 = call i32 @assert(i32 %35)
store i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8** %3
%37 = call i32 @strtol(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8** %2, i32 0)
%38 = icmp eq i32 %37, 123
br i1 %38, label %39, label %44
39: ; preds = %33
%40 = load i8*, i8** %2
%41 = load i8*, i8** %3
%42 = getelementptr inbounds i8, i8* %41, i64 4
%43 = icmp eq i8* %40, %42
br label %44
44: ; preds = %39, %33
%45 = phi i1 [ false, %33 ], [ %43, %39 ]
%46 = zext i1 %45 to i32
%47 = call i32 @assert(i32 %46)
store i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.4, i64 0, i64 0), i8** %3
%48 = call i32 @strtol(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.4, i64 0, i64 0), i8** %2, i32 0)
%49 = icmp eq i32 %48, -17
br i1 %49, label %50, label %55
50: ; preds = %44
%51 = load i8*, i8** %2
%52 = load i8*, i8** %3
%53 = getelementptr inbounds i8, i8* %52, i64 6
%54 = icmp eq i8* %51, %53
br label %55
55: ; preds = %50, %44
%56 = phi i1 [ false, %44 ], [ %54, %50 ]
%57 = zext i1 %56 to i32
%58 = call i32 @assert(i32 %57)
store i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0), i8** %3
%59 = call i32 @strtol(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0), i8** %2, i32 0)
%60 = icmp eq i32 %59, 83
br i1 %60, label %61, label %66
61: ; preds = %55
%62 = load i8*, i8** %2
%63 = load i8*, i8** %3
%64 = getelementptr inbounds i8, i8* %63, i64 4
%65 = icmp eq i8* %62, %64
br label %66
66: ; preds = %61, %55
%67 = phi i1 [ false, %55 ], [ %65, %61 ]
%68 = zext i1 %67 to i32
%69 = call i32 @assert(i32 %68)
store i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i8** %3
%70 = call i32 @strtol(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i8** %2, i32 0)
%71 = icmp eq i32 %70, 83
br i1 %71, label %72, label %77
72: ; preds = %66
%73 = load i8*, i8** %2
%74 = load i8*, i8** %3
%75 = getelementptr inbounds i8, i8* %74, i64 4
%76 = icmp eq i8* %73, %75
br label %77
77: ; preds = %72, %66
%78 = phi i1 [ false, %66 ], [ %76, %72 ]
%79 = zext i1 %78 to i32
%80 = call i32 @assert(i32 %79)
store i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 0), i8** %3
%81 = call i32 @strtol(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 0), i8** %2, i32 0)
%82 = icmp eq i32 %81, 83
br i1 %82, label %83, label %88
83: ; preds = %77
%84 = load i8*, i8** %2
%85 = load i8*, i8** %3
%86 = getelementptr inbounds i8, i8* %85, i64 4
%87 = icmp eq i8* %84, %86
br label %88
88: ; preds = %83, %77
%89 = phi i1 [ false, %77 ], [ %87, %83 ]
%90 = zext i1 %89 to i32
%91 = call i32 @assert(i32 %90)
store i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 0), i8** %3
%92 = call i32 @strtol(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 0), i8** %2, i32 0)
%93 = icmp eq i32 %92, 291
br i1 %93, label %94, label %99
94: ; preds = %88
%95 = load i8*, i8** %2
%96 = load i8*, i8** %3
%97 = getelementptr inbounds i8, i8* %96, i64 5
%98 = icmp eq i8* %95, %97
br label %99
99: ; preds = %94, %88
%100 = phi i1 [ false, %88 ], [ %98, %94 ]
%101 = zext i1 %100 to i32
%102 = call i32 @assert(i32 %101)
store i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.9, i64 0, i64 0), i8** %3
%103 = call i32 @strtol(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.9, i64 0, i64 0), i8** %2, i32 0)
%104 = icmp eq i32 %103, -291
br i1 %104, label %105, label %110
105: ; preds = %99
%106 = load i8*, i8** %2
%107 = load i8*, i8** %3
%108 = getelementptr inbounds i8, i8* %107, i64 6
%109 = icmp eq i8* %106, %108
br label %110
110: ; preds = %105, %99
%111 = phi i1 [ false, %99 ], [ %109, %105 ]
%112 = zext i1 %111 to i32
%113 = call i32 @assert(i32 %112)
store i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i8** %3
%114 = call i32 @strtol(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i8** %2, i32 0)
%115 = icmp eq i32 %114, 0
br i1 %115, label %116, label %121
116: ; preds = %110
%117 = load i8*, i8** %2
%118 = load i8*, i8** %3
%119 = getelementptr inbounds i8, i8* %118, i64 3
%120 = icmp eq i8* %117, %119
br label %121
121: ; preds = %116, %110
%122 = phi i1 [ false, %110 ], [ %120, %116 ]
%123 = zext i1 %122 to i32
%124 = call i32 @assert(i32 %123)
store i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.11, i64 0, i64 0), i8** %3
%125 = call i32 @strtol(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.11, i64 0, i64 0), i8** %2, i32 0)
%126 = icmp eq i32 %125, 4671
br i1 %126, label %127, label %132
127: ; preds = %121
%128 = load i8*, i8** %2
%129 = load i8*, i8** %3
%130 = getelementptr inbounds i8, i8* %129, i64 8
%131 = icmp eq i8* %128, %130
br label %132
132: ; preds = %127, %121
%133 = phi i1 [ false, %121 ], [ %131, %127 ]
%134 = zext i1 %133 to i32
%135 = call i32 @assert(i32 %134)
store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8** %3
%136 = call i32 @strtol(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8** %2, i32 16)
%137 = icmp eq i32 %136, 291
br i1 %137, label %138, label %143
138: ; preds = %132
%139 = load i8*, i8** %2
%140 = load i8*, i8** %3
%141 = getelementptr inbounds i8, i8* %140, i64 3
%142 = icmp eq i8* %139, %141
br label %143
143: ; preds = %138, %132
%144 = phi i1 [ false, %132 ], [ %142, %138 ]
%145 = zext i1 %144 to i32
%146 = call i32 @assert(i32 %145)
store i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 0), i8** %3
%147 = call i32 @strtol(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 0), i8** %2, i32 16)
%148 = icmp eq i32 %147, 291
br i1 %148, label %149, label %154
149: ; preds = %143
%150 = load i8*, i8** %2
%151 = load i8*, i8** %3
%152 = getelementptr inbounds i8, i8* %151, i64 5
%153 = icmp eq i8* %150, %152
br label %154
154: ; preds = %149, %143
%155 = phi i1 [ false, %143 ], [ %153, %149 ]
%156 = zext i1 %155 to i32
%157 = call i32 @assert(i32 %156)
store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8** %3
%158 = call i32 @strtol(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8** %2, i32 8)
%159 = icmp eq i32 %158, 83
br i1 %159, label %160, label %165
160: ; preds = %154
%161 = load i8*, i8** %2
%162 = load i8*, i8** %3
%163 = getelementptr inbounds i8, i8* %162, i64 3
%164 = icmp eq i8* %161, %163
br label %165
165: ; preds = %160, %154
%166 = phi i1 [ false, %154 ], [ %164, %160 ]
%167 = zext i1 %166 to i32
%168 = call i32 @assert(i32 %167)
store i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0), i8** %3
%169 = call i32 @strtol(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0), i8** %2, i32 8)
%170 = icmp eq i32 %169, 83
br i1 %170, label %171, label %176
171: ; preds = %165
%172 = load i8*, i8** %2
%173 = load i8*, i8** %3
%174 = getelementptr inbounds i8, i8* %173, i64 4
%175 = icmp eq i8* %172, %174
br label %176
176: ; preds = %171, %165
%177 = phi i1 [ false, %165 ], [ %175, %171 ]
%178 = zext i1 %177 to i32
%179 = call i32 @assert(i32 %178)
store i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0), i8** %3
%180 = call i32 @strtol(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0), i8** %2, i32 10)
%181 = icmp eq i32 %180, 123
br i1 %181, label %182, label %187
182: ; preds = %176
%183 = load i8*, i8** %2
%184 = load i8*, i8** %3
%185 = getelementptr inbounds i8, i8* %184, i64 4
%186 = icmp eq i8* %183, %185
br label %187
187: ; preds = %182, %176
%188 = phi i1 [ false, %176 ], [ %186, %182 ]
%189 = zext i1 %188 to i32
%190 = call i32 @assert(i32 %189)
store i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 0), i8** %3
%191 = call i32 @strtol(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 0), i8** %2, i32 10)
%192 = icmp eq i32 %191, 0
br i1 %192, label %193, label %198
193: ; preds = %187
%194 = load i8*, i8** %2
%195 = load i8*, i8** %3
%196 = getelementptr inbounds i8, i8* %195, i64 1
%197 = icmp eq i8* %194, %196
br label %198
198: ; preds = %193, %187
%199 = phi i1 [ false, %187 ], [ %197, %193 ]
%200 = zext i1 %199 to i32
%201 = call i32 @assert(i32 %200)
store i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.12, i64 0, i64 0), i8** %3
%202 = call i32 @strtol(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.12, i64 0, i64 0), i8** %2, i32 16)
%203 = icmp eq i32 %202, 43981
br i1 %203, label %204, label %209
204: ; preds = %198
%205 = load i8*, i8** %2
%206 = load i8*, i8** %3
%207 = getelementptr inbounds i8, i8* %206, i64 4
%208 = icmp eq i8* %205, %207
br label %209
209: ; preds = %204, %198
%210 = phi i1 [ false, %198 ], [ %208, %204 ]
%211 = zext i1 %210 to i32
%212 = call i32 @assert(i32 %211)
store i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.13, i64 0, i64 0), i8** %3
%213 = call i32 @strtol(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.13, i64 0, i64 0), i8** %2, i32 16)
%214 = icmp eq i32 %213, 43981
br i1 %214, label %215, label %220
215: ; preds = %209
%216 = load i8*, i8** %2
%217 = load i8*, i8** %3
%218 = getelementptr inbounds i8, i8* %217, i64 4
%219 = icmp eq i8* %216, %218
br label %220
220: ; preds = %215, %209
%221 = phi i1 [ false, %209 ], [ %219, %215 ]
%222 = zext i1 %221 to i32
%223 = call i32 @assert(i32 %222)
store i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.14, i64 0, i64 0), i8** %3
%224 = call i32 @strtol(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.14, i64 0, i64 0), i8** %2, i32 16)
%225 = icmp eq i32 %224, 43981
br i1 %225, label %226, label %231
226: ; preds = %220
%227 = load i8*, i8** %2
%228 = load i8*, i8** %3
%229 = getelementptr inbounds i8, i8* %228, i64 6
%230 = icmp eq i8* %227, %229
br label %231
231: ; preds = %226, %220
%232 = phi i1 [ false, %220 ], [ %230, %226 ]
%233 = zext i1 %232 to i32
%234 = call i32 @assert(i32 %233)
store i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.15, i64 0, i64 0), i8** %3
%235 = call i32 @strtol(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.15, i64 0, i64 0), i8** %2, i32 16)
%236 = icmp eq i32 %235, 43981
br i1 %236, label %237, label %242
237: ; preds = %231
%238 = load i8*, i8** %2
%239 = load i8*, i8** %3
%240 = getelementptr inbounds i8, i8* %239, i64 6
%241 = icmp eq i8* %238, %240
br label %242
242: ; preds = %237, %231
%243 = phi i1 [ false, %231 ], [ %241, %237 ]
%244 = zext i1 %243 to i32
%245 = call i32 @assert(i32 %244)
store i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.16, i64 0, i64 0), i8** %3
%246 = call i32 @strtol(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.16, i64 0, i64 0), i8** %2, i32 35)
%247 = icmp eq i32 %246, 1189
br i1 %247, label %248, label %253
248: ; preds = %242
%249 = load i8*, i8** %2
%250 = load i8*, i8** %3
%251 = getelementptr inbounds i8, i8* %250, i64 3
%252 = icmp eq i8* %249, %251
br label %253
253: ; preds = %248, %242
%254 = phi i1 [ false, %242 ], [ %252, %248 ]
%255 = zext i1 %254 to i32
%256 = call i32 @assert(i32 %255)
store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.17, i64 0, i64 0), i8** %3
%257 = call i32 @strtol(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.17, i64 0, i64 0), i8** %2, i32 36)
%258 = icmp eq i32 %257, 1259
br i1 %258, label %259, label %264
259: ; preds = %253
%260 = load i8*, i8** %2
%261 = load i8*, i8** %3
%262 = getelementptr inbounds i8, i8* %261, i64 2
%263 = icmp eq i8* %260, %262
br label %264
264: ; preds = %259, %253
%265 = phi i1 [ false, %253 ], [ %263, %259 ]
%266 = zext i1 %265 to i32
%267 = call i32 @assert(i32 %266)
store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.18, i64 0, i64 0), i8** %3
%268 = call i32 @strtol(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.18, i64 0, i64 0), i8** %2, i32 36)
%269 = icmp eq i32 %268, -1259
br i1 %269, label %270, label %275
270: ; preds = %264
%271 = load i8*, i8** %2
%272 = load i8*, i8** %3
%273 = getelementptr inbounds i8, i8* %272, i64 3
%274 = icmp eq i8* %271, %273
br label %275
275: ; preds = %270, %264
%276 = phi i1 [ false, %264 ], [ %274, %270 ]
%277 = zext i1 %276 to i32
%278 = call i32 @assert(i32 %277)
store i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.19, i64 0, i64 0), i8** %3
%279 = call i32 @strtol(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.19, i64 0, i64 0), i8** %2, i32 20)
%280 = icmp eq i32 %279, 135164
br i1 %280, label %281, label %286
281: ; preds = %275
%282 = load i8*, i8** %2
%283 = load i8*, i8** %3
%284 = getelementptr inbounds i8, i8* %283, i64 4
%285 = icmp eq i8* %282, %284
br label %286
286: ; preds = %281, %275
%287 = phi i1 [ false, %275 ], [ %285, %281 ]
%288 = zext i1 %287 to i32
%289 = call i32 @assert(i32 %288)
store i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.20, i64 0, i64 0), i8** %3
%290 = call i32 @strtol(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.20, i64 0, i64 0), i8** %2, i32 0)
%291 = sext i32 %290 to i64
%292 = icmp eq i64 %291, 9223372036854775807
br i1 %292, label %293, label %301
293: ; preds = %286
%294 = load i8*, i8** %2
%295 = load i8*, i8** %3
%296 = getelementptr inbounds i8, i8* %295, i64 19
%297 = icmp eq i8* %294, %296
br i1 %297, label %298, label %301
298: ; preds = %293
%299 = load i64, i64* @errno
%300 = icmp eq i64 %299, 0
br label %301
301: ; preds = %298, %293, %286
%302 = phi i1 [ false, %293 ], [ false, %286 ], [ %300, %298 ]
%303 = zext i1 %302 to i32
%304 = call i32 @assert(i32 %303)
store i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.21, i64 0, i64 0), i8** %3
%305 = call i32 @strtol(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.21, i64 0, i64 0), i8** %2, i32 0)
%306 = sext i32 %305 to i64
%307 = icmp eq i64 %306, 9223372036854775807
br i1 %307, label %308, label %317
308: ; preds = %301
%309 = load i8*, i8** %2
%310 = load i8*, i8** %3
%311 = getelementptr inbounds i8, i8* %310, i64 19
%312 = icmp eq i8* %309, %311
br i1 %312, label %313, label %317
313: ; preds = %308
%314 = load i64, i64* @errno
%315 = load i64, i64* @ERANGE
%316 = icmp eq i64 %314, %315
br label %317
317: ; preds = %313, %308, %301
%318 = phi i1 [ false, %308 ], [ false, %301 ], [ %316, %313 ]
%319 = zext i1 %318 to i32
%320 = call i32 @assert(i32 %319)
store i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.22, i64 0, i64 0), i8** %3
%321 = call i32 @strtol(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.22, i64 0, i64 0), i8** %2, i32 0)
%322 = sext i32 %321 to i64
%323 = icmp eq i64 %322, 9223372036854775807
br i1 %323, label %324, label %333
324: ; preds = %317
%325 = load i8*, i8** %2
%326 = load i8*, i8** %3
%327 = getelementptr inbounds i8, i8* %326, i64 21
%328 = icmp eq i8* %325, %327
br i1 %328, label %329, label %333
329: ; preds = %324
%330 = load i64, i64* @errno
%331 = load i64, i64* @ERANGE
%332 = icmp eq i64 %330, %331
br label %333
333: ; preds = %329, %324, %317
%334 = phi i1 [ false, %324 ], [ false, %317 ], [ %332, %329 ]
%335 = zext i1 %334 to i32
%336 = call i32 @assert(i32 %335)
store i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.23, i64 0, i64 0), i8** %3
%337 = call i32 @strtol(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.23, i64 0, i64 0), i8** %2, i32 0)
%338 = sext i32 %337 to i64
%339 = icmp eq i64 %338, 9223372036854775807
br i1 %339, label %340, label %349
340: ; preds = %333
%341 = load i8*, i8** %2
%342 = load i8*, i8** %3
%343 = getelementptr inbounds i8, i8* %342, i64 19
%344 = icmp eq i8* %341, %343
br i1 %344, label %345, label %349
345: ; preds = %340
%346 = load i64, i64* @errno
%347 = load i64, i64* @ERANGE
%348 = icmp eq i64 %346, %347
br label %349
349: ; preds = %345, %340, %333
%350 = phi i1 [ false, %340 ], [ false, %333 ], [ %348, %345 ]
%351 = zext i1 %350 to i32
%352 = call i32 @assert(i32 %351)
store i64 0, i64* @errno
store i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.24, i64 0, i64 0), i8** %3
%353 = call i32 @strtol(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.24, i64 0, i64 0), i8** %2, i32 0)
%354 = sext i32 %353 to i64
%355 = icmp eq i64 %354, -2147483648
br i1 %355, label %356, label %364
356: ; preds = %349
%357 = load i8*, i8** %2
%358 = load i8*, i8** %3
%359 = getelementptr inbounds i8, i8* %358, i64 11
%360 = icmp eq i8* %357, %359
br i1 %360, label %361, label %364
361: ; preds = %356
%362 = load i64, i64* @errno
%363 = icmp eq i64 %362, 0
br label %364
364: ; preds = %361, %356, %349
%365 = phi i1 [ false, %356 ], [ false, %349 ], [ %363, %361 ]
%366 = zext i1 %365 to i32
%367 = call i32 @assert(i32 %366)
store i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.25, i64 0, i64 0), i8** %3
%368 = call i32 @strtol(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.25, i64 0, i64 0), i8** %2, i32 0)
%369 = sext i32 %368 to i64
%370 = icmp eq i64 %369, -9223372036854775808
br i1 %370, label %371, label %379
371: ; preds = %364
%372 = load i8*, i8** %2
%373 = load i8*, i8** %3
%374 = getelementptr inbounds i8, i8* %373, i64 20
%375 = icmp eq i8* %372, %374
br i1 %375, label %376, label %379
376: ; preds = %371
%377 = load i64, i64* @errno
%378 = icmp eq i64 %377, 0
br label %379
379: ; preds = %376, %371, %364
%380 = phi i1 [ false, %371 ], [ false, %364 ], [ %378, %376 ]
%381 = zext i1 %380 to i32
%382 = call i32 @assert(i32 %381)
store i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.26, i64 0, i64 0), i8** %3
%383 = call i32 @strtol(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.26, i64 0, i64 0), i8** %2, i32 0)
%384 = sext i32 %383 to i64
%385 = icmp eq i64 %384, -9223372036854775808
br i1 %385, label %386, label %395
386: ; preds = %379
%387 = load i8*, i8** %2
%388 = load i8*, i8** %3
%389 = getelementptr inbounds i8, i8* %388, i64 20
%390 = icmp eq i8* %387, %389
br i1 %390, label %391, label %395
391: ; preds = %386
%392 = load i64, i64* @errno
%393 = load i64, i64* @ERANGE
%394 = icmp eq i64 %392, %393
br label %395
395: ; preds = %391, %386, %379
%396 = phi i1 [ false, %386 ], [ false, %379 ], [ %394, %391 ]
%397 = zext i1 %396 to i32
%398 = call i32 @assert(i32 %397)
store i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.27, i64 0, i64 0), i8** %3
%399 = call i32 @strtol(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.27, i64 0, i64 0), i8** %2, i32 0)
%400 = sext i32 %399 to i64
%401 = icmp eq i64 %400, 9223372036854775807
br i1 %401, label %402, label %411
402: ; preds = %395
%403 = load i8*, i8** %2
%404 = load i8*, i8** %3
%405 = getelementptr inbounds i8, i8* %404, i64 20
%406 = icmp eq i8* %403, %405
br i1 %406, label %407, label %411
407: ; preds = %402
%408 = load i64, i64* @errno
%409 = load i64, i64* @ERANGE
%410 = icmp eq i64 %408, %409
br label %411
411: ; preds = %407, %402, %395
%412 = phi i1 [ false, %402 ], [ false, %395 ], [ %410, %407 ]
%413 = zext i1 %412 to i32
%414 = call i32 @assert(i32 %413)
store i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.28, i64 0, i64 0), i8** %3
%415 = call i32 @strtol(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.28, i64 0, i64 0), i8** %2, i32 0)
%416 = sext i32 %415 to i64
%417 = icmp eq i64 %416, 9223372036854775807
br i1 %417, label %418, label %427
418: ; preds = %411
%419 = load i8*, i8** %2
%420 = load i8*, i8** %3
%421 = getelementptr inbounds i8, i8* %420, i64 18
%422 = icmp eq i8* %419, %421
br i1 %422, label %423, label %427
423: ; preds = %418
%424 = load i64, i64* @errno
%425 = load i64, i64* @ERANGE
%426 = icmp eq i64 %424, %425
br label %427
427: ; preds = %423, %418, %411
%428 = phi i1 [ false, %418 ], [ false, %411 ], [ %426, %423 ]
%429 = zext i1 %428 to i32
%430 = call i32 @assert(i32 %429)
store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.29, i64 0, i64 0), i8** %3
%431 = call i32 @strtoul(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.29, i64 0, i64 0), i8** %2, i32 0)
%432 = icmp eq i32 %431, 0
br i1 %432, label %433, label %438
433: ; preds = %427
%434 = load i8*, i8** %2
%435 = load i8*, i8** %3
%436 = getelementptr inbounds i8, i8* %435, i64 3
%437 = icmp eq i8* %434, %436
br label %438
438: ; preds = %433, %427
%439 = phi i1 [ false, %427 ], [ %437, %433 ]
%440 = zext i1 %439 to i32
%441 = call i32 @assert(i32 %440)
store i64 0, i64* @errno
store i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.30, i64 0, i64 0), i8** %3
%442 = call i32 @strtoul(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.30, i64 0, i64 0), i8** %2, i32 0)
%443 = icmp eq i32 %442, -1
br i1 %443, label %444, label %452
444: ; preds = %438
%445 = load i8*, i8** %2
%446 = load i8*, i8** %3
%447 = getelementptr inbounds i8, i8* %446, i64 10
%448 = icmp eq i8* %445, %447
br i1 %448, label %449, label %452
449: ; preds = %444
%450 = load i64, i64* @errno
%451 = icmp eq i64 %450, 0
br label %452
452: ; preds = %449, %444, %438
%453 = phi i1 [ false, %444 ], [ false, %438 ], [ %451, %449 ]
%454 = zext i1 %453 to i32
%455 = call i32 @assert(i32 %454)
store i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.31, i64 0, i64 0), i8** %3
%456 = call i32 @strtoul(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.31, i64 0, i64 0), i8** %2, i32 0)
%457 = sext i32 %456 to i64
%458 = icmp eq i64 %457, -1
br i1 %458, label %459, label %467
459: ; preds = %452
%460 = load i8*, i8** %2
%461 = load i8*, i8** %3
%462 = getelementptr inbounds i8, i8* %461, i64 18
%463 = icmp eq i8* %460, %462
br i1 %463, label %464, label %467
464: ; preds = %459
%465 = load i64, i64* @errno
%466 = icmp eq i64 %465, 0
br label %467
467: ; preds = %464, %459, %452
%468 = phi i1 [ false, %459 ], [ false, %452 ], [ %466, %464 ]
%469 = zext i1 %468 to i32
%470 = call i32 @assert(i32 %469)
store i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.32, i64 0, i64 0), i8** %3
%471 = call i32 @strtoul(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.32, i64 0, i64 0), i8** %2, i32 0)
%472 = sext i32 %471 to i64
%473 = icmp eq i64 %472, -1147797409030816545
br i1 %473, label %474, label %482
474: ; preds = %467
%475 = load i8*, i8** %2
%476 = load i8*, i8** %3
%477 = getelementptr inbounds i8, i8* %476, i64 18
%478 = icmp eq i8* %475, %477
br i1 %478, label %479, label %482
479: ; preds = %474
%480 = load i64, i64* @errno
%481 = icmp eq i64 %480, 0
br label %482
482: ; preds = %479, %474, %467
%483 = phi i1 [ false, %474 ], [ false, %467 ], [ %481, %479 ]
%484 = zext i1 %483 to i32
%485 = call i32 @assert(i32 %484)
store i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.33, i64 0, i64 0), i8** %3
%486 = call i32 @strtoul(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.33, i64 0, i64 0), i8** %2, i32 0)
%487 = sext i32 %486 to i64
%488 = icmp eq i64 %487, -1
br i1 %488, label %489, label %498
489: ; preds = %482
%490 = load i8*, i8** %2
%491 = load i8*, i8** %3
%492 = getelementptr inbounds i8, i8* %491, i64 20
%493 = icmp eq i8* %490, %492
br i1 %493, label %494, label %498
494: ; preds = %489
%495 = load i64, i64* @errno
%496 = load i64, i64* @ERANGE
%497 = icmp eq i64 %495, %496
br label %498
498: ; preds = %494, %489, %482
%499 = phi i1 [ false, %489 ], [ false, %482 ], [ %497, %494 ]
%500 = zext i1 %499 to i32
%501 = call i32 @assert(i32 %500)
store i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.34, i64 0, i64 0), i8** %3
%502 = call i32 @strtoul(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.34, i64 0, i64 0), i8** %2, i32 0)
%503 = sext i32 %502 to i64
%504 = icmp eq i64 %503, -1
br i1 %504, label %505, label %514
505: ; preds = %498
%506 = load i8*, i8** %2
%507 = load i8*, i8** %3
%508 = getelementptr inbounds i8, i8* %507, i64 20
%509 = icmp eq i8* %506, %508
br i1 %509, label %510, label %514
510: ; preds = %505
%511 = load i64, i64* @errno
%512 = load i64, i64* @ERANGE
%513 = icmp eq i64 %511, %512
br label %514
514: ; preds = %510, %505, %498
%515 = phi i1 [ false, %505 ], [ false, %498 ], [ %513, %510 ]
%516 = zext i1 %515 to i32
%517 = call i32 @assert(i32 %516)
store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.35, i64 0, i64 0), i8** %3
%518 = call i32 @strtoul(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.35, i64 0, i64 0), i8** %2, i32 0)
%519 = icmp eq i32 %518, 0
br i1 %519, label %520, label %525
520: ; preds = %514
%521 = load i8*, i8** %2
%522 = load i8*, i8** %3
%523 = getelementptr inbounds i8, i8* %522, i64 1
%524 = icmp eq i8* %521, %523
br label %525
525: ; preds = %520, %514
%526 = phi i1 [ false, %514 ], [ %524, %520 ]
%527 = zext i1 %526 to i32
%528 = call i32 @assert(i32 %527)
ret i32 0
}

LLVM IR (-O2):
@.str = [4 x i8] c"123\00"
@.str.1 = [5 x i8] c"+123\00"
@.str.2 = [6 x i8] c" 123\00"
@.str.3 = [6 x i8] c" 123 \00"
@.str.4 = [7 x i8] c" -17\00"
@.str.5 = [5 x i8] c"0123\00"
@.str.6 = [6 x i8] c"0123a\00"
@.str.7 = [6 x i8] c"01239\00"
@.str.8 = [6 x i8] c"0x123\00"
@.str.9 = [7 x i8] c"-0x123\00"
@.str.10 = [6 x i8] c"0x0xc\00"
@.str.11 = [10 x i8] c" +0x123fg\00"
@.str.12 = [5 x i8] c"abcd\00"
@.str.13 = [5 x i8] c"AbCd\00"
@.str.14 = [7 x i8] c"0xABCD\00"
@.str.15 = [7 x i8] c"0Xabcd\00"
@.str.16 = [5 x i8] c"0xyz\00"
@.str.17 = [4 x i8] c"yz!\00"
@.str.18 = [4 x i8] c"-yz\00"
@.str.19 = [5 x i8] c"GhI4\00"
@.str.20 = [20 x i8] c"9223372036854775807\00"
@errno = global i64 0
@.str.21 = [20 x i8] c"9223372036854775808\00"
@ERANGE = global i64 0
@.str.22 = [22 x i8] c"922337203685477580777\00"
@.str.23 = [20 x i8] c"9223372036854775810\00"
@.str.24 = [12 x i8] c"-2147483648\00"
@.str.25 = [21 x i8] c"-9223372036854775808\00"
@.str.26 = [21 x i8] c"-9223372036854775809\00"
@.str.27 = [22 x i8] c"0x112233445566778899z\00"
@.str.28 = [19 x i8] c"0xFFFFFFFFFFFF00FF\00"
@.str.29 = [4 x i8] c" 0\00"
@.str.30 = [12 x i8] c"0xffffffffg\00"
@.str.31 = [20 x i8] c"0xffffffffffffffffg\00"
@.str.32 = [19 x i8] c"-0xfedcba987654321\00"
@.str.33 = [21 x i8] c"0xf1f2f3f4f5f6f7f8f9\00"
@.str.34 = [21 x i8] c"-0x123456789abcdef01\00"
@.str.35 = [4 x i8] c"0x,\00"
define i32 @main() {
%1 = alloca i8*
%2 = bitcast i8** %1 to i8*
%3 = call i32 @strtol(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8** %1, i32 0)
%4 = icmp eq i32 %3, 123
%5 = load i8*, i8** %1
%6 = icmp eq i8* %5, getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 3)
%7 = select i1 %4, i1 %6, i1 false
%8 = zext i1 %7 to i32
%9 = tail call i32 @assert(i32 %8)
%10 = call i32 @strtol(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8** %1, i32 0)
%11 = icmp eq i32 %10, 123
%12 = load i8*, i8** %1
%13 = icmp eq i8* %12, getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 4)
%14 = select i1 %11, i1 %13, i1 false
%15 = zext i1 %14 to i32
%16 = tail call i32 @assert(i32 %15)
%17 = call i32 @strtol(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), i8** %1, i32 0)
%18 = icmp eq i32 %17, 123
%19 = load i8*, i8** %1
%20 = icmp eq i8* %19, getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 5)
%21 = select i1 %18, i1 %20, i1 false
%22 = zext i1 %21 to i32
%23 = tail call i32 @assert(i32 %22)
%24 = call i32 @strtol(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8** %1, i32 0)
%25 = icmp eq i32 %24, 123
%26 = load i8*, i8** %1
%27 = icmp eq i8* %26, getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 4)
%28 = select i1 %25, i1 %27, i1 false
%29 = zext i1 %28 to i32
%30 = tail call i32 @assert(i32 %29)
%31 = call i32 @strtol(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.4, i64 0, i64 0), i8** %1, i32 0)
%32 = icmp eq i32 %31, -17
%33 = load i8*, i8** %1
%34 = icmp eq i8* %33, getelementptr inbounds ([7 x i8], [7 x i8]* @.str.4, i64 0, i64 6)
%35 = select i1 %32, i1 %34, i1 false
%36 = zext i1 %35 to i32
%37 = tail call i32 @assert(i32 %36)
%38 = call i32 @strtol(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0), i8** %1, i32 0)
%39 = icmp eq i32 %38, 83
%40 = load i8*, i8** %1
%41 = icmp eq i8* %40, getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 4)
%42 = select i1 %39, i1 %41, i1 false
%43 = zext i1 %42 to i32
%44 = tail call i32 @assert(i32 %43)
%45 = call i32 @strtol(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i8** %1, i32 0)
%46 = icmp eq i32 %45, 83
%47 = load i8*, i8** %1
%48 = icmp eq i8* %47, getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 4)
%49 = select i1 %46, i1 %48, i1 false
%50 = zext i1 %49 to i32
%51 = tail call i32 @assert(i32 %50)
%52 = call i32 @strtol(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 0), i8** %1, i32 0)
%53 = icmp eq i32 %52, 83
%54 = load i8*, i8** %1
%55 = icmp eq i8* %54, getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 4)
%56 = select i1 %53, i1 %55, i1 false
%57 = zext i1 %56 to i32
%58 = tail call i32 @assert(i32 %57)
%59 = call i32 @strtol(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 0), i8** %1, i32 0)
%60 = icmp eq i32 %59, 291
%61 = load i8*, i8** %1
%62 = icmp eq i8* %61, getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 5)
%63 = select i1 %60, i1 %62, i1 false
%64 = zext i1 %63 to i32
%65 = tail call i32 @assert(i32 %64)
%66 = call i32 @strtol(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.9, i64 0, i64 0), i8** %1, i32 0)
%67 = icmp eq i32 %66, -291
%68 = load i8*, i8** %1
%69 = icmp eq i8* %68, getelementptr inbounds ([7 x i8], [7 x i8]* @.str.9, i64 0, i64 6)
%70 = select i1 %67, i1 %69, i1 false
%71 = zext i1 %70 to i32
%72 = tail call i32 @assert(i32 %71)
%73 = call i32 @strtol(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i8** %1, i32 0)
%74 = icmp eq i32 %73, 0
%75 = load i8*, i8** %1
%76 = icmp eq i8* %75, getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 3)
%77 = select i1 %74, i1 %76, i1 false
%78 = zext i1 %77 to i32
%79 = tail call i32 @assert(i32 %78)
%80 = call i32 @strtol(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.11, i64 0, i64 0), i8** %1, i32 0)
%81 = icmp eq i32 %80, 4671
%82 = load i8*, i8** %1
%83 = icmp eq i8* %82, getelementptr inbounds ([10 x i8], [10 x i8]* @.str.11, i64 0, i64 8)
%84 = select i1 %81, i1 %83, i1 false
%85 = zext i1 %84 to i32
%86 = tail call i32 @assert(i32 %85)
%87 = call i32 @strtol(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8** %1, i32 16)
%88 = icmp eq i32 %87, 291
%89 = load i8*, i8** %1
%90 = icmp eq i8* %89, getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 3)
%91 = select i1 %88, i1 %90, i1 false
%92 = zext i1 %91 to i32
%93 = tail call i32 @assert(i32 %92)
%94 = call i32 @strtol(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 0), i8** %1, i32 16)
%95 = icmp eq i32 %94, 291
%96 = load i8*, i8** %1
%97 = icmp eq i8* %96, getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 5)
%98 = select i1 %95, i1 %97, i1 false
%99 = zext i1 %98 to i32
%100 = tail call i32 @assert(i32 %99)
%101 = call i32 @strtol(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8** %1, i32 8)
%102 = icmp eq i32 %101, 83
%103 = load i8*, i8** %1
%104 = icmp eq i8* %103, getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 3)
%105 = select i1 %102, i1 %104, i1 false
%106 = zext i1 %105 to i32
%107 = tail call i32 @assert(i32 %106)
%108 = call i32 @strtol(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0), i8** %1, i32 8)
%109 = icmp eq i32 %108, 83
%110 = load i8*, i8** %1
%111 = icmp eq i8* %110, getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 4)
%112 = select i1 %109, i1 %111, i1 false
%113 = zext i1 %112 to i32
%114 = tail call i32 @assert(i32 %113)
%115 = call i32 @strtol(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0), i8** %1, i32 10)
%116 = icmp eq i32 %115, 123
%117 = load i8*, i8** %1
%118 = icmp eq i8* %117, getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 4)
%119 = select i1 %116, i1 %118, i1 false
%120 = zext i1 %119 to i32
%121 = tail call i32 @assert(i32 %120)
%122 = call i32 @strtol(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 0), i8** %1, i32 10)
%123 = icmp eq i32 %122, 0
%124 = load i8*, i8** %1
%125 = icmp eq i8* %124, getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 1)
%126 = select i1 %123, i1 %125, i1 false
%127 = zext i1 %126 to i32
%128 = tail call i32 @assert(i32 %127)
%129 = call i32 @strtol(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.12, i64 0, i64 0), i8** %1, i32 16)
%130 = icmp eq i32 %129, 43981
%131 = load i8*, i8** %1
%132 = icmp eq i8* %131, getelementptr inbounds ([5 x i8], [5 x i8]* @.str.12, i64 0, i64 4)
%133 = select i1 %130, i1 %132, i1 false
%134 = zext i1 %133 to i32
%135 = tail call i32 @assert(i32 %134)
%136 = call i32 @strtol(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.13, i64 0, i64 0), i8** %1, i32 16)
%137 = icmp eq i32 %136, 43981
%138 = load i8*, i8** %1
%139 = icmp eq i8* %138, getelementptr inbounds ([5 x i8], [5 x i8]* @.str.13, i64 0, i64 4)
%140 = select i1 %137, i1 %139, i1 false
%141 = zext i1 %140 to i32
%142 = tail call i32 @assert(i32 %141)
%143 = call i32 @strtol(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.14, i64 0, i64 0), i8** %1, i32 16)
%144 = icmp eq i32 %143, 43981
%145 = load i8*, i8** %1
%146 = icmp eq i8* %145, getelementptr inbounds ([7 x i8], [7 x i8]* @.str.14, i64 0, i64 6)
%147 = select i1 %144, i1 %146, i1 false
%148 = zext i1 %147 to i32
%149 = tail call i32 @assert(i32 %148)
%150 = call i32 @strtol(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.15, i64 0, i64 0), i8** %1, i32 16)
%151 = icmp eq i32 %150, 43981
%152 = load i8*, i8** %1
%153 = icmp eq i8* %152, getelementptr inbounds ([7 x i8], [7 x i8]* @.str.15, i64 0, i64 6)
%154 = select i1 %151, i1 %153, i1 false
%155 = zext i1 %154 to i32
%156 = tail call i32 @assert(i32 %155)
%157 = call i32 @strtol(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.16, i64 0, i64 0), i8** %1, i32 35)
%158 = icmp eq i32 %157, 1189
%159 = load i8*, i8** %1
%160 = icmp eq i8* %159, getelementptr inbounds ([5 x i8], [5 x i8]* @.str.16, i64 0, i64 3)
%161 = select i1 %158, i1 %160, i1 false
%162 = zext i1 %161 to i32
%163 = tail call i32 @assert(i32 %162)
%164 = call i32 @strtol(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.17, i64 0, i64 0), i8** %1, i32 36)
%165 = icmp eq i32 %164, 1259
%166 = load i8*, i8** %1
%167 = icmp eq i8* %166, getelementptr inbounds ([4 x i8], [4 x i8]* @.str.17, i64 0, i64 2)
%168 = select i1 %165, i1 %167, i1 false
%169 = zext i1 %168 to i32
%170 = tail call i32 @assert(i32 %169)
%171 = call i32 @strtol(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.18, i64 0, i64 0), i8** %1, i32 36)
%172 = icmp eq i32 %171, -1259
%173 = load i8*, i8** %1
%174 = icmp eq i8* %173, getelementptr inbounds ([4 x i8], [4 x i8]* @.str.18, i64 0, i64 3)
%175 = select i1 %172, i1 %174, i1 false
%176 = zext i1 %175 to i32
%177 = tail call i32 @assert(i32 %176)
%178 = call i32 @strtol(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.19, i64 0, i64 0), i8** %1, i32 20)
%179 = icmp eq i32 %178, 135164
%180 = load i8*, i8** %1
%181 = icmp eq i8* %180, getelementptr inbounds ([5 x i8], [5 x i8]* @.str.19, i64 0, i64 4)
%182 = select i1 %179, i1 %181, i1 false
%183 = zext i1 %182 to i32
%184 = tail call i32 @assert(i32 %183)
%185 = call i32 @strtol(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.20, i64 0, i64 0), i8** %1, i32 0)
%186 = tail call i32 @assert(i32 0)
%187 = call i32 @strtol(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.21, i64 0, i64 0), i8** %1, i32 0)
%188 = tail call i32 @assert(i32 0)
%189 = call i32 @strtol(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.22, i64 0, i64 0), i8** %1, i32 0)
%190 = tail call i32 @assert(i32 0)
%191 = call i32 @strtol(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.23, i64 0, i64 0), i8** %1, i32 0)
%192 = tail call i32 @assert(i32 0)
store i64 0, i64* @errno
%193 = call i32 @strtol(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.24, i64 0, i64 0), i8** %1, i32 0)
%194 = icmp eq i32 %193, -2147483648
%195 = load i8*, i8** %1
%196 = icmp eq i8* %195, getelementptr inbounds ([12 x i8], [12 x i8]* @.str.24, i64 0, i64 11)
%197 = select i1 %194, i1 %196, i1 false
%198 = load i64, i64* @errno
%199 = icmp eq i64 %198, 0
%200 = select i1 %197, i1 %199, i1 false
%201 = zext i1 %200 to i32
%202 = tail call i32 @assert(i32 %201)
%203 = call i32 @strtol(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.25, i64 0, i64 0), i8** %1, i32 0)
%204 = tail call i32 @assert(i32 0)
%205 = call i32 @strtol(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.26, i64 0, i64 0), i8** %1, i32 0)
%206 = tail call i32 @assert(i32 0)
%207 = call i32 @strtol(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.27, i64 0, i64 0), i8** %1, i32 0)
%208 = tail call i32 @assert(i32 0)
%209 = call i32 @strtol(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.28, i64 0, i64 0), i8** %1, i32 0)
%210 = tail call i32 @assert(i32 0)
%211 = call i32 @strtoul(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.29, i64 0, i64 0), i8** %1, i32 0)
%212 = icmp eq i32 %211, 0
%213 = load i8*, i8** %1
%214 = icmp eq i8* %213, getelementptr inbounds ([4 x i8], [4 x i8]* @.str.29, i64 0, i64 3)
%215 = select i1 %212, i1 %214, i1 false
%216 = zext i1 %215 to i32
%217 = tail call i32 @assert(i32 %216)
store i64 0, i64* @errno
%218 = call i32 @strtoul(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.30, i64 0, i64 0), i8** %1, i32 0)
%219 = icmp eq i32 %218, -1
%220 = load i8*, i8** %1
%221 = icmp eq i8* %220, getelementptr inbounds ([12 x i8], [12 x i8]* @.str.30, i64 0, i64 10)
%222 = select i1 %219, i1 %221, i1 false
%223 = load i64, i64* @errno
%224 = icmp eq i64 %223, 0
%225 = select i1 %222, i1 %224, i1 false
%226 = zext i1 %225 to i32
%227 = tail call i32 @assert(i32 %226)
%228 = call i32 @strtoul(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.31, i64 0, i64 0), i8** %1, i32 0)
%229 = icmp eq i32 %228, -1
%230 = load i8*, i8** %1
%231 = icmp eq i8* %230, getelementptr inbounds ([20 x i8], [20 x i8]* @.str.31, i64 0, i64 18)
%232 = select i1 %229, i1 %231, i1 false
%233 = load i64, i64* @errno
%234 = icmp eq i64 %233, 0
%235 = select i1 %232, i1 %234, i1 false
%236 = zext i1 %235 to i32
%237 = tail call i32 @assert(i32 %236)
%238 = call i32 @strtoul(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.32, i64 0, i64 0), i8** %1, i32 0)
%239 = tail call i32 @assert(i32 0)
%240 = call i32 @strtoul(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.33, i64 0, i64 0), i8** %1, i32 0)
%241 = icmp eq i32 %240, -1
%242 = load i8*, i8** %1
%243 = icmp eq i8* %242, getelementptr inbounds ([21 x i8], [21 x i8]* @.str.33, i64 0, i64 20)
%244 = select i1 %241, i1 %243, i1 false
%245 = load i64, i64* @errno
%246 = load i64, i64* @ERANGE
%247 = icmp eq i64 %245, %246
%248 = select i1 %244, i1 %247, i1 false
%249 = zext i1 %248 to i32
%250 = tail call i32 @assert(i32 %249)
%251 = call i32 @strtoul(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.34, i64 0, i64 0), i8** %1, i32 0)
%252 = icmp eq i32 %251, -1
%253 = load i8*, i8** %1
%254 = icmp eq i8* %253, getelementptr inbounds ([21 x i8], [21 x i8]* @.str.34, i64 0, i64 20)
%255 = select i1 %252, i1 %254, i1 false
%256 = load i64, i64* @errno
%257 = load i64, i64* @ERANGE
%258 = icmp eq i64 %256, %257
%259 = select i1 %255, i1 %258, i1 false
%260 = zext i1 %259 to i32
%261 = tail call i32 @assert(i32 %260)
%262 = call i32 @strtoul(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.35, i64 0, i64 0), i8** %1, i32 0)
%263 = icmp eq i32 %262, 0
%264 = load i8*, i8** %1
%265 = icmp eq i8* %264, getelementptr inbounds ([4 x i8], [4 x i8]* @.str.35, i64 0, i64 1)
%266 = select i1 %263, i1 %265, i1 false
%267 = zext i1 %266 to i32
%268 = tail call i32 @assert(i32 %267)
ret i32 0
}