#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 ERANGE;
int errno;
scalar_t__ isdigit(unsigned char const);
scalar_t__ isspace(unsigned char const);
scalar_t__ isxdigit(unsigned char const);
long strtol(void *, void *, int);
scalar_t__ valid_exp(unsigned char const *);
long double strtold(const char *s1, char **p) {
  const unsigned char *s = (void *)s1;
  long double x = 0;
  long double frac;
  int sign = 0;
  int nonzero = 0;
  int radix = '.';
  long e;
  int saved_errno = errno;
  if (!p)
    p = (char **)&s1;
  for (; isspace(*s); s++)
    ;
  if (*s == '-')
    sign = *s++;
  else if (*s == '+')
    s++;
  if ((s[0] | 32) == 'i' && (s[1] | 32) == 'n' && (s[2] | 32) == 'f') {
    *p = (char *)s + 3;
    return sign ? -1.0 / 0.0 : 1.0 / 0.0;
  } else if ((s[0] | 32) == 'n' && (s[1] | 32) == 'a' && (s[2] | 32) == 'n') {
    *p = (char *)s + 3;
    return 0.0 / 0.0;
  }
  if (s[0] == '0' && (s[1] | 32) == 'x') {
    if (!isxdigit(s[2]) && (s[2] != radix || !isxdigit(s[3]))) {
      *p = (char *)++s;
      return 0;
    }
    s += 2;
    for (; isxdigit(*s); s++) {
      x = 16 * x + (isdigit(*s) ? *s - '0' : (*s | 32) - 'a' + 10);
      if (*s != '0')
        nonzero = 1;
    }
    if (*s == radix) {
      frac = 1.0 / 16.0;
      for (s++; isxdigit(*s); s++) {
        x += frac * (isdigit(*s) ? *s - '0' : (*s | 32) - 'a' + 10);
        frac *= 1.0 / 16.0;
        if (*s != '0')
          nonzero = 1;
      }
    }
    if ((*s | 32) == 'p' && valid_exp(s + 1)) {
      e = strtol((void *)(s + 1), (void *)&s, 10);
      for (; e > 0; e--)
        x *= 2.0;
      for (; e < 0; e++)
        x *= 0.5;
    }
    goto finish;
  }
  if (!isdigit(s[0]) && (s[0] != radix || !isdigit(s[1]))) {
    *p = (char *)s1;
    return 0;
  }
  for (; isdigit(*s); s++) {
    x = 10 * x + *s - '0';
    if (*s != '0')
      nonzero = 1;
  }
  if (*s == radix) {
    frac = 10.0;
    for (s++; isdigit(*s); s++) {
      x += (*s - '0') / frac;
      frac *= 10.0;
      if (*s != '0')
        nonzero = 1;
    }
  }
  if ((*s | 32) == 'e' && valid_exp(s + 1)) {
    e = strtol((void *)++s, (void *)&s, 10);
    for (; e > 0; e--)
      x *= 10.0;
    for (; e < 0; e++)
      x /= 10.0;
  }
finish:
  errno = ((nonzero && !x) || !(1.0 / x)) ? ERANGE : saved_errno;
  *p = (char *)s;
  return sign ? -x : x;
}


x86 assembly (clang, -O0):
<strtold>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x18(%rbp)
mov    %rsi,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
fldz
fstpt  -0x40(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
movl   $0x2e,-0x5c(%rbp)
mov    0x2e4c(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x6c(%rbp)
cmpq   $0x0,-0x20(%rbp)
jne    11a4 <strtold+0x54>
lea    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    11a9 <strtold+0x59>
mov    -0x28(%rbp),%rax
movzbl (%rax),%edi
call   1050 <isspace@plt>
cmp    $0x0,%rax
je     11d5 <strtold+0x85>
jmp    11c4 <strtold+0x74>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    11a9 <strtold+0x59>
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x2d,%eax
jne    11ff <strtold+0xaf>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x54(%rbp)
jmp    1220 <strtold+0xd0>
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x2b,%eax
jne    121b <strtold+0xcb>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1220 <strtold+0xd0>
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
or     $0x20,%eax
cmp    $0x69,%eax
jne    1289 <strtold+0x139>
mov    -0x28(%rbp),%rax
movzbl 0x1(%rax),%eax
or     $0x20,%eax
cmp    $0x6e,%eax
jne    1289 <strtold+0x139>
mov    -0x28(%rbp),%rax
movzbl 0x2(%rax),%eax
or     $0x20,%eax
cmp    $0x66,%eax
jne    1289 <strtold+0x139>
mov    -0x28(%rbp),%rcx
add    $0x3,%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x54(%rbp),%eax
test   %eax,%eax
setne  %al
movzbl %al,%eax
mov    %eax,%ecx
lea    0xd9a(%rip),%rax
fldl   (%rax,%rcx,8)
fstpt  -0x10(%rbp)
jmp    184d <strtold+0x6fd>
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
or     $0x20,%eax
cmp    $0x6e,%eax
jne    12e1 <strtold+0x191>
mov    -0x28(%rbp),%rax
movzbl 0x1(%rax),%eax
or     $0x20,%eax
cmp    $0x61,%eax
jne    12e1 <strtold+0x191>
mov    -0x28(%rbp),%rax
movzbl 0x2(%rax),%eax
or     $0x20,%eax
cmp    $0x6e,%eax
jne    12e1 <strtold+0x191>
mov    -0x28(%rbp),%rcx
add    $0x3,%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
flds   0xd3b(%rip)
fstpt  -0x10(%rbp)
jmp    184d <strtold+0x6fd>
jmp    12e6 <strtold+0x196>
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x30,%eax
jne    15a2 <strtold+0x452>
mov    -0x28(%rbp),%rax
movzbl 0x1(%rax),%eax
or     $0x20,%eax
cmp    $0x78,%eax
jne    15a2 <strtold+0x452>
mov    -0x28(%rbp),%rax
movzbl 0x2(%rax),%edi
call   1070 <isxdigit@plt>
cmp    $0x0,%rax
jne    1366 <strtold+0x216>
mov    -0x28(%rbp),%rax
movzbl 0x2(%rax),%eax
cmp    -0x5c(%rbp),%eax
jne    1349 <strtold+0x1f9>
mov    -0x28(%rbp),%rax
movzbl 0x3(%rax),%edi
call   1070 <isxdigit@plt>
cmp    $0x0,%rax
jne    1366 <strtold+0x216>
mov    -0x28(%rbp),%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
fldz
fstpt  -0x10(%rbp)
jmp    184d <strtold+0x6fd>
mov    -0x28(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movzbl (%rax),%edi
call   1070 <isxdigit@plt>
cmp    $0x0,%rax
je     141e <strtold+0x2ce>
fldt   -0x40(%rbp)
fstpt  -0x88(%rbp)
mov    -0x28(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     13bc <strtold+0x26c>
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
sub    $0x30,%eax
mov    %eax,-0x8c(%rbp)
jmp    13d2 <strtold+0x282>
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
or     $0x20,%eax
sub    $0x61,%eax
add    $0xa,%eax
mov    %eax,-0x8c(%rbp)
fldt   -0x88(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
fildl  -0x7c(%rbp)
flds   0xc26(%rip)
fmulp  %st,%st(2)
faddp  %st,%st(1)
fstpt  -0x40(%rbp)
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x30,%eax
je     1408 <strtold+0x2b8>
movl   $0x1,-0x58(%rbp)
jmp    140d <strtold+0x2bd>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1372 <strtold+0x222>
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
cmp    -0x5c(%rbp),%eax
jne    1501 <strtold+0x3b1>
flds   0xbd4(%rip)
fstpt  -0x50(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movzbl (%rax),%edi
call   1070 <isxdigit@plt>
cmp    $0x0,%rax
je     14fc <strtold+0x3ac>
fldt   -0x50(%rbp)
fstpt  -0x98(%rbp)
mov    -0x28(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     148d <strtold+0x33d>
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
sub    $0x30,%eax
mov    %eax,-0x9c(%rbp)
jmp    14a3 <strtold+0x353>
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
or     $0x20,%eax
sub    $0x61,%eax
add    $0xa,%eax
mov    %eax,-0x9c(%rbp)
fldt   -0x98(%rbp)
mov    -0x9c(%rbp),%eax
mov    %eax,-0x78(%rbp)
fildl  -0x78(%rbp)
fldt   -0x40(%rbp)
fxch   %st(2)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fstpt  -0x40(%rbp)
fldt   -0x50(%rbp)
flds   0xb3e(%rip)
fmulp  %st,%st(1)
fstpt  -0x50(%rbp)
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x30,%eax
je     14e6 <strtold+0x396>
movl   $0x1,-0x58(%rbp)
jmp    14eb <strtold+0x39b>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1443 <strtold+0x2f3>
jmp    1501 <strtold+0x3b1>
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
or     $0x20,%eax
cmp    $0x70,%eax
jne    159d <strtold+0x44d>
mov    -0x28(%rbp),%rdi
add    $0x1,%rdi
call   1040 <valid_exp@plt>
cmp    $0x0,%rax
je     159d <strtold+0x44d>
mov    -0x28(%rbp),%rdi
add    $0x1,%rdi
lea    -0x28(%rbp),%rsi
mov    $0xa,%edx
call   1060 <strtol@plt>
mov    %rax,-0x68(%rbp)
cmpq   $0x0,-0x68(%rbp)
jle    1569 <strtold+0x419>
fldt   -0x40(%rbp)
fadd   %st,%st(0)
fstpt  -0x40(%rbp)
mov    -0x68(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x68(%rbp)
jmp    1545 <strtold+0x3f5>
jmp    156e <strtold+0x41e>
cmpq   $0x0,-0x68(%rbp)
jge    1598 <strtold+0x448>
fldt   -0x40(%rbp)
flds   0xa8a(%rip)
fmulp  %st,%st(1)
fstpt  -0x40(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    156e <strtold+0x41e>
jmp    159d <strtold+0x44d>
jmp    17a4 <strtold+0x654>
mov    -0x28(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
jne    15f4 <strtold+0x4a4>
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
cmp    -0x5c(%rbp),%eax
jne    15df <strtold+0x48f>
mov    -0x28(%rbp),%rax
movzbl 0x1(%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
jne    15f4 <strtold+0x4a4>
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
fldz
fstpt  -0x10(%rbp)
jmp    184d <strtold+0x6fd>
jmp    15f9 <strtold+0x4a9>
mov    -0x28(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     1661 <strtold+0x511>
fldt   -0x40(%rbp)
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x74(%rbp)
fildl  -0x74(%rbp)
flds   0x9db(%rip)
fmulp  %st,%st(2)
faddp  %st,%st(1)
flds   0x9d5(%rip)
faddp  %st,%st(1)
fstpt  -0x40(%rbp)
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x30,%eax
je     164b <strtold+0x4fb>
movl   $0x1,-0x58(%rbp)
jmp    1650 <strtold+0x500>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    15f9 <strtold+0x4a9>
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
cmp    -0x5c(%rbp),%eax
jne    16f9 <strtold+0x5a9>
flds   0x989(%rip)
fstpt  -0x50(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     16f4 <strtold+0x5a4>
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
add    $0xffffffd0,%eax
mov    %eax,-0x70(%rbp)
fildl  -0x70(%rbp)
fldt   -0x50(%rbp)
fdivrp %st,%st(1)
fldt   -0x40(%rbp)
faddp  %st,%st(1)
fstpt  -0x40(%rbp)
fldt   -0x50(%rbp)
flds   0x93e(%rip)
fmulp  %st,%st(1)
fstpt  -0x50(%rbp)
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x30,%eax
je     16de <strtold+0x58e>
movl   $0x1,-0x58(%rbp)
jmp    16e3 <strtold+0x593>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1686 <strtold+0x536>
jmp    16f9 <strtold+0x5a9>
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
or     $0x20,%eax
cmp    $0x65,%eax
jne    179f <strtold+0x64f>
mov    -0x28(%rbp),%rdi
add    $0x1,%rdi
call   1040 <valid_exp@plt>
cmp    $0x0,%rax
je     179f <strtold+0x64f>
mov    -0x28(%rbp),%rdi
add    $0x1,%rdi
mov    %rdi,-0x28(%rbp)
lea    -0x28(%rbp),%rsi
mov    $0xa,%edx
call   1060 <strtol@plt>
mov    %rax,-0x68(%rbp)
cmpq   $0x0,-0x68(%rbp)
jle    176b <strtold+0x61b>
fldt   -0x40(%rbp)
flds   0x8ab(%rip)
fmulp  %st,%st(1)
fstpt  -0x40(%rbp)
mov    -0x68(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x68(%rbp)
jmp    1741 <strtold+0x5f1>
jmp    1770 <strtold+0x620>
cmpq   $0x0,-0x68(%rbp)
jge    179a <strtold+0x64a>
fldt   -0x40(%rbp)
flds   0x87c(%rip)
fdivrp %st,%st(1)
fstpt  -0x40(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    1770 <strtold+0x620>
jmp    179f <strtold+0x64f>
jmp    17a4 <strtold+0x654>
cmpl   $0x0,-0x58(%rbp)
je     17ca <strtold+0x67a>
fldt   -0x40(%rbp)
fldz
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    17ca <strtold+0x67a>
jp     17ca <strtold+0x67a>
jmp    17ea <strtold+0x69a>
fldt   -0x40(%rbp)
fld1
fdivp  %st,%st(1)
fldz
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    17fe <strtold+0x6ae>
jp     17fe <strtold+0x6ae>
jmp    17ea <strtold+0x69a>
mov    0x27f7(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0xa0(%rbp)
jmp    1807 <strtold+0x6b7>
mov    -0x6c(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%ecx
mov    0x27c4(%rip),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
cmpl   $0x0,-0x54(%rbp)
je     183b <strtold+0x6eb>
fldt   -0x40(%rbp)
fchs
fstpt  -0xac(%rbp)
jmp    1844 <strtold+0x6f4>
fldt   -0x40(%rbp)
fstpt  -0xac(%rbp)
fldt   -0xac(%rbp)
fstpt  -0x10(%rbp)
fldt   -0x10(%rbp)
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<strtold>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rdi,%r14
mov    %rdi,0x40(%rsp)
mov    %rdi,0x10(%rsp)
mov    0x2e66(%rip),%r13
mov    0x0(%r13),%r12d
test   %rsi,%rsi
lea    0x40(%rsp),%r15
cmovne %rsi,%r15
movzbl (%rdi),%edi
call   1050 <isspace@plt>
mov    %r14,%rbx
test   %rax,%rax
je     11b7 <strtold+0x67>
mov    %r14,%rbx
cs nopw 0x0(%rax,%rax,1)
nop
movzbl 0x1(%rbx),%edi
add    $0x1,%rbx
call   1050 <isspace@plt>
test   %rax,%rax
jne    11a0 <strtold+0x50>
mov    %rbx,0x10(%rsp)
mov    (%rbx),%al
cmp    $0x2d,%al
je     11c9 <strtold+0x79>
mov    $0x1,%bpl
cmp    $0x2b,%al
jne    11da <strtold+0x8a>
mov    $0x1,%bpl
jmp    11cb <strtold+0x7b>
xor    %ebp,%ebp
lea    0x1(%rbx),%rcx
mov    %rcx,0x10(%rsp)
mov    0x1(%rbx),%al
mov    %rcx,%rbx
mov    %eax,%ecx
and    $0xdf,%cl
cmp    $0x4e,%cl
je     1222 <strtold+0xd2>
cmp    $0x49,%cl
jne    1252 <strtold+0x102>
mov    0x1(%rbx),%cl
and    $0xdf,%cl
cmp    $0x4e,%cl
jne    1326 <strtold+0x1d6>
mov    0x2(%rbx),%cl
and    $0xdf,%cl
cmp    $0x46,%cl
jne    1326 <strtold+0x1d6>
add    $0x3,%rbx
mov    %rbx,(%r15)
test   %bpl,%bpl
flds   0xded(%rip)
flds   0xdeb(%rip)
jmp    176f <strtold+0x61f>
mov    0x1(%rbx),%cl
and    $0xdf,%cl
cmp    $0x41,%cl
jne    1326 <strtold+0x1d6>
mov    0x2(%rbx),%cl
and    $0xdf,%cl
cmp    $0x4e,%cl
jne    1326 <strtold+0x1d6>
add    $0x3,%rbx
mov    %rbx,(%r15)
flds   0xdb3(%rip)
jmp    1773 <strtold+0x623>
cmp    $0x30,%al
jne    1326 <strtold+0x1d6>
mov    0x1(%rbx),%cl
and    $0xdf,%cl
cmp    $0x58,%cl
jne    1326 <strtold+0x1d6>
lea    0x2(%rbx),%r14
movzbl 0x2(%rbx),%edi
call   1070 <isxdigit@plt>
test   %rax,%rax
je     155c <strtold+0x40c>
mov    %ebp,0x20(%rsp)
mov    %r12d,0x24(%rsp)
mov    %r14,0x10(%rsp)
movzbl (%r14),%edi
call   1070 <isxdigit@plt>
fldz
test   %rax,%rax
je     1582 <strtold+0x432>
fstp   %st(0)
fldz
fstpt  0x4(%rsp)
xor    %r12d,%r12d
mov    $0x1,%ebx
mov    %r14,%rbp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl 0x0(%rbp),%edi
call   1030 <isdigit@plt>
movzbl 0x0(%rbp),%ecx
mov    %ecx,%edx
or     $0x20,%dl
test   %rax,%rax
movzbl %dl,%edx
cmovne %ecx,%edx
movzbl %dl,%edx
lea    -0x57(%rdx),%esi
add    $0xffffffd0,%edx
test   %rax,%rax
cmove  %esi,%edx
mov    %edx,0x38(%rsp)
fldt   0x4(%rsp)
fmuls  0xd1c(%rip)
fiaddl 0x38(%rsp)
fstpt  0x4(%rsp)
cmp    $0x30,%cl
cmovne %ebx,%r12d
lea    0x1(%rbp),%r14
mov    %r14,0x10(%rsp)
movzbl 0x1(%rbp),%edi
call   1070 <isxdigit@plt>
mov    %r14,%rbp
test   %rax,%rax
jne    12c0 <strtold+0x170>
jmp    1589 <strtold+0x439>
movzbl %al,%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     13ab <strtold+0x25b>
movzbl (%rbx),%edi
call   1030 <isdigit@plt>
fldz
test   %rax,%rax
mov    %r12d,0x24(%rsp)
mov    %ebp,0x20(%rsp)
je     13cc <strtold+0x27c>
fstp   %st(0)
add    $0x1,%rbx
fldz
xor    %r12d,%r12d
mov    $0x1,%ebp
nop
movzbl -0x1(%rbx),%eax
mov    %ax,0x1e(%rsp)
fmuls  0xc9d(%rip)
fiadds 0x1e(%rsp)
fadds  0xc97(%rip)
fstpt  0x4(%rsp)
cmp    $0x30,%al
cmovne %ebp,%r12d
mov    %rbx,0x10(%rsp)
movzbl (%rbx),%edi
call   1030 <isdigit@plt>
fldt   0x4(%rsp)
add    $0x1,%rbx
test   %rax,%rax
jne    1360 <strtold+0x210>
add    $0xffffffffffffffff,%rbx
cmpb   $0x2e,(%rbx)
je     13d8 <strtold+0x288>
jmp    1465 <strtold+0x315>
cmpb   $0x2e,(%rbx)
jne    13c2 <strtold+0x272>
movzbl 0x1(%rbx),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
jne    1333 <strtold+0x1e3>
mov    %r14,(%r15)
fldz
jmp    1773 <strtold+0x623>
xor    %r12d,%r12d
cmpb   $0x2e,(%rbx)
jne    1465 <strtold+0x315>
fstpt  0x4(%rsp)
lea    0x1(%rbx),%rbp
mov    %rbp,0x10(%rsp)
movzbl 0x1(%rbx),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     145e <strtold+0x30e>
add    $0x2,%rbx
flds   0xc0f(%rip)
mov    $0x1,%ebp
fldt   0x4(%rsp)
cs nopw 0x0(%rax,%rax,1)
movzbl -0x1(%rbx),%eax
lea    -0x30(%rax),%ecx
mov    %ecx,0x3c(%rsp)
fld    %st(1)
fidivrl 0x3c(%rsp)
cmp    $0x30,%eax
faddp  %st,%st(1)
fstpt  0x4(%rsp)
fmuls  0xbdc(%rip)
fstpt  0x28(%rsp)
cmovne %ebp,%r12d
mov    %rbx,0x10(%rsp)
movzbl (%rbx),%edi
call   1030 <isdigit@plt>
fldt   0x28(%rsp)
fldt   0x4(%rsp)
add    $0x1,%rbx
test   %rax,%rax
jne    1410 <strtold+0x2c0>
fstp   %st(1)
add    $0xffffffffffffffff,%rbx
jmp    1465 <strtold+0x315>
mov    %rbp,%rbx
fldt   0x4(%rsp)
mov    (%rbx),%al
and    $0xdf,%al
cmp    $0x45,%al
jne    1729 <strtold+0x5d9>
fstpt  0x4(%rsp)
add    $0x1,%rbx
mov    %rbx,%rdi
call   1040 <valid_exp@plt>
test   %rax,%rax
je     1511 <strtold+0x3c1>
mov    %rbx,0x10(%rsp)
lea    0x10(%rsp),%rsi
mov    %rbx,%rdi
mov    $0xa,%edx
call   1060 <strtol@plt>
test   %rax,%rax
jle    151a <strtold+0x3ca>
lea    -0x1(%rax),%rcx
mov    %rax,%rdx
fldz
and    $0x7,%rdx
fldt   0x4(%rsp)
je     14d6 <strtold+0x386>
fstp   %st(1)
xor    %esi,%esi
nopl   (%rax)
fmuls  0xb46(%rip)
add    $0x1,%rsi
cmp    %rsi,%rdx
jne    14c0 <strtold+0x370>
sub    %rsi,%rax
fld    %st(0)
fxch   %st(1)
cmp    $0x7,%rcx
jb     150a <strtold+0x3ba>
fstp   %st(1)
add    $0xffffffffffffffff,%rax
flds   0xb24(%rip)
nopl   0x0(%rax,%rax,1)
fmul   %st,%st(1)
fmul   %st,%st(1)
fmul   %st,%st(1)
fmul   %st,%st(1)
fmul   %st,%st(1)
fmul   %st,%st(1)
fmul   %st,%st(1)
fmul   %st,%st(1)
add    $0xfffffffffffffff8,%rax
cmp    $0xfffffffffffffffe,%rax
jb     14f0 <strtold+0x3a0>
fstp   %st(0)
jmp    1729 <strtold+0x5d9>
fldt   0x4(%rsp)
jmp    1729 <strtold+0x5d9>
fldt   0x4(%rsp)
jns    1729 <strtold+0x5d9>
mov    %eax,%ecx
neg    %ecx
fldz
and    $0x3,%rcx
je     16f7 <strtold+0x5a7>
fstp   %st(0)
neg    %rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
fdivs  0xac6(%rip)
add    $0xffffffffffffffff,%rdx
cmp    %rdx,%rcx
jne    1540 <strtold+0x3f0>
mov    %rax,%rcx
sub    %rdx,%rcx
fld    %st(0)
jmp    16fa <strtold+0x5aa>
cmpb   $0x2e,(%r14)
jne    1574 <strtold+0x424>
movzbl 0x3(%rbx),%edi
call   1070 <isxdigit@plt>
test   %rax,%rax
jne    127f <strtold+0x12f>
add    $0x1,%rbx
mov    %rbx,(%r15)
fldz
jmp    1773 <strtold+0x623>
xor    %r12d,%r12d
fstpt  0x4(%rsp)
fldt   0x4(%rsp)
fstpt  0x4(%rsp)
cmpb   $0x2e,(%r14)
jne    163f <strtold+0x4ef>
mov    %r13,%rbp
lea    0x1(%r14),%rbx
mov    %rbx,0x10(%rsp)
movzbl 0x1(%r14),%edi
call   1070 <isxdigit@plt>
test   %rax,%rax
je     1644 <strtold+0x4f4>
flds   0xa58(%rip)
fstpt  0x28(%rsp)
mov    $0x1,%r13d
fldt   0x4(%rsp)
fstp   %st(0)
movzbl (%rbx),%edi
call   1030 <isdigit@plt>
movzbl (%rbx),%ecx
mov    %ecx,%edx
or     $0x20,%dl
test   %rax,%rax
movzbl %dl,%edx
cmovne %ecx,%edx
movzbl %dl,%edx
lea    -0x57(%rdx),%esi
add    $0xffffffd0,%edx
test   %rax,%rax
cmove  %esi,%edx
mov    %edx,0x34(%rsp)
fldt   0x28(%rsp)
fld    %st(0)
fimull 0x34(%rsp)
fxch   %st(1)
fmuls  0xa0a(%rip)
fstpt  0x28(%rsp)
cmp    $0x30,%cl
cmovne %r13d,%r12d
fldt   0x4(%rsp)
faddp  %st,%st(1)
fstpt  0x4(%rsp)
lea    0x1(%rbx),%r14
mov    %r14,0x10(%rsp)
movzbl 0x1(%rbx),%edi
call   1070 <isxdigit@plt>
mov    %r14,%rbx
test   %rax,%rax
jne    15d0 <strtold+0x480>
jmp    164d <strtold+0x4fd>
mov    %r13,%rbp
jmp    1647 <strtold+0x4f7>
mov    %rbx,%r14
fldt   0x4(%rsp)
fstp   %st(0)
fldt   0x4(%rsp)
fstpt  0x4(%rsp)
mov    (%r14),%al
and    $0xdf,%al
cmp    $0x50,%al
jne    16ee <strtold+0x59e>
add    $0x1,%r14
mov    %r14,%rdi
call   1040 <valid_exp@plt>
test   %rax,%rax
je     16ee <strtold+0x59e>
lea    0x10(%rsp),%rsi
mov    %r14,%rdi
mov    $0xa,%edx
call   1060 <strtol@plt>
test   %rax,%rax
mov    %rbp,%r13
jle    1723 <strtold+0x5d3>
lea    -0x1(%rax),%rcx
mov    %rax,%rdx
fldz
and    $0x7,%rdx
fldt   0x4(%rsp)
je     16c2 <strtold+0x572>
fstp   %st(1)
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
fadd   %st,%st(0)
add    $0x1,%rsi
cmp    %rsi,%rdx
jne    16b0 <strtold+0x560>
sub    %rsi,%rax
fld    %st(0)
fxch   %st(1)
cmp    $0x7,%rcx
jb     150a <strtold+0x3ba>
fstp   %st(1)
add    $0xffffffffffffffff,%rax
fadd   %st,%st(0)
fadd   %st,%st(0)
fadd   %st,%st(0)
fadd   %st,%st(0)
fadd   %st,%st(0)
fadd   %st,%st(0)
fadd   %st,%st(0)
fadd   %st,%st(0)
add    $0xfffffffffffffff8,%rax
cmp    $0xfffffffffffffffe,%rax
jb     16d2 <strtold+0x582>
jmp    1729 <strtold+0x5d9>
mov    %rbp,%r13
fldt   0x4(%rsp)
jmp    1729 <strtold+0x5d9>
mov    %rax,%rcx
cmp    $0xfffffffffffffffc,%rax
jbe    1704 <strtold+0x5b4>
fstp   %st(1)
jmp    1729 <strtold+0x5d9>
fstp   %st(0)
flds   0x900(%rip)
nopl   0x0(%rax)
fdivr  %st,%st(1)
fdivr  %st,%st(1)
fdivr  %st,%st(1)
fdivr  %st,%st(1)
add    $0x4,%rcx
jne    1710 <strtold+0x5c0>
jmp    150a <strtold+0x3ba>
fldt   0x4(%rsp)
js     1782 <strtold+0x632>
fld1
fdiv   %st(1),%st
fldz
fxch   %st(1)
fucomip %st(1),%st
mov    0x28ae(%rip),%rax
mov    (%rax),%eax
mov    %eax,%ecx
mov    0x24(%rsp),%edx
cmovne %edx,%ecx
cmovp  %edx,%ecx
fxch   %st(1)
fucomi %st(1),%st
fstp   %st(1)
cmovne %ecx,%eax
cmovp  %ecx,%eax
test   %r12d,%r12d
cmove  %ecx,%eax
mov    %eax,0x0(%r13)
mov    0x10(%rsp),%rax
mov    %rax,(%r15)
fld    %st(0)
fchs
cmpb   $0x0,0x20(%rsp)
fcmovne %st(1),%st
fstp   %st(1)
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %eax,%ecx
neg    %ecx
fldz
and    $0x7,%rcx
je     17ae <strtold+0x65e>
fstp   %st(0)
neg    %rcx
xor    %edx,%edx
fmuls  0x881(%rip)
add    $0xffffffffffffffff,%rdx
cmp    %rdx,%rcx
jne    1795 <strtold+0x645>
mov    %rax,%rcx
sub    %rdx,%rcx
fld    %st(0)
jmp    17b1 <strtold+0x661>
mov    %rax,%rcx
cmp    $0xfffffffffffffff8,%rax
ja     1700 <strtold+0x5b0>
fstp   %st(0)
flds   0x859(%rip)
fmul   %st,%st(1)
fmul   %st,%st(1)
fmul   %st,%st(1)
fmul   %st,%st(1)
fmul   %st,%st(1)
fmul   %st,%st(1)
fmul   %st,%st(1)
fmul   %st,%st(1)
add    $0x8,%rcx
jne    17c3 <strtold+0x673>
jmp    150a <strtold+0x3ba>

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

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