#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 */
unsigned char *cvtround(double, int *, unsigned char *, unsigned char *,
                        unsigned char, unsigned char *);
unsigned char *exponent(unsigned char *, int, unsigned char);
double modf(double, double *);
int cvt(double number, int prec, int sharpflag, unsigned char *negp,
        unsigned char fmtch, unsigned char *startp, unsigned char *endp) {
  unsigned char *p, *t;
  double fract;
  int dotrim, expcnt, gformat;
  double integer, tmp;
  expcnt = 0;
  dotrim = expcnt = gformat = 0;
  fract = modf(number, &integer);
  t = ++startp;
  p = endp - 1;
  for (; integer && p >= startp; ++expcnt) {
    tmp = modf(integer * 0.1L, &integer);
    *p-- = (int)((tmp + .01L) * 10) + '0';
  }
  switch (fmtch) {
  case 'f':
    if (expcnt) {
      for (; ++p < endp; *t++ = *p)
        ;
    } else {
      *t++ = '0';
    }
    if (prec || sharpflag) {
      *t++ = '.';
    }
    if (fract) {
      if (prec) {
        do {
          fract = modf(fract * 10, &tmp);
          *t++ = (int)tmp + '0';
        } while (--prec && fract);
      }
      if (fract) {
        startp = cvtround(fract, 0, startp, t - 1, '0', negp);
      }
    }
    for (; prec--; *t++ = '0')
      ;
    break;
  case 'e':
  case 'E':
  eformat:
    if (expcnt) {
      *t++ = *++p;
      if (prec || sharpflag) {
        *t++ = '.';
      }
      for (; prec && ++p < endp; --prec) {
        *t++ = *p;
      }
      if (!prec && ++p < endp) {
        fract = 0;
        startp = cvtround(0, &expcnt, startp, t - 1, *p, negp);
      }
      --expcnt;
    } else if (fract) {
      for (expcnt = -1;; --expcnt) {
        fract = modf(fract * 10, &tmp);
        if (tmp) {
          break;
        }
      }
      *t++ = (int)tmp + '0';
      if (prec || sharpflag) {
        *t++ = '.';
      }
    } else {
      *t++ = '0';
      if (prec || sharpflag) {
        *t++ = '.';
      }
    }
    if (fract) {
      if (prec) {
        do {
          fract = modf(fract * 10, &tmp);
          *t++ = (int)tmp + '0';
        } while (--prec && fract);
      }
      if (fract) {
        startp = cvtround(fract, &expcnt, startp, t - 1, '0', negp);
      }
    }
    for (; prec--; *t++ = '0')
      ;
    if (gformat && !sharpflag) {
      while (t > startp && *--t == '0')
        ;
      if (*t == '.') {
        --t;
      }
      ++t;
    }
    t = exponent(t, expcnt, fmtch);
    break;
  case 'g':
  case 'G':
    if (!prec) {
      ++prec;
    }
    if (expcnt > prec || (!expcnt && fract && fract < .0001)) {
      --prec;
      fmtch -= 2;
      gformat = 1;
      goto eformat;
    }
    if (expcnt) {
      for (; ++p < endp; *t++ = *p, --prec)
        ;
    } else {
      *t++ = '0';
    }
    if (prec || sharpflag) {
      dotrim = 1;
      *t++ = '.';
    } else {
      dotrim = 0;
    }
    while (prec && fract) {
      fract = modf(fract * 10, &tmp);
      *t++ = (int)tmp + '0';
      prec--;
    }
    if (fract) {
      startp = cvtround(fract, 0, startp, t - 1, '0', negp);
    }
    if (sharpflag) {
      for (; prec--; *t++ = '0')
        ;
    } else if (dotrim) {
      while (t > startp && *--t == '0')
        ;
      if (*t != '.') {
        ++t;
      }
    }
  }
  return t - startp;
}


x86 assembly (clang, -O0):
<cvt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %cl,%al
movsd  %xmm0,-0x8(%rbp)
mov    %edi,-0xc(%rbp)
mov    %esi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %al,-0x19(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x4c(%rbp)
movsd  -0x8(%rbp),%xmm0
lea    -0x60(%rbp),%rdi
call   1040 <modf@plt>
movsd  %xmm0,-0x48(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
movsd  -0x60(%rbp),%xmm0
xor    %eax,%eax
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
mov    %al,-0x7d(%rbp)
jne    11c4 <cvt+0x94>
jp     11c4 <cvt+0x94>
jmp    11d2 <cvt+0xa2>
mov    -0x38(%rbp),%rax
cmp    -0x28(%rbp),%rax
setae  %al
mov    %al,-0x7d(%rbp)
mov    -0x7d(%rbp),%al
test   $0x1,%al
jne    11e2 <cvt+0xb2>
jmp    1256 <cvt+0x126>
fldl   -0x60(%rbp)
fldt   0xe25(%rip)
fmulp  %st,%st(1)
fstpl  -0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
lea    -0x60(%rbp),%rdi
call   1040 <modf@plt>
movsd  %xmm0,-0x68(%rbp)
fldl   -0x68(%rbp)
fldt   0xe14(%rip)
faddp  %st,%st(1)
flds   0xe1c(%rip)
fmulp  %st,%st(1)
fnstcw -0x7a(%rbp)
movzwl -0x7a(%rbp),%eax
or     $0xc00,%eax
mov    %ax,-0x7c(%rbp)
fldcw  -0x7c(%rbp)
fistpl -0x6c(%rbp)
fldcw  -0x7a(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    11a2 <cvt+0x72>
movzbl -0x19(%rbp),%eax
add    $0xffffffbb,%eax
mov    %eax,%ecx
mov    %rcx,-0x88(%rbp)
sub    $0x22,%eax
ja     1acc <cvt+0x99c>
mov    -0x88(%rbp),%rax
lea    0xdb7(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
cmpl   $0x0,-0x50(%rbp)
je     12d1 <cvt+0x1a1>
jmp    1295 <cvt+0x165>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
cmp    -0x30(%rbp),%rax
jae    12cc <cvt+0x19c>
jmp    12b0 <cvt+0x180>
mov    -0x38(%rbp),%rax
mov    (%rax),%cl
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x40(%rbp)
mov    %cl,(%rax)
jmp    1295 <cvt+0x165>
jmp    12e3 <cvt+0x1b3>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movb   $0x30,(%rax)
cmpl   $0x0,-0xc(%rbp)
jne    12f7 <cvt+0x1c7>
cmpl   $0x0,-0x10(%rbp)
je     1309 <cvt+0x1d9>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movb   $0x2e,(%rax)
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1326 <cvt+0x1f6>
jp     1326 <cvt+0x1f6>
jmp    13fb <cvt+0x2cb>
cmpl   $0x0,-0xc(%rbp)
je     13b2 <cvt+0x282>
jmp    1335 <cvt+0x205>
movsd  0xccb(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
lea    -0x68(%rbp),%rdi
call   1040 <modf@plt>
movsd  %xmm0,-0x48(%rbp)
cvttsd2si -0x68(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x40(%rbp)
mov    %cl,(%rax)
mov    -0xc(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0xc(%rbp)
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x89(%rbp)
je     139f <cvt+0x26f>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
setne  %al
setp   %cl
or     %cl,%al
mov    %al,-0x89(%rbp)
mov    -0x89(%rbp),%al
test   $0x1,%al
jne    1335 <cvt+0x205>
jmp    13b2 <cvt+0x282>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    13cf <cvt+0x29f>
jp     13cf <cvt+0x29f>
jmp    13f6 <cvt+0x2c6>
movsd  -0x48(%rbp),%xmm0
mov    -0x28(%rbp),%rsi
mov    -0x40(%rbp),%rdx
add    $0xffffffffffffffff,%rdx
mov    -0x18(%rbp),%r8
xor    %eax,%eax
mov    %eax,%edi
mov    $0x30,%ecx
call   1030 <cvtround@plt>
mov    %rax,-0x28(%rbp)
jmp    13fb <cvt+0x2cb>
jmp    1400 <cvt+0x2d0>
mov    -0xc(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0xc(%rbp)
cmp    $0x0,%eax
je     1430 <cvt+0x300>
jmp    1419 <cvt+0x2e9>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movb   $0x30,(%rax)
jmp    1400 <cvt+0x2d0>
jmp    1acc <cvt+0x99c>
jmp    143a <cvt+0x30a>
cmpl   $0x0,-0x50(%rbp)
je     1554 <cvt+0x424>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
mov    0x1(%rax),%cl
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x40(%rbp)
mov    %cl,(%rax)
cmpl   $0x0,-0xc(%rbp)
jne    147b <cvt+0x34b>
cmpl   $0x0,-0x10(%rbp)
je     148d <cvt+0x35d>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movb   $0x2e,(%rax)
jmp    1492 <cvt+0x362>
xor    %eax,%eax
cmpl   $0x0,-0xc(%rbp)
mov    %al,-0x8a(%rbp)
je     14bd <cvt+0x38d>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
cmp    -0x30(%rbp),%rax
setb   %al
mov    %al,-0x8a(%rbp)
mov    -0x8a(%rbp),%al
test   $0x1,%al
jne    14d0 <cvt+0x3a0>
jmp    14f5 <cvt+0x3c5>
mov    -0x38(%rbp),%rax
mov    (%rax),%cl
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x40(%rbp)
mov    %cl,(%rax)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    1492 <cvt+0x362>
cmpl   $0x0,-0xc(%rbp)
jne    1546 <cvt+0x416>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
cmp    -0x30(%rbp),%rax
jae    1546 <cvt+0x416>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x28(%rbp),%rsi
mov    -0x40(%rbp),%rdx
add    $0xffffffffffffffff,%rdx
mov    -0x38(%rbp),%rax
mov    (%rax),%al
mov    -0x18(%rbp),%r8
xorps  %xmm0,%xmm0
lea    -0x50(%rbp),%rdi
movzbl %al,%ecx
call   1030 <cvtround@plt>
mov    %rax,-0x28(%rbp)
mov    -0x50(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x50(%rbp)
jmp    1650 <cvt+0x520>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1571 <cvt+0x441>
jp     1571 <cvt+0x441>
jmp    160e <cvt+0x4de>
movl   $0xffffffff,-0x50(%rbp)
movsd  0xa88(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
lea    -0x68(%rbp),%rdi
call   1040 <modf@plt>
movsd  %xmm0,-0x48(%rbp)
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    15b0 <cvt+0x480>
jp     15b0 <cvt+0x480>
jmp    15b5 <cvt+0x485>
jmp    15c8 <cvt+0x498>
jmp    15ba <cvt+0x48a>
mov    -0x50(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x50(%rbp)
jmp    1578 <cvt+0x448>
cvttsd2si -0x68(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x40(%rbp)
mov    %cl,(%rax)
cmpl   $0x0,-0xc(%rbp)
jne    15f7 <cvt+0x4c7>
cmpl   $0x0,-0x10(%rbp)
je     1609 <cvt+0x4d9>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movb   $0x2e,(%rax)
jmp    164b <cvt+0x51b>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movb   $0x30,(%rax)
cmpl   $0x0,-0xc(%rbp)
jne    1634 <cvt+0x504>
cmpl   $0x0,-0x10(%rbp)
je     1646 <cvt+0x516>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movb   $0x2e,(%rax)
jmp    164b <cvt+0x51b>
jmp    1650 <cvt+0x520>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    166d <cvt+0x53d>
jp     166d <cvt+0x53d>
jmp    1742 <cvt+0x612>
cmpl   $0x0,-0xc(%rbp)
je     16f9 <cvt+0x5c9>
jmp    167c <cvt+0x54c>
movsd  0x984(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
lea    -0x68(%rbp),%rdi
call   1040 <modf@plt>
movsd  %xmm0,-0x48(%rbp)
cvttsd2si -0x68(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x40(%rbp)
mov    %cl,(%rax)
mov    -0xc(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0xc(%rbp)
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x8b(%rbp)
je     16e6 <cvt+0x5b6>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
setne  %al
setp   %cl
or     %cl,%al
mov    %al,-0x8b(%rbp)
mov    -0x8b(%rbp),%al
test   $0x1,%al
jne    167c <cvt+0x54c>
jmp    16f9 <cvt+0x5c9>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1716 <cvt+0x5e6>
jp     1716 <cvt+0x5e6>
jmp    173d <cvt+0x60d>
movsd  -0x48(%rbp),%xmm0
mov    -0x28(%rbp),%rsi
mov    -0x40(%rbp),%rdx
add    $0xffffffffffffffff,%rdx
mov    -0x18(%rbp),%r8
lea    -0x50(%rbp),%rdi
mov    $0x30,%ecx
call   1030 <cvtround@plt>
mov    %rax,-0x28(%rbp)
jmp    1742 <cvt+0x612>
jmp    1747 <cvt+0x617>
mov    -0xc(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0xc(%rbp)
cmp    $0x0,%eax
je     1777 <cvt+0x647>
jmp    1760 <cvt+0x630>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movb   $0x30,(%rax)
jmp    1747 <cvt+0x617>
cmpl   $0x0,-0x54(%rbp)
je     1805 <cvt+0x6d5>
cmpl   $0x0,-0x10(%rbp)
jne    1805 <cvt+0x6d5>
jmp    1790 <cvt+0x660>
mov    -0x40(%rbp),%rcx
xor    %eax,%eax
cmp    -0x28(%rbp),%rcx
mov    %al,-0x8c(%rbp)
jbe    17c5 <cvt+0x695>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x40(%rbp)
movzbl -0x1(%rax),%eax
cmp    $0x30,%eax
sete   %al
mov    %al,-0x8c(%rbp)
mov    -0x8c(%rbp),%al
test   $0x1,%al
jne    17d8 <cvt+0x6a8>
jmp    17dd <cvt+0x6ad>
jmp    1790 <cvt+0x660>
mov    -0x40(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x2e,%eax
jne    17f9 <cvt+0x6c9>
mov    -0x40(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rdi
mov    -0x50(%rbp),%esi
movzbl -0x19(%rbp),%edx
call   1050 <exponent@plt>
mov    %rax,-0x40(%rbp)
jmp    1acc <cvt+0x99c>
cmpl   $0x0,-0xc(%rbp)
jne    1831 <cvt+0x701>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1877 <cvt+0x747>
cmpl   $0x0,-0x50(%rbp)
jne    1896 <cvt+0x766>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1864 <cvt+0x734>
jp     1864 <cvt+0x734>
jmp    1896 <cvt+0x766>
movsd  0x794(%rip),%xmm0
ucomisd -0x48(%rbp),%xmm0
jbe    1896 <cvt+0x766>
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
movzbl -0x19(%rbp),%eax
sub    $0x2,%eax
mov    %al,-0x19(%rbp)
movl   $0x1,-0x54(%rbp)
jmp    143a <cvt+0x30a>
cmpl   $0x0,-0x50(%rbp)
je     18ea <cvt+0x7ba>
jmp    18a5 <cvt+0x775>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
cmp    -0x30(%rbp),%rax
jae    18e5 <cvt+0x7b5>
jmp    18c0 <cvt+0x790>
mov    -0x38(%rbp),%rax
mov    (%rax),%cl
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x40(%rbp)
mov    %cl,(%rax)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    18a5 <cvt+0x775>
jmp    18fc <cvt+0x7cc>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movb   $0x30,(%rax)
cmpl   $0x0,-0xc(%rbp)
jne    1910 <cvt+0x7e0>
cmpl   $0x0,-0x10(%rbp)
je     192e <cvt+0x7fe>
movl   $0x1,-0x4c(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movb   $0x2e,(%rax)
jmp    1935 <cvt+0x805>
movl   $0x0,-0x4c(%rbp)
jmp    193a <cvt+0x80a>
xor    %eax,%eax
cmpl   $0x0,-0xc(%rbp)
mov    %al,-0x8d(%rbp)
je     1966 <cvt+0x836>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
setne  %al
setp   %cl
or     %cl,%al
mov    %al,-0x8d(%rbp)
mov    -0x8d(%rbp),%al
test   $0x1,%al
jne    1979 <cvt+0x849>
jmp    19bd <cvt+0x88d>
movsd  0x687(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
lea    -0x68(%rbp),%rdi
call   1040 <modf@plt>
movsd  %xmm0,-0x48(%rbp)
cvttsd2si -0x68(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x40(%rbp)
mov    %cl,(%rax)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    193a <cvt+0x80a>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    19da <cvt+0x8aa>
jp     19da <cvt+0x8aa>
jmp    1a01 <cvt+0x8d1>
movsd  -0x48(%rbp),%xmm0
mov    -0x28(%rbp),%rsi
mov    -0x40(%rbp),%rdx
add    $0xffffffffffffffff,%rdx
mov    -0x18(%rbp),%r8
xor    %eax,%eax
mov    %eax,%edi
mov    $0x30,%ecx
call   1030 <cvtround@plt>
mov    %rax,-0x28(%rbp)
cmpl   $0x0,-0x10(%rbp)
je     1a45 <cvt+0x915>
jmp    1a10 <cvt+0x8e0>
mov    -0xc(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0xc(%rbp)
cmp    $0x0,%eax
je     1a40 <cvt+0x910>
jmp    1a29 <cvt+0x8f9>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movb   $0x30,(%rax)
jmp    1a10 <cvt+0x8e0>
jmp    1ac7 <cvt+0x997>
cmpl   $0x0,-0x4c(%rbp)
je     1ac2 <cvt+0x992>
jmp    1a54 <cvt+0x924>
mov    -0x40(%rbp),%rcx
xor    %eax,%eax
cmp    -0x28(%rbp),%rcx
mov    %al,-0x8e(%rbp)
jbe    1a89 <cvt+0x959>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x40(%rbp)
movzbl -0x1(%rax),%eax
cmp    $0x30,%eax
sete   %al
mov    %al,-0x8e(%rbp)
mov    -0x8e(%rbp),%al
test   $0x1,%al
jne    1a9c <cvt+0x96c>
jmp    1aa1 <cvt+0x971>
jmp    1a54 <cvt+0x924>
mov    -0x40(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x2e,%eax
je     1abd <cvt+0x98d>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1ac2 <cvt+0x992>
jmp    1ac7 <cvt+0x997>
jmp    1acc <cvt+0x99c>
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cvt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r9,%rbp
mov    %r8,%rbx
mov    %rcx,0x40(%rsp)
mov    %rdx,0x38(%rsp)
mov    %esi,0xc(%rsp)
mov    %edi,%r14d
movl   $0x0,0x18(%rsp)
lea    0x48(%rsp),%rdi
call   1040 <modf@plt>
movapd %xmm0,%xmm2
lea    0x1(%rbx),%r12
lea    -0x1(%rbp),%r13
movsd  0x48(%rsp),%xmm1
xor    %r15d,%r15d
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm1
jne    119c <cvt+0x5c>
jnp    125e <cvt+0x11e>
cmp    %r12,%r13
jb     125e <cvt+0x11e>
mov    %rbp,0x58(%rsp)
movsd  %xmm2,0x30(%rsp)
xor    %r15d,%r15d
lea    0x48(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movsd  %xmm1,0x70(%rsp)
fldt   0xe34(%rip)
fmull  0x70(%rsp)
fstpl  0x68(%rsp)
movsd  0x68(%rsp),%xmm0
mov    %rbp,%rdi
call   1040 <modf@plt>
movsd  %xmm0,0x60(%rsp)
fldt   0xe22(%rip)
faddl  0x60(%rsp)
fmuls  0xe28(%rip)
fnstcw 0x1e(%rsp)
movzwl 0x1e(%rsp),%eax
or     $0xc00,%eax
mov    %ax,0x2e(%rsp)
fldcw  0x2e(%rsp)
fistpl 0x54(%rsp)
fldcw  0x1e(%rsp)
movzbl 0x54(%rsp),%eax
add    $0x30,%al
mov    %al,0x0(%r13)
add    $0x1,%r15d
mov    %r15d,0x18(%rsp)
add    $0xffffffffffffffff,%r13
movsd  0x48(%rsp),%xmm1
ucomisd 0xdfb(%rip),%xmm1
jne    1241 <cvt+0x101>
jnp    124a <cvt+0x10a>
cmp    %r12,%r13
jae    11c0 <cvt+0x80>
mov    %r13,%rax
add    $0x1,%rax
movsd  0x30(%rsp),%xmm2
mov    0x58(%rsp),%rbp
jmp    1261 <cvt+0x121>
mov    %rbp,%rax
movsd  %xmm0,0x20(%rsp)
mov    0x40(%rsp),%rcx
add    $0xffffffbb,%ecx
cmp    $0x22,%cl
mov    %r12,0x10(%rsp)
ja     1517 <cvt+0x3d7>
mov    $0x1,%dl
mov    %edx,0x30(%rsp)
movzbl %cl,%ecx
lea    0xdb3(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
test   %r14d,%r14d
mov    $0x1,%r10d
cmovne %r14d,%r10d
cmp    %r10d,%r15d
jg     12d3 <cvt+0x193>
xorpd  %xmm0,%xmm0
test   %r15d,%r15d
jne    152e <cvt+0x3ee>
ucomisd %xmm0,%xmm2
jne    12c1 <cvt+0x181>
jnp    152e <cvt+0x3ee>
movsd  0xd5f(%rip),%xmm1
ucomisd %xmm2,%xmm1
jbe    152e <cvt+0x3ee>
add    $0xffffffff,%r10d
mov    0x40(%rsp),%rcx
add    $0xfe,%cl
mov    %rcx,0x40(%rsp)
movl   $0x0,0x30(%rsp)
mov    %r10d,%r14d
test   %r15d,%r15d
je     1317 <cvt+0x1d7>
mov    (%rax),%cl
mov    %cl,0x1(%rbx)
mov    %r14d,%ecx
mov    0xc(%rsp),%r13d
or     %r13d,%ecx
je     13a6 <cvt+0x266>
movb   $0x2e,0x2(%rbx)
add    $0x3,%rbx
jmp    13aa <cvt+0x26a>
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm2
jne    1327 <cvt+0x1e7>
jnp    1573 <cvt+0x433>
movl   $0xffffffff,0x18(%rsp)
ff
mulsd  0xcf9(%rip),%xmm2
lea    0x20(%rsp),%rdi
movapd %xmm2,%xmm0
call   1040 <modf@plt>
movapd %xmm0,%xmm2
movsd  0x20(%rsp),%xmm0
ucomisd 0xce1(%rip),%xmm0
jne    135f <cvt+0x21f>
jnp    15a5 <cvt+0x465>
mov    0x10(%rsp),%r12
mov    0xc(%rsp),%r13d
jmp    15f1 <cvt+0x4b1>
test   %r15d,%r15d
je     1595 <cvt+0x455>
lea    0x1(%r13),%rax
mov    0x10(%rsp),%r12
cmp    %rbp,%rax
jae    1813 <cvt+0x6d3>
mov    %r13,%rcx
not    %rcx
add    %rbp,%rcx
cmp    $0x20,%rcx
jae    1641 <cvt+0x501>
mov    0x10(%rsp),%r12
jmp    1782 <cvt+0x642>
add    $0x2,%rbx
mov    0x10(%rsp),%r12
test   %r14d,%r14d
je     13dc <cvt+0x29c>
add    $0x1,%rax
nopl   0x0(%rax,%rax,1)
cmp    %rbp,%rax
jae    1411 <cvt+0x2d1>
movzbl (%rax),%ecx
mov    %cl,(%rbx)
add    $0x1,%rbx
add    $0x1,%rax
add    $0xffffffff,%r14d
jne    13c0 <cvt+0x280>
add    $0xffffffffffffffff,%rax
add    $0x1,%rax
xor    %r14d,%r14d
cmp    %rbp,%rax
jae    1411 <cvt+0x2d1>
lea    -0x1(%rbx),%rdx
movzbl (%rax),%ecx
lea    0x18(%rsp),%rdi
xorpd  %xmm0,%xmm0
mov    %r12,%rsi
mov    0x38(%rsp),%r8
call   1030 <cvtround@plt>
xorpd  %xmm2,%xmm2
mov    %rax,%r12
mov    0x18(%rsp),%r15d
add    $0xffffffff,%r15d
mov    %r15d,0x18(%rsp)
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm2
jne    1426 <cvt+0x2e6>
jnp    14a1 <cvt+0x361>
test   %r14d,%r14d
je     1470 <cvt+0x330>
lea    0x20(%rsp),%r15
mov    %r14d,%ebp
mulsd  0xbf5(%rip),%xmm2
movapd %xmm2,%xmm0
mov    %r15,%rdi
call   1040 <modf@plt>
movapd %xmm0,%xmm2
cvttsd2si 0x20(%rsp),%eax
add    $0x30,%al
mov    %al,(%rbx)
add    $0x1,%rbx
lea    -0x1(%rbp),%r14d
cmp    $0x1,%ebp
je     1473 <cvt+0x333>
ucomisd 0xbce(%rip),%xmm2
jne    1430 <cvt+0x2f0>
jp     1430 <cvt+0x2f0>
jmp    1473 <cvt+0x333>
xor    %r14d,%r14d
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm2
jne    147f <cvt+0x33f>
jnp    14a1 <cvt+0x361>
lea    -0x1(%rbx),%rdx
lea    0x18(%rsp),%rdi
movapd %xmm2,%xmm0
mov    %r12,%rsi
mov    $0x30,%ecx
mov    0x38(%rsp),%r8
call   1030 <cvtround@plt>
mov    %rax,%r12
test   %r14d,%r14d
je     14c1 <cvt+0x381>
mov    %r14d,%edx
mov    %rbx,%rdi
mov    $0x30,%esi
call   1050 <memset@plt>
add    $0xffffffff,%r14d
add    %r14,%rbx
add    $0x1,%rbx
mov    0x30(%rsp),%ecx
test   %r13d,%r13d
setne  %al
or     %cl,%al
mov    %r12,0x10(%rsp)
jne    1503 <cvt+0x3c3>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %r12,%rbx
jbe    14f3 <cvt+0x3b3>
movzbl -0x1(%rbx),%eax
add    $0xffffffffffffffff,%rbx
cmp    $0x30,%al
je     14e0 <cvt+0x3a0>
jmp    14f5 <cvt+0x3b5>
mov    (%rbx),%al
xor    %ecx,%ecx
cmp    $0x2e,%al
sete   %cl
sub    %rcx,%rbx
add    $0x1,%rbx
mov    0x18(%rsp),%esi
movzbl 0x40(%rsp),%edx
mov    %rbx,%rdi
call   1060 <exponent@plt>
mov    %rax,%r12
sub    0x10(%rsp),%r12d
mov    %r12d,%eax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmpneqsd %xmm2,%xmm0
movq   %xmm0,%rax
test   %r15d,%r15d
je     161b <cvt+0x4db>
lea    0x1(%r13),%rcx
cmp    %rbp,%rcx
jae    1688 <cvt+0x548>
add    %r13d,%r10d
mov    %r13,%r9
not    %r9
add    %rbp,%r9
cmp    $0x20,%r9
jae    1697 <cvt+0x557>
mov    0x10(%rsp),%r12
mov    0xc(%rsp),%r15d
jmp    19bc <cvt+0x87c>
movb   $0x30,0x1(%rbx)
mov    %r14d,%eax
mov    0xc(%rsp),%r13d
or     %r13d,%eax
je     1630 <cvt+0x4f0>
movb   $0x2e,0x2(%rbx)
add    $0x3,%rbx
jmp    1637 <cvt+0x4f7>
movb   $0x30,0x1(%rbx)
add    $0x2,%rbx
mov    %rbx,%r12
jmp    1813 <cvt+0x6d3>
mov    $0xfffffffe,%ebp
lea    0x20(%rsp),%r15
mov    0x10(%rsp),%r12
mov    0xc(%rsp),%r13d
nopl   0x0(%rax)
mov    %ebp,0x18(%rsp)
mulsd  0xa64(%rip),%xmm2
movapd %xmm2,%xmm0
mov    %r15,%rdi
call   1040 <modf@plt>
movapd %xmm0,%xmm2
movsd  0x20(%rsp),%xmm0
add    $0xffffffff,%ebp
ucomisd 0xa4b(%rip),%xmm0
jne    15f1 <cvt+0x4b1>
jnp    15c0 <cvt+0x480>
cvttsd2si %xmm0,%eax
add    $0x30,%al
mov    %al,0x1(%rbx)
mov    %r14d,%eax
or     %r13d,%eax
je     160f <cvt+0x4cf>
movb   $0x2e,0x2(%rbx)
add    $0x3,%rbx
jmp    141a <cvt+0x2da>
add    $0x2,%rbx
xor    %r14d,%r14d
jmp    141a <cvt+0x2da>
movb   $0x30,0x1(%rbx)
add    $0x2,%rbx
mov    %rbx,%r12
mov    0xc(%rsp),%r15d
jmp    1a4a <cvt+0x90a>
add    $0x2,%rbx
xor    %r14d,%r14d
mov    0x10(%rsp),%r12
jmp    141a <cvt+0x2da>
mov    0x10(%rsp),%r12
cmp    %rbp,%r12
jae    165d <cvt+0x51d>
mov    %rbp,%rdx
sub    %r13,%rdx
add    %rbx,%rdx
cmp    %rdx,%rax
jb     1782 <cvt+0x642>
mov    %rbp,%r8
mov    %rcx,%rdx
and    $0xffffffffffffffe0,%rdx
lea    -0x20(%rdx),%rbp
mov    %rbp,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x60,%rbp
jae    16c1 <cvt+0x581>
xor    %ebp,%ebp
jmp    1736 <cvt+0x5f6>
mov    0x10(%rsp),%r12
mov    0xc(%rsp),%r15d
jmp    1a4a <cvt+0x90a>
mov    0x10(%rsp),%r12
cmp    %rbp,%r12
jae    18de <cvt+0x79e>
mov    %rbp,%rdx
sub    %r13,%rdx
add    %rbx,%rdx
cmp    %rdx,%rcx
jae    18de <cvt+0x79e>
mov    0xc(%rsp),%r15d
jmp    19bc <cvt+0x87c>
and    $0xfffffffffffffffc,%rdi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups 0x1(%r13,%rbp,1),%xmm0
movups 0x11(%r13,%rbp,1),%xmm1
movups %xmm0,0x1(%rbx,%rbp,1)
movups %xmm1,0x11(%rbx,%rbp,1)
movups 0x21(%r13,%rbp,1),%xmm0
movups 0x31(%r13,%rbp,1),%xmm1
movups %xmm0,0x21(%rbx,%rbp,1)
movups %xmm1,0x31(%rbx,%rbp,1)
movups 0x41(%r13,%rbp,1),%xmm0
movups 0x51(%r13,%rbp,1),%xmm1
movups %xmm0,0x41(%rbx,%rbp,1)
movups %xmm1,0x51(%rbx,%rbp,1)
movupd 0x61(%r13,%rbp,1),%xmm0
movupd 0x71(%r13,%rbp,1),%xmm1
movupd %xmm0,0x61(%rbx,%rbp,1)
movupd %xmm1,0x71(%rbx,%rbp,1)
sub    $0xffffffffffffff80,%rbp
add    $0xfffffffffffffffc,%rdi
jne    16d0 <cvt+0x590>
test   %rsi,%rsi
je     1770 <cvt+0x630>
lea    (%rbx,%rbp,1),%rdi
add    $0x11,%rdi
add    %r13,%rbp
add    $0x11,%rbp
shl    $0x5,%rsi
xor    %ebx,%ebx
movupd -0x10(%rbp,%rbx,1),%xmm0
movupd 0x0(%rbp,%rbx,1),%xmm1
movupd %xmm0,-0x10(%rdi,%rbx,1)
movupd %xmm1,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rsi
jne    1750 <cvt+0x610>
add    %rdx,%r12
cmp    %rdx,%rcx
je     1813 <cvt+0x6d3>
add    %rdx,%rax
mov    %r8,%rbp
mov    %ebp,%edx
sub    %eax,%edx
mov    %rax,%rcx
not    %rcx
add    %rbp,%rcx
and    $0x7,%rdx
je     17b5 <cvt+0x675>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rax),%ebx
mov    %bl,(%r12)
add    $0x1,%r12
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    17a0 <cvt+0x660>
cmp    $0x7,%rcx
jb     1813 <cvt+0x6d3>
nopl   0x0(%rax,%rax,1)
movzbl (%rax),%ecx
mov    %cl,(%r12)
movzbl 0x1(%rax),%ecx
mov    %cl,0x1(%r12)
movzbl 0x2(%rax),%ecx
mov    %cl,0x2(%r12)
movzbl 0x3(%rax),%ecx
mov    %cl,0x3(%r12)
movzbl 0x4(%rax),%ecx
mov    %cl,0x4(%r12)
movzbl 0x5(%rax),%ecx
mov    %cl,0x5(%r12)
movzbl 0x6(%rax),%ecx
mov    %cl,0x6(%r12)
movzbl 0x7(%rax),%ecx
mov    %cl,0x7(%r12)
add    $0x8,%r12
add    $0x8,%rax
cmp    %rbp,%rax
jne    17c0 <cvt+0x680>
or     %r14d,0xc(%rsp)
je     1823 <cvt+0x6e3>
movb   $0x2e,(%r12)
add    $0x1,%r12
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm2
jne    1833 <cvt+0x6f3>
jnp    18b5 <cvt+0x775>
test   %r14d,%r14d
je     1882 <cvt+0x742>
lea    0x20(%rsp),%rbx
nopl   (%rax)
mov    %r14d,%ebp
mulsd  0x7e5(%rip),%xmm2
movapd %xmm2,%xmm0
mov    %rbx,%rdi
call   1040 <modf@plt>
movapd %xmm0,%xmm2
cvttsd2si 0x20(%rsp),%eax
add    $0x30,%al
mov    %al,(%r12)
add    $0x1,%r12
lea    -0x1(%rbp),%r14d
cmp    $0x1,%ebp
je     1885 <cvt+0x745>
ucomisd 0x7bc(%rip),%xmm2
jne    1840 <cvt+0x700>
jp     1840 <cvt+0x700>
jmp    1885 <cvt+0x745>
xor    %r14d,%r14d
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm2
jne    1891 <cvt+0x751>
jnp    18b5 <cvt+0x775>
lea    -0x1(%r12),%rdx
movapd %xmm2,%xmm0
xor    %edi,%edi
mov    0x10(%rsp),%rsi
mov    $0x30,%ecx
mov    0x38(%rsp),%r8
call   1030 <cvtround@plt>
mov    %rax,0x10(%rsp)
test   %r14d,%r14d
je     1517 <cvt+0x3d7>
mov    %r14d,%edx
mov    %r12,%rdi
mov    $0x30,%esi
call   1050 <memset@plt>
add    $0xffffffff,%r14d
add    %r14,%r12
add    $0x1,%r12
jmp    1517 <cvt+0x3d7>
mov    %r9,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rdx
mov    %rdx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x60,%rdx
jae    1903 <cvt+0x7c3>
xor    %edx,%edx
jmp    196f <cvt+0x82f>
and    $0xfffffffffffffffc,%rdi
xor    %edx,%edx
movups 0x1(%r13,%rdx,1),%xmm0
movups 0x11(%r13,%rdx,1),%xmm1
movups %xmm0,0x1(%rbx,%rdx,1)
movups %xmm1,0x11(%rbx,%rdx,1)
movups 0x21(%r13,%rdx,1),%xmm0
movups 0x31(%r13,%rdx,1),%xmm1
movups %xmm0,0x21(%rbx,%rdx,1)
movups %xmm1,0x31(%rbx,%rdx,1)
movups 0x41(%r13,%rdx,1),%xmm0
movups 0x51(%r13,%rdx,1),%xmm1
movups %xmm0,0x41(%rbx,%rdx,1)
movups %xmm1,0x51(%rbx,%rdx,1)
movupd 0x61(%r13,%rdx,1),%xmm0
movupd 0x71(%r13,%rdx,1),%xmm1
movupd %xmm0,0x61(%rbx,%rdx,1)
movupd %xmm1,0x71(%rbx,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rdi
jne    1909 <cvt+0x7c9>
test   %rsi,%rsi
je     19a8 <cvt+0x868>
lea    (%rbx,%rdx,1),%rdi
add    $0x11,%rdi
add    %r13,%rdx
add    $0x11,%rdx
shl    $0x5,%rsi
xor    %ebx,%ebx
movupd -0x10(%rdx,%rbx,1),%xmm0
movupd (%rdx,%rbx,1),%xmm1
movupd %xmm0,-0x10(%rdi,%rbx,1)
movupd %xmm1,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rsi
jne    1989 <cvt+0x849>
add    %r8,%r12
cmp    %r8,%r9
mov    0xc(%rsp),%r15d
je     1a43 <cvt+0x903>
add    %r8,%rcx
mov    %ebp,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
not    %rdx
add    %rbp,%rdx
and    $0x7,%rsi
je     19e5 <cvt+0x8a5>
nop
movzbl (%rcx),%ebx
mov    %bl,(%r12)
add    $0x1,%r12
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    19d0 <cvt+0x890>
cmp    $0x7,%rdx
jb     1a43 <cvt+0x903>
nopl   0x0(%rax,%rax,1)
movzbl (%rcx),%edx
mov    %dl,(%r12)
movzbl 0x1(%rcx),%edx
mov    %dl,0x1(%r12)
movzbl 0x2(%rcx),%edx
mov    %dl,0x2(%r12)
movzbl 0x3(%rcx),%edx
mov    %dl,0x3(%r12)
movzbl 0x4(%rcx),%edx
mov    %dl,0x4(%r12)
movzbl 0x5(%rcx),%edx
mov    %dl,0x5(%r12)
movzbl 0x6(%rcx),%edx
mov    %dl,0x6(%r12)
movzbl 0x7(%rcx),%edx
mov    %dl,0x7(%r12)
add    $0x8,%r12
add    $0x8,%rcx
cmp    %rbp,%rcx
jne    19f0 <cvt+0x8b0>
sub    %ebp,%r10d
add    $0x1,%r10d
and    $0x1,%eax
mov    %r10d,%r14d
or     %r15d,%r14d
je     1a5e <cvt+0x91e>
movb   $0x2e,(%r12)
add    $0x1,%r12
test   %r10d,%r10d
je     1acd <cvt+0x98d>
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm2
jne    1a6f <cvt+0x92f>
jnp    1acd <cvt+0x98d>
lea    0x20(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r10d,%ebp
mulsd  0x5a5(%rip),%xmm2
movapd %xmm2,%xmm0
mov    %rbx,%rdi
call   1040 <modf@plt>
xorpd  %xmm1,%xmm1
movapd %xmm0,%xmm2
cvttsd2si 0x20(%rsp),%eax
add    $0x30,%al
mov    %al,(%r12)
add    $0x1,%r12
lea    -0x1(%rbp),%r10d
cmpneqsd %xmm1,%xmm0
movq   %xmm0,%rax
and    $0x1,%eax
cmp    $0x1,%ebp
je     1acd <cvt+0x98d>
ucomisd %xmm1,%xmm2
jne    1a80 <cvt+0x940>
jp     1a80 <cvt+0x940>
test   %al,%al
je     1afb <cvt+0x9bb>
lea    -0x1(%r12),%rdx
movapd %xmm2,%xmm0
xor    %edi,%edi
mov    0x10(%rsp),%rsi
mov    $0x30,%ecx
mov    0x38(%rsp),%r8
mov    %r10,%rbx
call   1030 <cvtround@plt>
mov    %rbx,%r10
mov    %rax,0x10(%rsp)
test   %r15d,%r15d
je     1b2b <cvt+0x9eb>
test   %r10d,%r10d
je     1517 <cvt+0x3d7>
mov    %r10d,%edx
mov    %r12,%rdi
mov    $0x30,%esi
mov    %r10,%rbx
call   1050 <memset@plt>
add    $0xffffffff,%ebx
add    %rbx,%r12
add    $0x1,%r12
jmp    1517 <cvt+0x3d7>
test   %r14d,%r14d
je     1517 <cvt+0x3d7>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    0x10(%rsp),%r12
jbe    1b57 <cvt+0xa17>
movzbl -0x1(%r12),%eax
add    $0xffffffffffffffff,%r12
cmp    $0x30,%al
je     1b40 <cvt+0xa00>
jmp    1b5b <cvt+0xa1b>
mov    (%r12),%al
xor    %ecx,%ecx
cmp    $0x2e,%al
setne  %cl
add    %rcx,%r12
jmp    1517 <cvt+0x3d7>

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

LLVM IR (-O2):
define i32 @cvt(double %0, i32 %1, i32 %2, i8* %3, i8 zeroext %4, i8* %5, i8* %6) {
%8 = ptrtoint i8* %6 to i64
%9 = alloca i32
%10 = alloca double
%11 = alloca double
%12 = bitcast i32* %9 to i8*
%13 = bitcast double* %10 to i8*
%14 = bitcast double* %11 to i8*
store i32 0, i32* %9
%15 = call double @modf(double %0, double* %10)
%16 = getelementptr i8, i8* %5, i64 1
%17 = getelementptr inbounds i8, i8* %6, i64 -1
%18 = load double, double* %10
%19 = fcmp une double %18, 0.000000e+00
%20 = icmp uge i8* %17, %16
%21 = select i1 %19, i1 %20, i1 false
br i1 %21, label %22, label %42
22: ; preds = %7, %22
%23 = phi i32 [ %36, %22 ], [ 0, %7 ]
%24 = phi double [ %38, %22 ], [ %18, %7 ]
%25 = phi i8* [ %37, %22 ], [ %17, %7 ]
%26 = fpext double %24 to x86_fp80
%27 = fmul x86_fp80 %26, 0xK3FFBCCCCCCCCCCCCCCCD
%28 = fptrunc x86_fp80 %27 to double
%29 = call double @modf(double %28, double* %10)
%30 = fpext double %29 to x86_fp80
%31 = fadd x86_fp80 %30, 0xK3FF8A3D70A3D70A3D70A
%32 = fmul x86_fp80 %31, 0xK4002A000000000000000
%33 = fptosi x86_fp80 %32 to i32
%34 = trunc i32 %33 to i8
%35 = add i8 %34, 48
store i8 %35, i8* %25
%36 = add nuw nsw i32 %23, 1
store i32 %36, i32* %9
%37 = getelementptr inbounds i8, i8* %25, i64 -1
%38 = load double, double* %10
%39 = fcmp une double %38, 0.000000e+00
%40 = icmp uge i8* %37, %16
%41 = select i1 %39, i1 %40, i1 false
br i1 %41, label %22, label %42
42: ; preds = %22, %7
%43 = phi i32 [ 0, %7 ], [ %36, %22 ]
%44 = phi double [ undef, %7 ], [ %29, %22 ]
%45 = phi i8* [ %6, %7 ], [ %25, %22 ]
%46 = phi i8* [ %17, %7 ], [ %37, %22 ]
%47 = ptrtoint i8* %46 to i64
store double %44, double* %11
switch i8 %4, label %614 [
i8 102, label %48
i8 101, label %243
i8 69, label %243
i8 103, label %384
i8 71, label %384
]
48: ; preds = %42
%49 = icmp eq i32 %43, 0
br i1 %49, label %196, label %50
50: ; preds = %48
%51 = getelementptr i8, i8* %46, i64 1
%52 = icmp ult i8* %51, %6
br i1 %52, label %53, label %198
53: ; preds = %50
%54 = sub i64 %8, %47
%55 = getelementptr i8, i8* %46, i64 %54
%56 = xor i64 %47, -1
%57 = add i64 %56, %8
%58 = icmp ult i64 %57, 32
br i1 %58, label %145, label %59
59: ; preds = %53
%60 = getelementptr i8, i8* %5, i64 %54
%61 = icmp ult i8* %16, %55
%62 = icmp ult i8* %51, %60
%63 = and i1 %61, %62
br i1 %63, label %145, label %64
64: ; preds = %59
%65 = and i64 %57, -32
%66 = getelementptr i8, i8* %51, i64 %65
%67 = getelementptr i8, i8* %16, i64 %65
%68 = add i64 %65, -32
%69 = lshr exact i64 %68, 5
%70 = add nuw nsw i64 %69, 1
%71 = and i64 %70, 3
%72 = icmp ult i64 %68, 96
br i1 %72, label %124, label %73
73: ; preds = %64
%74 = and i64 %70, 1152921504606846972
br label %75
75: ; preds = %75, %73
%76 = phi i64 [ 0, %73 ], [ %121, %75 ]
%77 = phi i64 [ 0, %73 ], [ %122, %75 ]
%78 = getelementptr i8, i8* %51, i64 %76
%79 = getelementptr i8, i8* %16, i64 %76
%80 = bitcast i8* %78 to <16 x i8>*
%81 = load <16 x i8>, <16 x i8>* %80
%82 = getelementptr i8, i8* %78, i64 16
%83 = bitcast i8* %82 to <16 x i8>*
%84 = load <16 x i8>, <16 x i8>* %83
%85 = bitcast i8* %79 to <16 x i8>*
store <16 x i8> %81, <16 x i8>* %85
%86 = getelementptr i8, i8* %79, i64 16
%87 = bitcast i8* %86 to <16 x i8>*
store <16 x i8> %84, <16 x i8>* %87
%88 = or i64 %76, 32
%89 = getelementptr i8, i8* %51, i64 %88
%90 = getelementptr i8, i8* %16, i64 %88
%91 = bitcast i8* %89 to <16 x i8>*
%92 = load <16 x i8>, <16 x i8>* %91
%93 = getelementptr i8, i8* %89, i64 16
%94 = bitcast i8* %93 to <16 x i8>*
%95 = load <16 x i8>, <16 x i8>* %94
%96 = bitcast i8* %90 to <16 x i8>*
store <16 x i8> %92, <16 x i8>* %96
%97 = getelementptr i8, i8* %90, i64 16
%98 = bitcast i8* %97 to <16 x i8>*
store <16 x i8> %95, <16 x i8>* %98
%99 = or i64 %76, 64
%100 = getelementptr i8, i8* %51, i64 %99
%101 = getelementptr i8, i8* %16, i64 %99
%102 = bitcast i8* %100 to <16 x i8>*
%103 = load <16 x i8>, <16 x i8>* %102
%104 = getelementptr i8, i8* %100, i64 16
%105 = bitcast i8* %104 to <16 x i8>*
%106 = load <16 x i8>, <16 x i8>* %105
%107 = bitcast i8* %101 to <16 x i8>*
store <16 x i8> %103, <16 x i8>* %107
%108 = getelementptr i8, i8* %101, i64 16
%109 = bitcast i8* %108 to <16 x i8>*
store <16 x i8> %106, <16 x i8>* %109
%110 = or i64 %76, 96
%111 = getelementptr i8, i8* %51, i64 %110
%112 = getelementptr i8, i8* %16, i64 %110
%113 = bitcast i8* %111 to <16 x i8>*
%114 = load <16 x i8>, <16 x i8>* %113
%115 = getelementptr i8, i8* %111, i64 16
%116 = bitcast i8* %115 to <16 x i8>*
%117 = load <16 x i8>, <16 x i8>* %116
%118 = bitcast i8* %112 to <16 x i8>*
store <16 x i8> %114, <16 x i8>* %118
%119 = getelementptr i8, i8* %112, i64 16
%120 = bitcast i8* %119 to <16 x i8>*
store <16 x i8> %117, <16 x i8>* %120
%121 = add nuw i64 %76, 128
%122 = add i64 %77, 4
%123 = icmp eq i64 %122, %74
br i1 %123, label %124, label %75
124: ; preds = %75, %64
%125 = phi i64 [ 0, %64 ], [ %121, %75 ]
%126 = icmp eq i64 %71, 0
br i1 %126, label %143, label %127
127: ; preds = %124, %127
%128 = phi i64 [ %140, %127 ], [ %125, %124 ]
%129 = phi i64 [ %141, %127 ], [ 0, %124 ]
%130 = getelementptr i8, i8* %51, i64 %128
%131 = getelementptr i8, i8* %16, i64 %128
%132 = bitcast i8* %130 to <16 x i8>*
%133 = load <16 x i8>, <16 x i8>* %132
%134 = getelementptr i8, i8* %130, i64 16
%135 = bitcast i8* %134 to <16 x i8>*
%136 = load <16 x i8>, <16 x i8>* %135
%137 = bitcast i8* %131 to <16 x i8>*
store <16 x i8> %133, <16 x i8>* %137
%138 = getelementptr i8, i8* %131, i64 16
%139 = bitcast i8* %138 to <16 x i8>*
store <16 x i8> %136, <16 x i8>* %139
%140 = add nuw i64 %128, 32
%141 = add i64 %129, 1
%142 = icmp eq i64 %141, %71
br i1 %142, label %143, label %127
143: ; preds = %127, %124
%144 = icmp eq i64 %57, %65
br i1 %144, label %198, label %145
145: ; preds = %59, %53, %143
%146 = phi i8* [ %51, %59 ], [ %51, %53 ], [ %66, %143 ]
%147 = phi i8* [ %16, %59 ], [ %16, %53 ], [ %67, %143 ]
%148 = ptrtoint i8* %146 to i64
%149 = sub i64 %8, %148
%150 = xor i64 %148, -1
%151 = add i64 %150, %8
%152 = and i64 %149, 7
%153 = icmp eq i64 %152, 0
br i1 %153, label %163, label %154
154: ; preds = %145, %154
%155 = phi i8* [ %160, %154 ], [ %146, %145 ]
%156 = phi i8* [ %159, %154 ], [ %147, %145 ]
%157 = phi i64 [ %161, %154 ], [ 0, %145 ]
%158 = load i8, i8* %155
%159 = getelementptr inbounds i8, i8* %156, i64 1
store i8 %158, i8* %156
%160 = getelementptr inbounds i8, i8* %155, i64 1
%161 = add i64 %157, 1
%162 = icmp eq i64 %161, %152
br i1 %162, label %163, label %154
163: ; preds = %154, %145
%164 = phi i8* [ undef, %145 ], [ %159, %154 ]
%165 = phi i8* [ %146, %145 ], [ %160, %154 ]
%166 = phi i8* [ %147, %145 ], [ %159, %154 ]
%167 = icmp ult i64 %151, 7
br i1 %167, label %198, label %168
168: ; preds = %163, %168
%169 = phi i8* [ %194, %168 ], [ %165, %163 ]
%170 = phi i8* [ %193, %168 ], [ %166, %163 ]
%171 = load i8, i8* %169
%172 = getelementptr inbounds i8, i8* %170, i64 1
store i8 %171, i8* %170
%173 = getelementptr inbounds i8, i8* %169, i64 1
%174 = load i8, i8* %173
%175 = getelementptr inbounds i8, i8* %170, i64 2
store i8 %174, i8* %172
%176 = getelementptr inbounds i8, i8* %169, i64 2
%177 = load i8, i8* %176
%178 = getelementptr inbounds i8, i8* %170, i64 3
store i8 %177, i8* %175
%179 = getelementptr inbounds i8, i8* %169, i64 3
%180 = load i8, i8* %179
%181 = getelementptr inbounds i8, i8* %170, i64 4
store i8 %180, i8* %178
%182 = getelementptr inbounds i8, i8* %169, i64 4
%183 = load i8, i8* %182
%184 = getelementptr inbounds i8, i8* %170, i64 5
store i8 %183, i8* %181
%185 = getelementptr inbounds i8, i8* %169, i64 5
%186 = load i8, i8* %185
%187 = getelementptr inbounds i8, i8* %170, i64 6
store i8 %186, i8* %184
%188 = getelementptr inbounds i8, i8* %169, i64 6
%189 = load i8, i8* %188
%190 = getelementptr inbounds i8, i8* %170, i64 7
store i8 %189, i8* %187
%191 = getelementptr inbounds i8, i8* %169, i64 7
%192 = load i8, i8* %191
%193 = getelementptr inbounds i8, i8* %170, i64 8
store i8 %192, i8* %190
%194 = getelementptr inbounds i8, i8* %169, i64 8
%195 = icmp eq i8* %194, %55
br i1 %195, label %198, label %168
196: ; preds = %48
%197 = getelementptr inbounds i8, i8* %5, i64 2
store i8 48, i8* %16
br label %198
198: ; preds = %163, %168, %143, %50, %196
%199 = phi i8* [ %197, %196 ], [ %16, %50 ], [ %67, %143 ], [ %164, %163 ], [ %193, %168 ]
%200 = icmp eq i32 %1, 0
%201 = or i32 %2, %1
%202 = icmp eq i32 %201, 0
br i1 %202, label %205, label %203
203: ; preds = %198
%204 = getelementptr inbounds i8, i8* %199, i64 1
store i8 46, i8* %199
br label %205
205: ; preds = %198, %203
%206 = phi i8* [ %204, %203 ], [ %199, %198 ]
%207 = fcmp une double %15, 0.000000e+00
br i1 %207, label %208, label %232
208: ; preds = %205
br i1 %200, label %224, label %209
209: ; preds = %208, %209
%210 = phi i32 [ %220, %209 ], [ %1, %208 ]
%211 = phi i8* [ %219, %209 ], [ %206, %208 ]
%212 = phi double [ %214, %209 ], [ %15, %208 ]
%213 = fmul double %212, 1.000000e+01
%214 = call double @modf(double %213, double* %11)
%215 = load double, double* %11
%216 = fptosi double %215 to i32
%217 = trunc i32 %216 to i8
%218 = add i8 %217, 48
%219 = getelementptr inbounds i8, i8* %211, i64 1
store i8 %218, i8* %211
%220 = add nsw i32 %210, -1
%221 = icmp ne i32 %220, 0
%222 = fcmp une double %214, 0.000000e+00
%223 = select i1 %221, i1 %222, i1 false
br i1 %223, label %209, label %224
224: ; preds = %209, %208
%225 = phi i32 [ 0, %208 ], [ %220, %209 ]
%226 = phi i8* [ %206, %208 ], [ %219, %209 ]
%227 = phi double [ %15, %208 ], [ %214, %209 ]
%228 = fcmp une double %227, 0.000000e+00
br i1 %228, label %229, label %232
229: ; preds = %224
%230 = getelementptr inbounds i8, i8* %226, i64 -1
%231 = tail call i8* @cvtround(double %227, i32* null, i8* %16, i8* %230, i8 zeroext 48, i8* %3)
br label %232
232: ; preds = %224, %229, %205
%233 = phi i8* [ %231, %229 ], [ %16, %224 ], [ %16, %205 ]
%234 = phi i32 [ %225, %229 ], [ %225, %224 ], [ %1, %205 ]
%235 = phi i8* [ %226, %229 ], [ %226, %224 ], [ %206, %205 ]
%236 = icmp eq i32 %234, 0
br i1 %236, label %614, label %237
237: ; preds = %232
%238 = zext i32 %234 to i64
%239 = add i32 %234, -1
%240 = zext i32 %239 to i64
%241 = add nuw nsw i64 %240, 1
%242 = getelementptr i8, i8* %235, i64 %241
br label %614
243: ; preds = %42, %42, %394
%244 = phi i8 [ %396, %394 ], [ %4, %42 ], [ %4, %42 ]
%245 = phi i32 [ %395, %394 ], [ %1, %42 ], [ %1, %42 ]
%246 = phi i1 [ false, %394 ], [ true, %42 ], [ true, %42 ]
%247 = icmp eq i32 %43, 0
br i1 %247, label %286, label %248
248: ; preds = %243
%249 = load i8, i8* %45
%250 = getelementptr inbounds i8, i8* %5, i64 2
store i8 %249, i8* %16
%251 = or i32 %245, %2
%252 = icmp eq i32 %251, 0
br i1 %252, label %255, label %253
253: ; preds = %248
%254 = getelementptr inbounds i8, i8* %5, i64 3
store i8 46, i8* %250
br label %255
255: ; preds = %248, %253
%256 = phi i8* [ %254, %253 ], [ %250, %248 ]
%257 = icmp eq i32 %245, 0
br i1 %257, label %269, label %258
258: ; preds = %255, %264
%259 = phi i8* [ %266, %264 ], [ %256, %255 ]
%260 = phi i8* [ %262, %264 ], [ %45, %255 ]
%261 = phi i32 [ %267, %264 ], [ %245, %255 ]
%262 = getelementptr inbounds i8, i8* %260, i64 1
%263 = icmp ult i8* %262, %6
br i1 %263, label %264, label %279
264: ; preds = %258
%265 = load i8, i8* %262
%266 = getelementptr inbounds i8, i8* %259, i64 1
store i8 %265, i8* %259
%267 = add nsw i32 %261, -1
%268 = icmp eq i32 %267, 0
br i1 %268, label %269, label %258
269: ; preds = %264, %255
%270 = phi i8* [ %45, %255 ], [ %262, %264 ]
%271 = phi i8* [ %256, %255 ], [ %266, %264 ]
%272 = getelementptr inbounds i8, i8* %270, i64 1
%273 = icmp ult i8* %272, %6
br i1 %273, label %274, label %279
274: ; preds = %269
%275 = getelementptr inbounds i8, i8* %271, i64 -1
%276 = load i8, i8* %272
%277 = call i8* @cvtround(double 0.000000e+00, i32* %9, i8* %16, i8* %275, i8 zeroext %276, i8* %3)
%278 = load i32, i32* %9
br label %279
279: ; preds = %258, %274, %269
%280 = phi i32 [ %278, %274 ], [ %43, %269 ], [ %43, %258 ]
%281 = phi i32 [ 0, %274 ], [ 0, %269 ], [ %261, %258 ]
%282 = phi i8* [ %271, %274 ], [ %271, %269 ], [ %259, %258 ]
%283 = phi i8* [ %277, %274 ], [ %16, %269 ], [ %16, %258 ]
%284 = phi double [ 0.000000e+00, %274 ], [ %15, %269 ], [ %15, %258 ]
%285 = add nsw i32 %280, -1
store i32 %285, i32* %9
br label %318
286: ; preds = %243
%287 = fcmp une double %15, 0.000000e+00
br i1 %287, label %288, label %312
288: ; preds = %286
store i32 -1, i32* %9
%289 = fmul double %15, 1.000000e+01
%290 = call double @modf(double %289, double* %11)
%291 = load double, double* %11
%292 = fcmp une double %291, 0.000000e+00
br i1 %292, label %301, label %293
293: ; preds = %288, %293
%294 = phi i32 [ %296, %293 ], [ -1, %288 ]
%295 = phi double [ %298, %293 ], [ %290, %288 ]
%296 = add nsw i32 %294, -1
store i32 %296, i32* %9
%297 = fmul double %295, 1.000000e+01
%298 = call double @modf(double %297, double* %11)
%299 = load double, double* %11
%300 = fcmp une double %299, 0.000000e+00
br i1 %300, label %301, label %293
301: ; preds = %293, %288
%302 = phi double [ %290, %288 ], [ %298, %293 ]
%303 = phi double [ %291, %288 ], [ %299, %293 ]
%304 = fptosi double %303 to i32
%305 = trunc i32 %304 to i8
%306 = add i8 %305, 48
%307 = getelementptr inbounds i8, i8* %5, i64 2
store i8 %306, i8* %16
%308 = or i32 %245, %2
%309 = icmp eq i32 %308, 0
br i1 %309, label %318, label %310
310: ; preds = %301
%311 = getelementptr inbounds i8, i8* %5, i64 3
store i8 46, i8* %307
br label %318
312: ; preds = %286
%313 = getelementptr inbounds i8, i8* %5, i64 2
store i8 48, i8* %16
%314 = or i32 %245, %2
%315 = icmp eq i32 %314, 0
br i1 %315, label %318, label %316
316: ; preds = %312
%317 = getelementptr inbounds i8, i8* %5, i64 3
store i8 46, i8* %313
br label %318
318: ; preds = %301, %310, %312, %316, %279
%319 = phi i8* [ %283, %279 ], [ %16, %310 ], [ %16, %301 ], [ %16, %316 ], [ %16, %312 ]
%320 = phi i32 [ %281, %279 ], [ %245, %310 ], [ 0, %301 ], [ %245, %316 ], [ 0, %312 ]
%321 = phi i8* [ %282, %279 ], [ %311, %310 ], [ %307, %301 ], [ %317, %316 ], [ %313, %312 ]
%322 = phi double [ %284, %279 ], [ %302, %310 ], [ %302, %301 ], [ %15, %316 ], [ %15, %312 ]
%323 = fcmp une double %322, 0.000000e+00
br i1 %323, label %324, label %349
324: ; preds = %318
%325 = icmp eq i32 %320, 0
br i1 %325, label %341, label %326
326: ; preds = %324, %326
%327 = phi i32 [ %337, %326 ], [ %320, %324 ]
%328 = phi i8* [ %336, %326 ], [ %321, %324 ]
%329 = phi double [ %331, %326 ], [ %322, %324 ]
%330 = fmul double %329, 1.000000e+01
%331 = call double @modf(double %330, double* %11)
%332 = load double, double* %11
%333 = fptosi double %332 to i32
%334 = trunc i32 %333 to i8
%335 = add i8 %334, 48
%336 = getelementptr inbounds i8, i8* %328, i64 1
store i8 %335, i8* %328
%337 = add nsw i32 %327, -1
%338 = icmp ne i32 %337, 0
%339 = fcmp une double %331, 0.000000e+00
%340 = select i1 %338, i1 %339, i1 false
br i1 %340, label %326, label %341
341: ; preds = %326, %324
%342 = phi i32 [ 0, %324 ], [ %337, %326 ]
%343 = phi i8* [ %321, %324 ], [ %336, %326 ]
%344 = phi double [ %322, %324 ], [ %331, %326 ]
%345 = fcmp une double %344, 0.000000e+00
br i1 %345, label %346, label %349
346: ; preds = %341
%347 = getelementptr inbounds i8, i8* %343, i64 -1
%348 = call i8* @cvtround(double %344, i32* %9, i8* %319, i8* %347, i8 zeroext 48, i8* %3)
br label %349
349: ; preds = %341, %346, %318
%350 = phi i8* [ %348, %346 ], [ %319, %341 ], [ %319, %318 ]
%351 = phi i32 [ %342, %346 ], [ %342, %341 ], [ %320, %318 ]
%352 = phi i8* [ %343, %346 ], [ %343, %341 ], [ %321, %318 ]
%353 = icmp eq i32 %351, 0
br i1 %353, label %360, label %354
354: ; preds = %349
%355 = zext i32 %351 to i64
%356 = add i32 %351, -1
%357 = zext i32 %356 to i64
%358 = add nuw nsw i64 %357, 1
%359 = getelementptr i8, i8* %352, i64 %358
br label %360
360: ; preds = %354, %349
%361 = phi i8* [ %352, %349 ], [ %359, %354 ]
%362 = icmp ne i32 %2, 0
%363 = or i1 %362, %246
br i1 %363, label %380, label %364
364: ; preds = %360, %369
%365 = phi i8* [ %370, %369 ], [ %361, %360 ]
%366 = icmp ugt i8* %365, %350
br i1 %366, label %369, label %367
367: ; preds = %364
%368 = load i8, i8* %365
br label %373
369: ; preds = %364
%370 = getelementptr inbounds i8, i8* %365, i64 -1
%371 = load i8, i8* %370
%372 = icmp eq i8 %371, 48
br i1 %372, label %364, label %373
373: ; preds = %369, %367
%374 = phi i8 [ %368, %367 ], [ %371, %369 ]
%375 = phi i8* [ %365, %367 ], [ %370, %369 ]
%376 = icmp eq i8 %374, 46
%377 = sext i1 %376 to i64
%378 = getelementptr i8, i8* %375, i64 %377
%379 = getelementptr inbounds i8, i8* %378, i64 1
br label %380
380: ; preds = %373, %360
%381 = phi i8* [ %361, %360 ], [ %379, %373 ]
%382 = load i32, i32* %9
%383 = call i8* @exponent(i8* %381, i32 %382, i8 zeroext %244)
br label %614
384: ; preds = %42, %42
%385 = icmp eq i32 %1, 0
%386 = select i1 %385, i32 1, i32 %1
%387 = icmp sgt i32 %43, %386
br i1 %387, label %394, label %388
388: ; preds = %384
%389 = icmp eq i32 %43, 0
%390 = fcmp une double %15, 0.000000e+00
%391 = select i1 %389, i1 %390, i1 false
%392 = fcmp olt double %15, 1.000000e-04
%393 = select i1 %391, i1 %392, i1 false
br i1 %393, label %394, label %397
394: ; preds = %388, %384
%395 = add nsw i32 %386, -1
%396 = add nsw i8 %4, -2
br label %243
397: ; preds = %388
br i1 %389, label %547, label %398
398: ; preds = %397
%399 = getelementptr i8, i8* %46, i64 1
%400 = icmp ult i8* %399, %6
br i1 %400, label %401, label %553
401: ; preds = %398
%402 = trunc i64 %47 to i32
%403 = add i32 %386, %402
%404 = trunc i64 %8 to i32
%405 = sub i64 %8, %47
%406 = getelementptr i8, i8* %46, i64 %405
%407 = xor i64 %47, -1
%408 = add i64 %407, %8
%409 = icmp ult i64 %408, 32
br i1 %409, label %496, label %410
410: ; preds = %401
%411 = getelementptr i8, i8* %5, i64 %405
%412 = icmp ult i8* %16, %406
%413 = icmp ult i8* %399, %411
%414 = and i1 %412, %413
br i1 %414, label %496, label %415
415: ; preds = %410
%416 = and i64 %408, -32
%417 = getelementptr i8, i8* %399, i64 %416
%418 = getelementptr i8, i8* %16, i64 %416
%419 = add i64 %416, -32
%420 = lshr exact i64 %419, 5
%421 = add nuw nsw i64 %420, 1
%422 = and i64 %421, 3
%423 = icmp ult i64 %419, 96
br i1 %423, label %475, label %424
424: ; preds = %415
%425 = and i64 %421, 1152921504606846972
br label %426
426: ; preds = %426, %424
%427 = phi i64 [ 0, %424 ], [ %472, %426 ]
%428 = phi i64 [ 0, %424 ], [ %473, %426 ]
%429 = getelementptr i8, i8* %399, i64 %427
%430 = getelementptr i8, i8* %16, i64 %427
%431 = bitcast i8* %429 to <16 x i8>*
%432 = load <16 x i8>, <16 x i8>* %431
%433 = getelementptr i8, i8* %429, i64 16
%434 = bitcast i8* %433 to <16 x i8>*
%435 = load <16 x i8>, <16 x i8>* %434
%436 = bitcast i8* %430 to <16 x i8>*
store <16 x i8> %432, <16 x i8>* %436
%437 = getelementptr i8, i8* %430, i64 16
%438 = bitcast i8* %437 to <16 x i8>*
store <16 x i8> %435, <16 x i8>* %438
%439 = or i64 %427, 32
%440 = getelementptr i8, i8* %399, i64 %439
%441 = getelementptr i8, i8* %16, i64 %439
%442 = bitcast i8* %440 to <16 x i8>*
%443 = load <16 x i8>, <16 x i8>* %442
%444 = getelementptr i8, i8* %440, i64 16
%445 = bitcast i8* %444 to <16 x i8>*
%446 = load <16 x i8>, <16 x i8>* %445
%447 = bitcast i8* %441 to <16 x i8>*
store <16 x i8> %443, <16 x i8>* %447
%448 = getelementptr i8, i8* %441, i64 16
%449 = bitcast i8* %448 to <16 x i8>*
store <16 x i8> %446, <16 x i8>* %449
%450 = or i64 %427, 64
%451 = getelementptr i8, i8* %399, i64 %450
%452 = getelementptr i8, i8* %16, i64 %450
%453 = bitcast i8* %451 to <16 x i8>*
%454 = load <16 x i8>, <16 x i8>* %453
%455 = getelementptr i8, i8* %451, i64 16
%456 = bitcast i8* %455 to <16 x i8>*
%457 = load <16 x i8>, <16 x i8>* %456
%458 = bitcast i8* %452 to <16 x i8>*
store <16 x i8> %454, <16 x i8>* %458
%459 = getelementptr i8, i8* %452, i64 16
%460 = bitcast i8* %459 to <16 x i8>*
store <16 x i8> %457, <16 x i8>* %460
%461 = or i64 %427, 96
%462 = getelementptr i8, i8* %399, i64 %461
%463 = getelementptr i8, i8* %16, i64 %461
%464 = bitcast i8* %462 to <16 x i8>*
%465 = load <16 x i8>, <16 x i8>* %464
%466 = getelementptr i8, i8* %462, i64 16
%467 = bitcast i8* %466 to <16 x i8>*
%468 = load <16 x i8>, <16 x i8>* %467
%469 = bitcast i8* %463 to <16 x i8>*
store <16 x i8> %465, <16 x i8>* %469
%470 = getelementptr i8, i8* %463, i64 16
%471 = bitcast i8* %470 to <16 x i8>*
store <16 x i8> %468, <16 x i8>* %471
%472 = add nuw i64 %427, 128
%473 = add i64 %428, 4
%474 = icmp eq i64 %473, %425
br i1 %474, label %475, label %426
475: ; preds = %426, %415
%476 = phi i64 [ 0, %415 ], [ %472, %426 ]
%477 = icmp eq i64 %422, 0
br i1 %477, label %494, label %478
478: ; preds = %475, %478
%479 = phi i64 [ %491, %478 ], [ %476, %475 ]
%480 = phi i64 [ %492, %478 ], [ 0, %475 ]
%481 = getelementptr i8, i8* %399, i64 %479
%482 = getelementptr i8, i8* %16, i64 %479
%483 = bitcast i8* %481 to <16 x i8>*
%484 = load <16 x i8>, <16 x i8>* %483
%485 = getelementptr i8, i8* %481, i64 16
%486 = bitcast i8* %485 to <16 x i8>*
%487 = load <16 x i8>, <16 x i8>* %486
%488 = bitcast i8* %482 to <16 x i8>*
store <16 x i8> %484, <16 x i8>* %488
%489 = getelementptr i8, i8* %482, i64 16
%490 = bitcast i8* %489 to <16 x i8>*
store <16 x i8> %487, <16 x i8>* %490
%491 = add nuw i64 %479, 32
%492 = add i64 %480, 1
%493 = icmp eq i64 %492, %422
br i1 %493, label %494, label %478
494: ; preds = %478, %475
%495 = icmp eq i64 %408, %416
br i1 %495, label %549, label %496
496: ; preds = %410, %401, %494
%497 = phi i8* [ %399, %410 ], [ %399, %401 ], [ %417, %494 ]
%498 = phi i8* [ %16, %410 ], [ %16, %401 ], [ %418, %494 ]
%499 = ptrtoint i8* %497 to i64
%500 = sub i64 %8, %499
%501 = xor i64 %499, -1
%502 = add i64 %501, %8
%503 = and i64 %500, 7
%504 = icmp eq i64 %503, 0
br i1 %504, label %514, label %505
505: ; preds = %496, %505
%506 = phi i8* [ %511, %505 ], [ %497, %496 ]
%507 = phi i8* [ %510, %505 ], [ %498, %496 ]
%508 = phi i64 [ %512, %505 ], [ 0, %496 ]
%509 = load i8, i8* %506
%510 = getelementptr inbounds i8, i8* %507, i64 1
store i8 %509, i8* %507
%511 = getelementptr inbounds i8, i8* %506, i64 1
%512 = add i64 %508, 1
%513 = icmp eq i64 %512, %503
br i1 %513, label %514, label %505
514: ; preds = %505, %496
%515 = phi i8* [ undef, %496 ], [ %510, %505 ]
%516 = phi i8* [ %497, %496 ], [ %511, %505 ]
%517 = phi i8* [ %498, %496 ], [ %510, %505 ]
%518 = icmp ult i64 %502, 7
br i1 %518, label %549, label %519
519: ; preds = %514, %519
%520 = phi i8* [ %545, %519 ], [ %516, %514 ]
%521 = phi i8* [ %544, %519 ], [ %517, %514 ]
%522 = load i8, i8* %520
%523 = getelementptr inbounds i8, i8* %521, i64 1
store i8 %522, i8* %521
%524 = getelementptr inbounds i8, i8* %520, i64 1
%525 = load i8, i8* %524
%526 = getelementptr inbounds i8, i8* %521, i64 2
store i8 %525, i8* %523
%527 = getelementptr inbounds i8, i8* %520, i64 2
%528 = load i8, i8* %527
%529 = getelementptr inbounds i8, i8* %521, i64 3
store i8 %528, i8* %526
%530 = getelementptr inbounds i8, i8* %520, i64 3
%531 = load i8, i8* %530
%532 = getelementptr inbounds i8, i8* %521, i64 4
store i8 %531, i8* %529
%533 = getelementptr inbounds i8, i8* %520, i64 4
%534 = load i8, i8* %533
%535 = getelementptr inbounds i8, i8* %521, i64 5
store i8 %534, i8* %532
%536 = getelementptr inbounds i8, i8* %520, i64 5
%537 = load i8, i8* %536
%538 = getelementptr inbounds i8, i8* %521, i64 6
store i8 %537, i8* %535
%539 = getelementptr inbounds i8, i8* %520, i64 6
%540 = load i8, i8* %539
%541 = getelementptr inbounds i8, i8* %521, i64 7
store i8 %540, i8* %538
%542 = getelementptr inbounds i8, i8* %520, i64 7
%543 = load i8, i8* %542
%544 = getelementptr inbounds i8, i8* %521, i64 8
store i8 %543, i8* %541
%545 = getelementptr inbounds i8, i8* %520, i64 8
%546 = icmp eq i8* %545, %406
br i1 %546, label %549, label %519
547: ; preds = %397
%548 = getelementptr inbounds i8, i8* %5, i64 2
store i8 48, i8* %16
br label %553
549: ; preds = %514, %519, %494
%550 = phi i8* [ %418, %494 ], [ %515, %514 ], [ %544, %519 ]
%551 = add i32 %403, 1
%552 = sub i32 %551, %404
br label %553
553: ; preds = %549, %398, %547
%554 = phi i32 [ %386, %547 ], [ %386, %398 ], [ %552, %549 ]
%555 = phi i8* [ %548, %547 ], [ %16, %398 ], [ %550, %549 ]
%556 = icmp eq i32 %2, 0
%557 = or i32 %554, %2
%558 = icmp eq i32 %557, 0
br i1 %558, label %561, label %559
559: ; preds = %553
%560 = getelementptr inbounds i8, i8* %555, i64 1
store i8 46, i8* %555
br label %561
561: ; preds = %553, %559
%562 = phi i8* [ %560, %559 ], [ %555, %553 ]
%563 = icmp ne i32 %554, 0
%564 = select i1 %563, i1 %390, i1 false
br i1 %564, label %565, label %580
565: ; preds = %561, %565
%566 = phi double [ %570, %565 ], [ %15, %561 ]
%567 = phi i8* [ %575, %565 ], [ %562, %561 ]
%568 = phi i32 [ %576, %565 ], [ %554, %561 ]
%569 = fmul double %566, 1.000000e+01
%570 = call double @modf(double %569, double* %11)
%571 = load double, double* %11
%572 = fptosi double %571 to i32
%573 = trunc i32 %572 to i8
%574 = add i8 %573, 48
%575 = getelementptr inbounds i8, i8* %567, i64 1
store i8 %574, i8* %567
%576 = add nsw i32 %568, -1
%577 = icmp ne i32 %576, 0
%578 = fcmp une double %570, 0.000000e+00
%579 = select i1 %577, i1 %578, i1 false
br i1 %579, label %565, label %580
580: ; preds = %565, %561
%581 = phi i32 [ %554, %561 ], [ %576, %565 ]
%582 = phi i8* [ %562, %561 ], [ %575, %565 ]
%583 = phi double [ %15, %561 ], [ %570, %565 ]
%584 = phi i1 [ %390, %561 ], [ %578, %565 ]
br i1 %584, label %585, label %588
585: ; preds = %580
%586 = getelementptr inbounds i8, i8* %582, i64 -1
%587 = tail call i8* @cvtround(double %583, i32* null, i8* %16, i8* %586, i8 zeroext 48, i8* %3)
br label %588
588: ; preds = %585, %580
%589 = phi i8* [ %587, %585 ], [ %16, %580 ]
br i1 %556, label %598, label %590
590: ; preds = %588
%591 = icmp eq i32 %581, 0
br i1 %591, label %614, label %592
592: ; preds = %590
%593 = zext i32 %581 to i64
%594 = add i32 %581, -1
%595 = zext i32 %594 to i64
%596 = add nuw nsw i64 %595, 1
%597 = getelementptr i8, i8* %582, i64 %596
br label %614
598: ; preds = %588
br i1 %558, label %614, label %599
599: ; preds = %598, %604
%600 = phi i8* [ %605, %604 ], [ %582, %598 ]
%601 = icmp ugt i8* %600, %589
br i1 %601, label %604, label %602
602: ; preds = %599
%603 = load i8, i8* %600
br label %608
604: ; preds = %599
%605 = getelementptr inbounds i8, i8* %600, i64 -1
%606 = load i8, i8* %605
%607 = icmp eq i8 %606, 48
br i1 %607, label %599, label %608
608: ; preds = %604, %602
%609 = phi i8 [ %603, %602 ], [ %606, %604 ]
%610 = phi i8* [ %600, %602 ], [ %605, %604 ]
%611 = icmp ne i8 %609, 46
%612 = zext i1 %611 to i64
%613 = getelementptr i8, i8* %610, i64 %612
br label %614
614: ; preds = %592, %237, %590, %232, %608, %598, %42, %380
%615 = phi i8* [ %16, %42 ], [ %350, %380 ], [ %589, %598 ], [ %589, %608 ], [ %233, %232 ], [ %589, %590 ], [ %233, %237 ], [ %589, %592 ]
%616 = phi i8* [ %16, %42 ], [ %383, %380 ], [ %582, %598 ], [ %613, %608 ], [ %235, %232 ], [ %582, %590 ], [ %242, %237 ], [ %597, %592 ]
%617 = ptrtoint i8* %616 to i64
%618 = ptrtoint i8* %615 to i64
%619 = sub i64 %617, %618
%620 = trunc i64 %619 to i32
ret i32 %620
}