#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 */
typedef int uint32_t;
struct fake_file_t {
  int dummy;
};

/* Variables and functions */
int /*<<< orphan*/ ERANGE;
int LDBL_MANT_DIG;
int LDBL_MAX;
int LDBL_MIN;
long long LLONG_MIN;
long double copysignl(int /*<<< orphan*/, int);
int /*<<< orphan*/ errno;
int /*<<< orphan*/ scalbn(int, int);
long double scalbnl(long double, long long);
long long scanexp(struct fake_file_t *, int);
int shgetc(struct fake_file_t *);
int /*<<< orphan*/ shlim(struct fake_file_t *, int /*<<< orphan*/);
int /*<<< orphan*/ shunget(struct fake_file_t *);
long double hexfloat(struct fake_file_t *f, int bits, int emin, int sign,
                     int pok) {
  uint32_t x = 0;
  long double y = 0;
  long double scale = 1;
  long double bias = 0;
  int gottail = 0, gotrad = 0, gotdig = 0;
  long long rp = 0;
  long long dc = 0;
  long long e2 = 0;
  int d;
  int c;
  c = shgetc(f);
  for (; c == '0'; c = shgetc(f))
    gotdig = 1;
  if (c == '.') {
    gotrad = 1;
    c = shgetc(f);
    for (rp = 0; c == '0'; c = shgetc(f), rp--)
      gotdig = 1;
  }
  for (; c - '0' < 10U || (c | 32) - 'a' < 6U || c == '.'; c = shgetc(f)) {
    if (c == '.') {
      if (gotrad)
        break;
      rp = dc;
      gotrad = 1;
    } else {
      gotdig = 1;
      if (c > '9')
        d = (c | 32) + 10 - 'a';
      else
        d = c - '0';
      if (dc < 8) {
        x = x * 16 + d;
      } else if (dc < LDBL_MANT_DIG / 4 + 1) {
        y += d * (scale /= 16);
      } else if (d && !gottail) {
        y += 0.5 * scale;
        gottail = 1;
      }
      dc++;
    }
  }
  if (!gotdig) {
    shunget(f);
    if (pok) {
      shunget(f);
      if (gotrad)
        shunget(f);
    } else {
      shlim(f, 0);
    }
    return sign * 0.0;
  }
  if (!gotrad)
    rp = dc;
  while (dc < 8)
    x *= 16, dc++;
  if ((c | 32) == 'p') {
    e2 = scanexp(f, pok);
    if (e2 == LLONG_MIN) {
      if (pok) {
        shunget(f);
      } else {
        shlim(f, 0);
        return 0;
      }
      e2 = 0;
    }
  } else {
    shunget(f);
  }
  e2 += 4 * rp - 32;
  if (!x)
    return sign * 0.0;
  if (e2 > -emin) {
    errno = ERANGE;
    return sign * LDBL_MAX * LDBL_MAX;
  }
  if (e2 < emin - 2 * LDBL_MANT_DIG) {
    errno = ERANGE;
    return sign * LDBL_MIN * LDBL_MIN;
  }
  while (x < 0x80000000) {
    if (y >= 0.5) {
      x += x + 1;
      y += y - 1;
    } else {
      x += x;
      y += y;
    }
    e2--;
  }
  if (bits > 32 + e2 - emin) {
    bits = 32 + e2 - emin;
    if (bits < 0)
      bits = 0;
  }
  if (bits < LDBL_MANT_DIG)
    bias = copysignl(scalbn(1, 32 + LDBL_MANT_DIG - bits - 1), sign);
  if (bits < 32 && y && !(x & 1))
    x++, y = 0;
  y = bias + sign * (long double)x + sign * y;
  y -= bias;
  if (!y)
    errno = ERANGE;
  return scalbnl(y, e2);
}


x86 assembly (clang, -O0):
<hexfloat>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    %rdi,-0x18(%rbp)
mov    %esi,-0x1c(%rbp)
mov    %edx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8d,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
fldz
fld    %st(0)
fstpt  -0x40(%rbp)
fld1
fstpt  -0x50(%rbp)
fstpt  -0x60(%rbp)
movl   $0x0,-0x64(%rbp)
movl   $0x0,-0x68(%rbp)
movl   $0x0,-0x6c(%rbp)
movq   $0x0,-0x78(%rbp)
movq   $0x0,-0x80(%rbp)
movq   $0x0,-0x88(%rbp)
mov    -0x18(%rbp),%rdi
call   1090 <shgetc@plt>
mov    %eax,-0x90(%rbp)
cmpl   $0x30,-0x90(%rbp)
jne    1209 <hexfloat+0x99>
movl   $0x1,-0x6c(%rbp)
mov    -0x18(%rbp),%rdi
call   1090 <shgetc@plt>
mov    %eax,-0x90(%rbp)
jmp    11e1 <hexfloat+0x71>
cmpl   $0x2e,-0x90(%rbp)
jne    126d <hexfloat+0xfd>
movl   $0x1,-0x68(%rbp)
mov    -0x18(%rbp),%rdi
call   1090 <shgetc@plt>
mov    %eax,-0x90(%rbp)
movq   $0x0,-0x78(%rbp)
cmpl   $0x30,-0x90(%rbp)
jne    1268 <hexfloat+0xf8>
movl   $0x1,-0x6c(%rbp)
mov    -0x18(%rbp),%rdi
call   1090 <shgetc@plt>
mov    %eax,-0x90(%rbp)
mov    -0x78(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x78(%rbp)
jmp    1234 <hexfloat+0xc4>
jmp    126d <hexfloat+0xfd>
jmp    1272 <hexfloat+0x102>
mov    -0x90(%rbp),%ecx
sub    $0x30,%ecx
mov    $0x1,%al
cmp    $0xa,%ecx
mov    %al,-0xb9(%rbp)
jb     12b9 <hexfloat+0x149>
mov    -0x90(%rbp),%ecx
or     $0x20,%ecx
sub    $0x61,%ecx
mov    $0x1,%al
cmp    $0x6,%ecx
mov    %al,-0xb9(%rbp)
jb     12b9 <hexfloat+0x149>
cmpl   $0x2e,-0x90(%rbp)
sete   %al
mov    %al,-0xb9(%rbp)
mov    -0xb9(%rbp),%al
test   $0x1,%al
jne    12cc <hexfloat+0x15c>
jmp    141f <hexfloat+0x2af>
cmpl   $0x2e,-0x90(%rbp)
jne    12fc <hexfloat+0x18c>
cmpl   $0x0,-0x68(%rbp)
je     12e8 <hexfloat+0x178>
jmp    141f <hexfloat+0x2af>
mov    -0x80(%rbp),%rax
mov    %rax,-0x78(%rbp)
movl   $0x1,-0x68(%rbp)
jmp    1406 <hexfloat+0x296>
movl   $0x1,-0x6c(%rbp)
cmpl   $0x39,-0x90(%rbp)
jle    132a <hexfloat+0x1ba>
mov    -0x90(%rbp),%eax
or     $0x20,%eax
add    $0xa,%eax
sub    $0x61,%eax
mov    %eax,-0x8c(%rbp)
jmp    1339 <hexfloat+0x1c9>
mov    -0x90(%rbp),%eax
sub    $0x30,%eax
mov    %eax,-0x8c(%rbp)
cmpq   $0x8,-0x80(%rbp)
jge    1358 <hexfloat+0x1e8>
mov    -0x2c(%rbp),%eax
shl    $0x4,%eax
add    -0x8c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    13fa <hexfloat+0x28a>
mov    -0x80(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    0x2c4e(%rip),%rax
mov    (%rax),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xc8(%rbp),%rax
add    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jge    13bf <hexfloat+0x24f>
mov    -0x8c(%rbp),%eax
mov    %eax,-0x94(%rbp)
fildl  -0x94(%rbp)
fldt   -0x50(%rbp)
flds   0xc5d(%rip)
fdivrp %st,%st(1)
fld    %st(0)
fstpt  -0x50(%rbp)
fldt   -0x40(%rbp)
fxch   %st(2)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fstpt  -0x40(%rbp)
jmp    13f5 <hexfloat+0x285>
cmpl   $0x0,-0x8c(%rbp)
je     13f0 <hexfloat+0x280>
cmpl   $0x0,-0x64(%rbp)
jne    13f0 <hexfloat+0x280>
fldt   -0x50(%rbp)
fldt   -0x40(%rbp)
flds   0xc1e(%rip)
fmulp  %st,%st(2)
faddp  %st,%st(1)
fstpt  -0x40(%rbp)
movl   $0x1,-0x64(%rbp)
jmp    13f5 <hexfloat+0x285>
jmp    13fa <hexfloat+0x28a>
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
jmp    140b <hexfloat+0x29b>
mov    -0x18(%rbp),%rdi
call   1090 <shgetc@plt>
mov    %eax,-0x90(%rbp)
jmp    1272 <hexfloat+0x102>
cmpl   $0x0,-0x6c(%rbp)
jne    148a <hexfloat+0x31a>
mov    -0x18(%rbp),%rdi
call   1030 <shunget@plt>
cmpl   $0x0,-0x28(%rbp)
je     145d <hexfloat+0x2ed>
mov    -0x18(%rbp),%rdi
call   1030 <shunget@plt>
cmpl   $0x0,-0x68(%rbp)
je     1458 <hexfloat+0x2e8>
mov    -0x18(%rbp),%rdi
call   1030 <shunget@plt>
jmp    1468 <hexfloat+0x2f8>
mov    -0x18(%rbp),%rdi
xor    %esi,%esi
call   1060 <shlim@plt>
cvtsi2sdl -0x24(%rbp),%xmm0
xorps  %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
fldl   -0xa0(%rbp)
fstpt  -0x10(%rbp)
jmp    17f7 <hexfloat+0x687>
cmpl   $0x0,-0x68(%rbp)
jne    149c <hexfloat+0x32c>
mov    -0x80(%rbp),%rax
mov    %rax,-0x78(%rbp)
jmp    14a1 <hexfloat+0x331>
cmpq   $0x8,-0x80(%rbp)
jge    14c6 <hexfloat+0x356>
mov    -0x2c(%rbp),%eax
shl    $0x4,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
jmp    14a1 <hexfloat+0x331>
mov    -0x90(%rbp),%eax
or     $0x20,%eax
cmp    $0x70,%eax
jne    153f <hexfloat+0x3cf>
mov    -0x18(%rbp),%rdi
mov    -0x28(%rbp),%esi
call   1040 <scanexp@plt>
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
mov    0x2adf(%rip),%rcx
cmp    (%rcx),%rax
jne    153a <hexfloat+0x3ca>
cmpl   $0x0,-0x28(%rbp)
je     151a <hexfloat+0x3aa>
mov    -0x18(%rbp),%rdi
call   1030 <shunget@plt>
jmp    152f <hexfloat+0x3bf>
mov    -0x18(%rbp),%rdi
xor    %esi,%esi
call   1060 <shlim@plt>
fldz
fstpt  -0x10(%rbp)
jmp    17f7 <hexfloat+0x687>
movq   $0x0,-0x88(%rbp)
jmp    1548 <hexfloat+0x3d8>
mov    -0x18(%rbp),%rdi
call   1030 <shunget@plt>
mov    -0x78(%rbp),%rax
shl    $0x2,%rax
sub    $0x20,%rax
add    -0x88(%rbp),%rax
mov    %rax,-0x88(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jne    158e <hexfloat+0x41e>
cvtsi2sdl -0x24(%rbp),%xmm0
xorps  %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
fldl   -0xa8(%rbp)
fstpt  -0x10(%rbp)
jmp    17f7 <hexfloat+0x687>
mov    -0x88(%rbp),%rax
xor    %ecx,%ecx
sub    -0x20(%rbp),%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jle    15de <hexfloat+0x46e>
mov    0x2a3b(%rip),%rax
mov    (%rax),%ecx
mov    0x2a12(%rip),%rax
mov    %ecx,(%rax)
mov    -0x24(%rbp),%eax
mov    0x2a0e(%rip),%rcx
mov    (%rcx),%ecx
imul   %ecx,%eax
imul   %ecx,%eax
mov    %eax,-0xb8(%rbp)
fildl  -0xb8(%rbp)
fstpt  -0x10(%rbp)
jmp    17f7 <hexfloat+0x687>
mov    -0x88(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    0x29c9(%rip),%rdx
mov    (%rdx),%edx
shl    $0x1,%edx
sub    %edx,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jge    163a <hexfloat+0x4ca>
mov    0x29df(%rip),%rax
mov    (%rax),%ecx
mov    0x29b6(%rip),%rax
mov    %ecx,(%rax)
mov    -0x24(%rbp),%eax
mov    0x29a2(%rip),%rcx
mov    (%rcx),%ecx
imul   %ecx,%eax
imul   %ecx,%eax
mov    %eax,-0xb4(%rbp)
fildl  -0xb4(%rbp)
fstpt  -0x10(%rbp)
jmp    17f7 <hexfloat+0x687>
jmp    163f <hexfloat+0x4cf>
cmpl   $0x80000000,-0x2c(%rbp)
jae    16ac <hexfloat+0x53c>
fldt   -0x40(%rbp)
flds   0x9ab(%rip)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jb     1685 <hexfloat+0x515>
jmp    1666 <hexfloat+0x4f6>
mov    -0x2c(%rbp),%ecx
mov    %ecx,%eax
lea    0x1(%rax,%rax,1),%eax
mov    %eax,-0x2c(%rbp)
fldt   -0x40(%rbp)
fld1
fchs
fadd   %st(1),%st
faddp  %st,%st(1)
fstpt  -0x40(%rbp)
jmp    1695 <hexfloat+0x525>
mov    -0x2c(%rbp),%eax
add    %eax,%eax
mov    %eax,-0x2c(%rbp)
fldt   -0x40(%rbp)
fadd   %st,%st(0)
fstpt  -0x40(%rbp)
mov    -0x88(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x88(%rbp)
jmp    163f <hexfloat+0x4cf>
movslq -0x1c(%rbp),%rax
mov    -0x88(%rbp),%rcx
add    $0x20,%rcx
movslq -0x20(%rbp),%rdx
sub    %rdx,%rcx
cmp    %rcx,%rax
jle    16f6 <hexfloat+0x586>
mov    -0x88(%rbp),%rax
add    $0x20,%rax
movslq -0x20(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jge    16f1 <hexfloat+0x581>
movl   $0x0,-0x1c(%rbp)
jmp    16f6 <hexfloat+0x586>
mov    -0x1c(%rbp),%eax
mov    0x28b8(%rip),%rcx
cmp    (%rcx),%eax
jge    1735 <hexfloat+0x5c5>
mov    0x28a9(%rip),%rax
mov    (%rax),%edx
mov    -0x1c(%rbp),%eax
not    %eax
mov    %eax,%ecx
mov    %edx,%eax
lea    0x20(%rax,%rcx,1),%esi
mov    $0x1,%edi
call   1050 <scalbn@plt>
mov    %eax,%edi
mov    -0x24(%rbp),%esi
call   1070 <copysignl@plt>
fstpt  -0x60(%rbp)
cmpl   $0x20,-0x1c(%rbp)
jge    1778 <hexfloat+0x608>
fldt   -0x40(%rbp)
fldz
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    175b <hexfloat+0x5eb>
jp     175b <hexfloat+0x5eb>
jmp    1778 <hexfloat+0x608>
mov    -0x2c(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    1778 <hexfloat+0x608>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
fldz
fstpt  -0x40(%rbp)
fldt   -0x60(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0xb0(%rbp)
fildl  -0xb0(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0xac(%rbp)
fildl  -0xac(%rbp)
fmul   %st(1),%st
faddp  %st,%st(2)
fldt   -0x40(%rbp)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fstpt  -0x40(%rbp)
fldt   -0x60(%rbp)
fldt   -0x40(%rbp)
fsubp  %st,%st(1)
fstpt  -0x40(%rbp)
fldt   -0x40(%rbp)
fldz
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    17e0 <hexfloat+0x670>
jp     17e0 <hexfloat+0x670>
jmp    17ce <hexfloat+0x65e>
mov    0x2813(%rip),%rax
mov    (%rax),%ecx
mov    0x27ea(%rip),%rax
mov    %ecx,(%rax)
fldt   -0x40(%rbp)
mov    -0x88(%rbp),%rdi
mov    %rsp,%rax
fstpt  (%rax)
call   1080 <scalbnl@plt>
fstpt  -0x10(%rbp)
fldt   -0x10(%rbp)
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<hexfloat>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r8d,0x18(%rsp)
mov    %ecx,%r14d
mov    %edx,%ebx
mov    %esi,%r15d
mov    %rdi,%rbp
xor    %ecx,%ecx
mov    %ecx,%r13d
mov    %rbp,%rdi
call   1090 <shgetc@plt>
mov    $0x1,%ecx
cmp    $0x30,%eax
je     1190 <hexfloat+0x20>
cmp    $0x2e,%eax
mov    %r14d,0x14(%rsp)
mov    %ebx,0x40(%rsp)
mov    %r15d,0x3c(%rsp)
jne    11f3 <hexfloat+0x83>
mov    %rbp,%rdi
call   1090 <shgetc@plt>
cmp    $0x30,%eax
jne    11f7 <hexfloat+0x87>
xor    %r12d,%r12d
nopl   0x0(%rax,%rax,1)
mov    %rbp,%rdi
call   1090 <shgetc@plt>
add    $0xffffffffffffffff,%r12
cmp    $0x30,%eax
je     11d0 <hexfloat+0x60>
mov    $0x1,%ecx
mov    %rcx,0x28(%rsp)
mov    $0x1,%r13d
jmp    1204 <hexfloat+0x94>
xor    %ecx,%ecx
jmp    11fc <hexfloat+0x8c>
mov    $0x1,%ecx
mov    %rcx,0x28(%rsp)
xor    %r12d,%r12d
fld1
fstpt  0x30(%rsp)
fldz
xor    %ebx,%ebx
xor    %r15d,%r15d
xor    %r14d,%r14d
jmp    123f <hexfloat+0xcf>
cs nopw 0x0(%rax,%rax,1)
fstpt  0x1c(%rsp)
shl    $0x4,%ebx
add    %ecx,%ebx
add    $0x1,%r14
mov    $0x1,%r13d
mov    %rbp,%rdi
call   1090 <shgetc@plt>
fldt   0x1c(%rsp)
lea    -0x30(%rax),%ecx
mov    %eax,%edx
or     $0x20,%edx
cmp    $0xa,%ecx
jb     1280 <hexfloat+0x110>
lea    -0x61(%rdx),%esi
cmp    $0x6,%esi
jb     125d <hexfloat+0xed>
cmp    $0x2e,%eax
jne    1300 <hexfloat+0x190>
cmp    $0x2e,%eax
jne    1280 <hexfloat+0x110>
cmpl   $0x0,0x28(%rsp)
jne    12fb <hexfloat+0x18b>
fstpt  0x1c(%rsp)
mov    $0x1,%eax
mov    %rax,0x28(%rsp)
mov    %r14,%r12
jmp    1233 <hexfloat+0xc3>
add    $0xffffffa9,%edx
cmp    $0x3a,%eax
cmovge %edx,%ecx
cmp    $0x7,%r14
jle    1220 <hexfloat+0xb0>
mov    0x2d22(%rip),%rax
mov    (%rax),%eax
lea    0x3(%rax),%edx
test   %eax,%eax
cmovns %eax,%edx
sar    $0x2,%edx
add    $0x1,%edx
movslq %edx,%rax
cmp    %rax,%r14
jge    12ca <hexfloat+0x15a>
fldt   0x30(%rsp)
fmuls  0xd4c(%rip)
mov    %ecx,0x44(%rsp)
fld    %st(0)
fstpt  0x30(%rsp)
fimull 0x44(%rsp)
faddp  %st,%st(1)
jmp    12f2 <hexfloat+0x182>
test   %ecx,%ecx
sete   %al
test   %r15d,%r15d
setne  %cl
or     %al,%cl
fldt   0x30(%rsp)
fmuls  0xd1f(%rip)
fadd   %st(1),%st
test   %cl,%cl
fcmovne %st(1),%st
fstp   %st(1)
mov    $0x1,%eax
cmove  %eax,%r15d
fstpt  0x1c(%rsp)
jmp    1229 <hexfloat+0xb9>
mov    $0x2e,%eax
test   %r13d,%r13d
je     1344 <hexfloat+0x1d4>
cmpl   $0x0,0x28(%rsp)
cmove  %r14,%r12
cmp    $0x7,%r14
fstpt  0x1c(%rsp)
jg     1372 <hexfloat+0x202>
mov    %r14d,%ecx
neg    %ecx
and    $0x7,%rcx
je     13a2 <hexfloat+0x232>
neg    %rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
shl    $0x4,%ebx
add    $0xffffffffffffffff,%rdx
cmp    %rdx,%rcx
jne    1330 <hexfloat+0x1c0>
mov    %r14,%rcx
sub    %rdx,%rcx
jmp    13a5 <hexfloat+0x235>
fstp   %st(0)
mov    %rbp,%rdi
call   1030 <shunget@plt>
cmpl   $0x0,0x18(%rsp)
je     1379 <hexfloat+0x209>
mov    %rbp,%rdi
call   1030 <shunget@plt>
cmpl   $0x0,0x28(%rsp)
mov    0x14(%rsp),%ebx
je     1387 <hexfloat+0x217>
mov    %rbp,%rdi
call   1030 <shunget@plt>
jmp    1387 <hexfloat+0x217>
mov    0x18(%rsp),%r14d
jmp    13c8 <hexfloat+0x258>
mov    %rbp,%rdi
xor    %esi,%esi
call   1060 <shlim@plt>
mov    0x14(%rsp),%ebx
cvtsi2sd %ebx,%xmm0
xorpd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x58(%rsp)
fldl   0x58(%rsp)
jmp    15d4 <hexfloat+0x464>
mov    %r14,%rcx
add    $0xffffffffffffffff,%r14
cmp    $0x7,%r14
mov    0x18(%rsp),%r14d
jb     13c8 <hexfloat+0x258>
add    $0xfffffffffffffff8,%rcx
nopl   0x0(%rax,%rax,1)
add    $0x8,%rcx
jne    13c0 <hexfloat+0x250>
xor    %ebx,%ebx
and    $0xffffffdf,%eax
cmp    $0x50,%eax
jne    13f0 <hexfloat+0x280>
mov    %rbp,%rdi
mov    %r14d,%esi
call   1040 <scanexp@plt>
mov    0x2bf6(%rip),%rcx
cmp    (%rcx),%rax
jne    13fa <hexfloat+0x28a>
test   %r14d,%r14d
je     14eb <hexfloat+0x37b>
mov    %rbp,%rdi
call   1030 <shunget@plt>
xor    %eax,%eax
test   %ebx,%ebx
je     1447 <hexfloat+0x2d7>
lea    (%rax,%r12,4),%rbp
add    $0xffffffffffffffe0,%rbp
mov    0x40(%rsp),%esi
mov    %esi,%eax
neg    %eax
cltq
cmp    %rax,%rbp
jle    1464 <hexfloat+0x2f4>
mov    0x2bcc(%rip),%rax
mov    (%rax),%eax
mov    0x2ba3(%rip),%rcx
mov    %eax,(%rcx)
mov    0x2ba2(%rip),%rax
mov    (%rax),%eax
mov    0x14(%rsp),%ecx
imul   %eax,%ecx
imul   %eax,%ecx
mov    %ecx,0x48(%rsp)
fildl  0x48(%rsp)
jmp    15d4 <hexfloat+0x464>
cvtsi2sdl 0x14(%rsp),%xmm0
xorpd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x60(%rsp)
fldl   0x60(%rsp)
jmp    15d4 <hexfloat+0x464>
mov    0x2b4d(%rip),%rax
mov    (%rax),%eax
mov    %esi,%edx
sub    %eax,%edx
sub    %eax,%edx
movslq %edx,%rcx
cmp    %rcx,%rbp
jge    14ad <hexfloat+0x33d>
mov    0x2b66(%rip),%rax
mov    (%rax),%eax
mov    0x2b3d(%rip),%rcx
mov    %eax,(%rcx)
mov    0x2b2c(%rip),%rax
mov    (%rax),%eax
mov    0x14(%rsp),%ecx
imul   %eax,%ecx
imul   %eax,%ecx
mov    %ecx,0x4c(%rsp)
fildl  0x4c(%rsp)
jmp    15d4 <hexfloat+0x464>
test   %ebx,%ebx
mov    0x14(%rsp),%r15d
js     14fc <hexfloat+0x38c>
flds   0xb44(%rip)
fld1
fchs
fldt   0x1c(%rsp)
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    %ebx,%ebx
xor    %ecx,%ecx
fucomi %st(2),%st
fld    %st(0)
fadd   %st(2),%st
fcmovb %st(1),%st
setae  %cl
add    $0xffffffffffffffff,%rbp
or     %ecx,%ebx
faddp  %st,%st(1)
jns    14d0 <hexfloat+0x360>
jmp    1508 <hexfloat+0x398>
mov    %rbp,%rdi
xor    %esi,%esi
call   1060 <shlim@plt>
fldz
jmp    15d4 <hexfloat+0x464>
fldt   0x1c(%rsp)
fldz
fldz
fxch   %st(1)
fxch   %st(2)
fstp   %st(2)
fstp   %st(0)
movslq 0x3c(%rsp),%r14
movslq %esi,%rcx
mov    %rbp,%rdx
sub    %rcx,%rdx
add    $0x20,%rdx
xor    %ecx,%ecx
test   %edx,%edx
cmovns %edx,%ecx
cmp    %r14,%rdx
cmovl  %ecx,%r14d
fldz
fld    %st(0)
cmp    %eax,%r14d
jge    156a <hexfloat+0x3fa>
fstp   %st(0)
mov    %r14d,%ecx
not    %ecx
lea    (%rax,%rcx,1),%esi
add    $0x20,%esi
mov    $0x1,%edi
fxch   %st(1)
fstpt  0x1c(%rsp)
fstpt  0x30(%rsp)
call   1050 <scalbn@plt>
mov    %eax,%edi
mov    %r15d,%esi
call   1070 <copysignl@plt>
fldt   0x30(%rsp)
fldt   0x1c(%rsp)
fxch   %st(2)
cmp    $0x20,%r14d
setl   %al
fxch   %st(2)
fucomi %st(1),%st
setp   %cl
setne  %dl
or     %cl,%dl
test   $0x1,%bl
sete   %cl
and    %al,%cl
and    %dl,%cl
movzbl %cl,%eax
add    %eax,%ebx
test   %al,%al
fcmovne %st(1),%st
mov    %r15d,0x50(%rsp)
fildl  0x50(%rsp)
mov    %ebx,0x54(%rsp)
fld    %st(0)
fimull 0x54(%rsp)
fadd   %st(4),%st
fxch   %st(1)
fmulp  %st,%st(2)
faddp  %st,%st(1)
fsubp  %st,%st(2)
fxch   %st(1)
fucomi %st(1),%st
fstp   %st(1)
jne    15c9 <hexfloat+0x459>
jp     15c9 <hexfloat+0x459>
mov    0x2a2a(%rip),%rax
mov    (%rax),%eax
mov    0x2a01(%rip),%rcx
mov    %eax,(%rcx)
fstpt  (%rsp)
mov    %rbp,%rdi
call   1080 <scalbnl@plt>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
%struct.fake_file_t = type { i32 }
@LDBL_MANT_DIG = global i32 0
@LLONG_MIN = global i64 0
@ERANGE = global i32 0
@errno = global i32 0
@LDBL_MAX = global i32 0
@LDBL_MIN = global i32 0
define x86_fp80 @hexfloat(%struct.fake_file_t* %0, i32 %1, i32 %2, i32 %3, i32 %4) {
br label %6
6: ; preds = %6, %5
%7 = phi i32 [ 0, %5 ], [ 1, %6 ]
%8 = tail call i32 @shgetc(%struct.fake_file_t* %0)
switch i32 %8, label %17 [
i32 48, label %6
i32 46, label %9
]
9: ; preds = %6
%10 = tail call i32 @shgetc(%struct.fake_file_t* %0)
%11 = icmp eq i32 %10, 48
br i1 %11, label %12, label %17
12: ; preds = %9, %12
%13 = phi i64 [ %15, %12 ], [ 0, %9 ]
%14 = tail call i32 @shgetc(%struct.fake_file_t* %0)
%15 = add nsw i64 %13, -1
%16 = icmp eq i32 %14, 48
br i1 %16, label %12, label %17
17: ; preds = %6, %12, %9
%18 = phi i32 [ 1, %9 ], [ 1, %12 ], [ 0, %6 ]
%19 = phi i32 [ %7, %9 ], [ 1, %12 ], [ %7, %6 ]
%20 = phi i64 [ 0, %9 ], [ %15, %12 ], [ 0, %6 ]
%21 = phi i32 [ %10, %9 ], [ %14, %12 ], [ %8, %6 ]
br label %22
22: ; preds = %17, %74
%23 = phi i32 [ %75, %74 ], [ 0, %17 ]
%24 = phi x86_fp80 [ %76, %74 ], [ 0xK00000000000000000000, %17 ]
%25 = phi x86_fp80 [ %77, %74 ], [ 0xK3FFF8000000000000000, %17 ]
%26 = phi i32 [ %78, %74 ], [ 0, %17 ]
%27 = phi i32 [ %79, %74 ], [ %18, %17 ]
%28 = phi i32 [ %80, %74 ], [ %19, %17 ]
%29 = phi i64 [ %81, %74 ], [ %20, %17 ]
%30 = phi i64 [ %82, %74 ], [ 0, %17 ]
%31 = phi i32 [ %83, %74 ], [ %21, %17 ]
%32 = add nsw i32 %31, -48
%33 = icmp ult i32 %32, 10
%34 = or i32 %31, 32
br i1 %33, label %43, label %35
35: ; preds = %22
%36 = add nsw i32 %34, -97
%37 = icmp ult i32 %36, 6
%38 = icmp eq i32 %31, 46
%39 = select i1 %37, i1 true, i1 %38
br i1 %39, label %40, label %84
40: ; preds = %35
br i1 %38, label %41, label %43
41: ; preds = %40
%42 = icmp eq i32 %27, 0
br i1 %42, label %74, label %84
43: ; preds = %22, %40
%44 = icmp sgt i32 %31, 57
%45 = add nsw i32 %34, -87
%46 = select i1 %44, i32 %45, i32 %32
%47 = icmp slt i64 %30, 8
br i1 %47, label %48, label %51
48: ; preds = %43
%49 = shl nsw i32 %23, 4
%50 = add nsw i32 %46, %49
br label %68
51: ; preds = %43
%52 = load i32, i32* @LDBL_MANT_DIG
%53 = sdiv i32 %52, 4
%54 = add nsw i32 %53, 1
%55 = sext i32 %54 to i64
%56 = icmp slt i64 %30, %55
br i1 %56, label %57, label %61
57: ; preds = %51
%58 = sitofp i32 %46 to x86_fp80
%59 = fmul x86_fp80 %25, 0xK3FFB8000000000000000
%60 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %58, x86_fp80 %59, x86_fp80 %24)
br label %68
61: ; preds = %51
%62 = icmp eq i32 %46, 0
%63 = icmp ne i32 %26, 0
%64 = select i1 %62, i1 true, i1 %63
%65 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %25, x86_fp80 0xK3FFE8000000000000000, x86_fp80 %24)
%66 = select i1 %64, x86_fp80 %24, x86_fp80 %65
%67 = select i1 %64, i32 %26, i32 1
br label %68
68: ; preds = %61, %57, %48
%69 = phi i32 [ %50, %48 ], [ %23, %57 ], [ %23, %61 ]
%70 = phi x86_fp80 [ %24, %48 ], [ %60, %57 ], [ %66, %61 ]
%71 = phi x86_fp80 [ %25, %48 ], [ %59, %57 ], [ %25, %61 ]
%72 = phi i32 [ %26, %48 ], [ %26, %57 ], [ %67, %61 ]
%73 = add nsw i64 %30, 1
br label %74
74: ; preds = %41, %68
%75 = phi i32 [ %69, %68 ], [ %23, %41 ]
%76 = phi x86_fp80 [ %70, %68 ], [ %24, %41 ]
%77 = phi x86_fp80 [ %71, %68 ], [ %25, %41 ]
%78 = phi i32 [ %72, %68 ], [ %26, %41 ]
%79 = phi i32 [ %27, %68 ], [ 1, %41 ]
%80 = phi i32 [ 1, %68 ], [ %28, %41 ]
%81 = phi i64 [ %29, %68 ], [ %30, %41 ]
%82 = phi i64 [ %73, %68 ], [ %30, %41 ]
%83 = tail call i32 @shgetc(%struct.fake_file_t* %0)
br label %22
84: ; preds = %35, %41
%85 = phi i32 [ %31, %35 ], [ 46, %41 ]
%86 = icmp eq i32 %28, 0
br i1 %86, label %87, label %101
87: ; preds = %84
%88 = tail call i32 @shunget(%struct.fake_file_t* %0)
%89 = icmp eq i32 %4, 0
br i1 %89, label %95, label %90
90: ; preds = %87
%91 = tail call i32 @shunget(%struct.fake_file_t* %0)
%92 = icmp eq i32 %27, 0
br i1 %92, label %97, label %93
93: ; preds = %90
%94 = tail call i32 @shunget(%struct.fake_file_t* %0)
br label %97
95: ; preds = %87
%96 = tail call i32 @shlim(%struct.fake_file_t* %0, i32 0)
br label %97
97: ; preds = %90, %93, %95
%98 = sitofp i32 %3 to double
%99 = fmul double %98, 0.000000e+00
%100 = fpext double %99 to x86_fp80
br label %229
101: ; preds = %84
%102 = icmp eq i32 %27, 0
%103 = select i1 %102, i64 %30, i64 %29
%104 = icmp slt i64 %30, 8
br i1 %104, label %105, label %126
105: ; preds = %101
%106 = sub i64 0, %30
%107 = and i64 %106, 7
%108 = icmp eq i64 %107, 0
br i1 %108, label %117, label %109
109: ; preds = %105, %109
%110 = phi i64 [ %114, %109 ], [ %30, %105 ]
%111 = phi i32 [ %113, %109 ], [ %23, %105 ]
%112 = phi i64 [ %115, %109 ], [ 0, %105 ]
%113 = shl nsw i32 %111, 4
%114 = add i64 %110, 1
%115 = add i64 %112, 1
%116 = icmp eq i64 %115, %107
br i1 %116, label %117, label %109
117: ; preds = %109, %105
%118 = phi i32 [ undef, %105 ], [ %113, %109 ]
%119 = phi i64 [ %30, %105 ], [ %114, %109 ]
%120 = add i64 %30, -1
%121 = icmp ult i64 %120, 7
br i1 %121, label %126, label %122
122: ; preds = %117, %122
%123 = phi i64 [ %124, %122 ], [ %119, %117 ]
%124 = add i64 %123, 8
%125 = icmp eq i64 %123, 0
br i1 %125, label %126, label %122
126: ; preds = %117, %122, %101
%127 = phi i32 [ %23, %101 ], [ %118, %117 ], [ 0, %122 ]
%128 = and i32 %85, -33
%129 = icmp eq i32 %128, 80
br i1 %129, label %130, label %138
130: ; preds = %126
%131 = tail call i64 @scanexp(%struct.fake_file_t* %0, i32 %4)
%132 = load i64, i64* @LLONG_MIN
%133 = icmp eq i64 %131, %132
br i1 %133, label %134, label %140
134: ; preds = %130
%135 = icmp eq i32 %4, 0
br i1 %135, label %136, label %138
136: ; preds = %134
%137 = tail call i32 @shlim(%struct.fake_file_t* %0, i32 0)
br label %229
138: ; preds = %126, %134
%139 = tail call i32 @shunget(%struct.fake_file_t* %0)
br label %140
140: ; preds = %138, %130
%141 = phi i64 [ %131, %130 ], [ 0, %138 ]
%142 = shl nsw i64 %103, 2
%143 = add nsw i64 %142, -32
%144 = add nsw i64 %143, %141
%145 = icmp eq i32 %127, 0
br i1 %145, label %146, label %150
146: ; preds = %140
%147 = sitofp i32 %3 to double
%148 = fmul double %147, 0.000000e+00
%149 = fpext double %148 to x86_fp80
br label %229
150: ; preds = %140
%151 = sub nsw i32 0, %2
%152 = sext i32 %151 to i64
%153 = icmp sgt i64 %144, %152
br i1 %153, label %154, label %160
154: ; preds = %150
%155 = load i32, i32* @ERANGE
store i32 %155, i32* @errno
%156 = load i32, i32* @LDBL_MAX
%157 = mul nsw i32 %156, %3
%158 = mul nsw i32 %157, %156
%159 = sitofp i32 %158 to x86_fp80
br label %229
160: ; preds = %150
%161 = load i32, i32* @LDBL_MANT_DIG
%162 = mul i32 %161, -2
%163 = add i32 %162, %2
%164 = sext i32 %163 to i64
%165 = icmp slt i64 %144, %164
br i1 %165, label %168, label %166
166: ; preds = %160
%167 = icmp sgt i32 %127, -1
br i1 %167, label %174, label %188
168: ; preds = %160
%169 = load i32, i32* @ERANGE
store i32 %169, i32* @errno
%170 = load i32, i32* @LDBL_MIN
%171 = mul nsw i32 %170, %3
%172 = mul nsw i32 %171, %170
%173 = sitofp i32 %172 to x86_fp80
br label %229
174: ; preds = %166, %174
%175 = phi i64 [ %186, %174 ], [ %144, %166 ]
%176 = phi x86_fp80 [ %185, %174 ], [ %24, %166 ]
%177 = phi i32 [ %183, %174 ], [ %127, %166 ]
%178 = fcmp ult x86_fp80 %176, 0xK3FFE8000000000000000
%179 = shl nuw i32 %177, 1
%180 = fadd x86_fp80 %176, 0xKBFFF8000000000000000
%181 = xor i1 %178, true
%182 = zext i1 %181 to i32
%183 = or i32 %179, %182
%184 = select i1 %178, x86_fp80 %176, x86_fp80 %180
%185 = fadd x86_fp80 %176, %184
%186 = add nsw i64 %175, -1
%187 = icmp sgt i32 %183, -1
br i1 %187, label %174, label %188
188: ; preds = %174, %166
%189 = phi i32 [ %127, %166 ], [ %183, %174 ]
%190 = phi x86_fp80 [ %24, %166 ], [ %185, %174 ]
%191 = phi i64 [ %144, %166 ], [ %186, %174 ]
%192 = sext i32 %1 to i64
%193 = sext i32 %2 to i64
%194 = sub nsw i64 32, %193
%195 = add i64 %194, %191
%196 = icmp slt i64 %195, %192
%197 = trunc i64 %195 to i32
%198 = icmp sgt i32 %197, 0
%199 = select i1 %198, i32 %197, i32 0
%200 = select i1 %196, i32 %199, i32 %1
%201 = icmp slt i32 %200, %161
br i1 %201, label %202, label %208
202: ; preds = %188
%203 = add nsw i32 %161, 32
%204 = xor i32 %200, -1
%205 = add i32 %203, %204
%206 = tail call i32 @scalbn(i32 1, i32 %205)
%207 = tail call x86_fp80 @copysignl(i32 %206, i32 %3)
br label %208
208: ; preds = %202, %188
%209 = phi x86_fp80 [ %207, %202 ], [ 0xK00000000000000000000, %188 ]
%210 = icmp slt i32 %200, 32
%211 = fcmp une x86_fp80 %190, 0xK00000000000000000000
%212 = select i1 %210, i1 %211, i1 false
%213 = and i32 %189, 1
%214 = icmp eq i32 %213, 0
%215 = select i1 %212, i1 %214, i1 false
%216 = zext i1 %215 to i32
%217 = add nsw i32 %189, %216
%218 = select i1 %215, x86_fp80 0xK00000000000000000000, x86_fp80 %190
%219 = sitofp i32 %3 to x86_fp80
%220 = sitofp i32 %217 to x86_fp80
%221 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %219, x86_fp80 %220, x86_fp80 %209)
%222 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %219, x86_fp80 %218, x86_fp80 %221)
%223 = fsub x86_fp80 %222, %209
%224 = fcmp une x86_fp80 %223, 0xK00000000000000000000
br i1 %224, label %227, label %225
225: ; preds = %208
%226 = load i32, i32* @ERANGE
store i32 %226, i32* @errno
br label %227
227: ; preds = %225, %208
%228 = tail call x86_fp80 @scalbnl(x86_fp80 %223, i64 %191)
br label %229
229: ; preds = %227, %168, %154, %146, %136, %97
%230 = phi x86_fp80 [ %159, %154 ], [ %173, %168 ], [ %228, %227 ], [ %149, %146 ], [ 0xK00000000000000000000, %136 ], [ %100, %97 ]
ret x86_fp80 %230
}