#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;
  for (p = endp - 1; integer; ++expcnt) {
    tmp = modf(integer / 10, &integer);
    *p-- = (int)((tmp + .01) * 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    $0x80,%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
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11bf <cvt+0x8f>
jp     11bf <cvt+0x8f>
jmp    121f <cvt+0xef>
movsd  -0x60(%rbp),%xmm0
movsd  0xe3c(%rip),%xmm1
divsd  %xmm1,%xmm0
lea    -0x60(%rbp),%rdi
call   1040 <modf@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  0xe2a(%rip),%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  0xe15(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%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,-0x70(%rbp)
sub    $0x22,%eax
ja     1a59 <cvt+0x929>
mov    -0x70(%rbp),%rax
lea    0xdd8(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
cmpl   $0x0,-0x50(%rbp)
je     1294 <cvt+0x164>
jmp    1258 <cvt+0x128>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
cmp    -0x30(%rbp),%rax
jae    128f <cvt+0x15f>
jmp    1273 <cvt+0x143>
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    1258 <cvt+0x128>
jmp    12a6 <cvt+0x176>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movb   $0x30,(%rax)
cmpl   $0x0,-0xc(%rbp)
jne    12ba <cvt+0x18a>
cmpl   $0x0,-0x10(%rbp)
je     12cc <cvt+0x19c>
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    12e9 <cvt+0x1b9>
jp     12e9 <cvt+0x1b9>
jmp    13b5 <cvt+0x285>
cmpl   $0x0,-0xc(%rbp)
je     136c <cvt+0x23c>
jmp    12f8 <cvt+0x1c8>
movsd  0xd08(%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,-0x71(%rbp)
je     135c <cvt+0x22c>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
setne  %al
setp   %cl
or     %cl,%al
mov    %al,-0x71(%rbp)
mov    -0x71(%rbp),%al
test   $0x1,%al
jne    12f8 <cvt+0x1c8>
jmp    136c <cvt+0x23c>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1389 <cvt+0x259>
jp     1389 <cvt+0x259>
jmp    13b0 <cvt+0x280>
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    13b5 <cvt+0x285>
jmp    13ba <cvt+0x28a>
mov    -0xc(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0xc(%rbp)
cmp    $0x0,%eax
je     13ea <cvt+0x2ba>
jmp    13d3 <cvt+0x2a3>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movb   $0x30,(%rax)
jmp    13ba <cvt+0x28a>
jmp    1a59 <cvt+0x929>
jmp    13f4 <cvt+0x2c4>
cmpl   $0x0,-0x50(%rbp)
je     1505 <cvt+0x3d5>
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    1435 <cvt+0x305>
cmpl   $0x0,-0x10(%rbp)
je     1447 <cvt+0x317>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movb   $0x2e,(%rax)
jmp    144c <cvt+0x31c>
xor    %eax,%eax
cmpl   $0x0,-0xc(%rbp)
mov    %al,-0x72(%rbp)
je     1471 <cvt+0x341>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
cmp    -0x30(%rbp),%rax
setb   %al
mov    %al,-0x72(%rbp)
mov    -0x72(%rbp),%al
test   $0x1,%al
jne    1481 <cvt+0x351>
jmp    14a6 <cvt+0x376>
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    144c <cvt+0x31c>
cmpl   $0x0,-0xc(%rbp)
jne    14f7 <cvt+0x3c7>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
cmp    -0x30(%rbp),%rax
jae    14f7 <cvt+0x3c7>
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    1601 <cvt+0x4d1>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1522 <cvt+0x3f2>
jp     1522 <cvt+0x3f2>
jmp    15bf <cvt+0x48f>
movl   $0xffffffff,-0x50(%rbp)
movsd  0xad7(%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    1561 <cvt+0x431>
jp     1561 <cvt+0x431>
jmp    1566 <cvt+0x436>
jmp    1579 <cvt+0x449>
jmp    156b <cvt+0x43b>
mov    -0x50(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x50(%rbp)
jmp    1529 <cvt+0x3f9>
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    15a8 <cvt+0x478>
cmpl   $0x0,-0x10(%rbp)
je     15ba <cvt+0x48a>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movb   $0x2e,(%rax)
jmp    15fc <cvt+0x4cc>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movb   $0x30,(%rax)
cmpl   $0x0,-0xc(%rbp)
jne    15e5 <cvt+0x4b5>
cmpl   $0x0,-0x10(%rbp)
je     15f7 <cvt+0x4c7>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movb   $0x2e,(%rax)
jmp    15fc <cvt+0x4cc>
jmp    1601 <cvt+0x4d1>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    161e <cvt+0x4ee>
jp     161e <cvt+0x4ee>
jmp    16ea <cvt+0x5ba>
cmpl   $0x0,-0xc(%rbp)
je     16a1 <cvt+0x571>
jmp    162d <cvt+0x4fd>
movsd  0x9d3(%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,-0x73(%rbp)
je     1691 <cvt+0x561>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
setne  %al
setp   %cl
or     %cl,%al
mov    %al,-0x73(%rbp)
mov    -0x73(%rbp),%al
test   $0x1,%al
jne    162d <cvt+0x4fd>
jmp    16a1 <cvt+0x571>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    16be <cvt+0x58e>
jp     16be <cvt+0x58e>
jmp    16e5 <cvt+0x5b5>
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    16ea <cvt+0x5ba>
jmp    16ef <cvt+0x5bf>
mov    -0xc(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0xc(%rbp)
cmp    $0x0,%eax
je     171f <cvt+0x5ef>
jmp    1708 <cvt+0x5d8>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movb   $0x30,(%rax)
jmp    16ef <cvt+0x5bf>
cmpl   $0x0,-0x54(%rbp)
je     17a4 <cvt+0x674>
cmpl   $0x0,-0x10(%rbp)
jne    17a4 <cvt+0x674>
jmp    1738 <cvt+0x608>
mov    -0x40(%rbp),%rcx
xor    %eax,%eax
cmp    -0x28(%rbp),%rcx
mov    %al,-0x74(%rbp)
jbe    1767 <cvt+0x637>
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,-0x74(%rbp)
mov    -0x74(%rbp),%al
test   $0x1,%al
jne    1777 <cvt+0x647>
jmp    177c <cvt+0x64c>
jmp    1738 <cvt+0x608>
mov    -0x40(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x2e,%eax
jne    1798 <cvt+0x668>
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    1a59 <cvt+0x929>
cmpl   $0x0,-0xc(%rbp)
jne    17d0 <cvt+0x6a0>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1816 <cvt+0x6e6>
cmpl   $0x0,-0x50(%rbp)
jne    1835 <cvt+0x705>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1803 <cvt+0x6d3>
jp     1803 <cvt+0x6d3>
jmp    1835 <cvt+0x705>
movsd  0x7f5(%rip),%xmm0
ucomisd -0x48(%rbp),%xmm0
jbe    1835 <cvt+0x705>
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    13f4 <cvt+0x2c4>
cmpl   $0x0,-0x50(%rbp)
je     1889 <cvt+0x759>
jmp    1844 <cvt+0x714>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
cmp    -0x30(%rbp),%rax
jae    1884 <cvt+0x754>
jmp    185f <cvt+0x72f>
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    1844 <cvt+0x714>
jmp    189b <cvt+0x76b>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movb   $0x30,(%rax)
cmpl   $0x0,-0xc(%rbp)
jne    18af <cvt+0x77f>
cmpl   $0x0,-0x10(%rbp)
je     18cd <cvt+0x79d>
movl   $0x1,-0x4c(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movb   $0x2e,(%rax)
jmp    18d4 <cvt+0x7a4>
movl   $0x0,-0x4c(%rbp)
jmp    18d9 <cvt+0x7a9>
xor    %eax,%eax
cmpl   $0x0,-0xc(%rbp)
mov    %al,-0x75(%rbp)
je     18ff <cvt+0x7cf>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
setne  %al
setp   %cl
or     %cl,%al
mov    %al,-0x75(%rbp)
mov    -0x75(%rbp),%al
test   $0x1,%al
jne    190f <cvt+0x7df>
jmp    1953 <cvt+0x823>
movsd  0x6f1(%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    18d9 <cvt+0x7a9>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1970 <cvt+0x840>
jp     1970 <cvt+0x840>
jmp    1997 <cvt+0x867>
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     19db <cvt+0x8ab>
jmp    19a6 <cvt+0x876>
mov    -0xc(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0xc(%rbp)
cmp    $0x0,%eax
je     19d6 <cvt+0x8a6>
jmp    19bf <cvt+0x88f>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movb   $0x30,(%rax)
jmp    19a6 <cvt+0x876>
jmp    1a54 <cvt+0x924>
cmpl   $0x0,-0x4c(%rbp)
je     1a4f <cvt+0x91f>
jmp    19ea <cvt+0x8ba>
mov    -0x40(%rbp),%rcx
xor    %eax,%eax
cmp    -0x28(%rbp),%rcx
mov    %al,-0x76(%rbp)
jbe    1a19 <cvt+0x8e9>
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,-0x76(%rbp)
mov    -0x76(%rbp),%al
test   $0x1,%al
jne    1a29 <cvt+0x8f9>
jmp    1a2e <cvt+0x8fe>
jmp    19ea <cvt+0x8ba>
mov    -0x40(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x2e,%eax
je     1a4a <cvt+0x91a>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1a4f <cvt+0x91f>
jmp    1a54 <cvt+0x924>
jmp    1a59 <cvt+0x929>
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cvt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %r9,%r14
mov    %r8,%rbx
mov    %rcx,0x28(%rsp)
mov    %rdx,0x20(%rsp)
mov    %esi,0xc(%rsp)
mov    %edi,%r15d
movl   $0x0,0x8(%rsp)
lea    0x30(%rsp),%rdi
call   1040 <modf@plt>
movapd %xmm0,%xmm2
movsd  0x30(%rsp),%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm1
jne    118d <cvt+0x4d>
jnp    120b <cvt+0xcb>
movsd  %xmm2,0x10(%rsp)
mov    $0x1,%ebp
xor    %r13d,%r13d
lea    0x30(%rsp),%r12
movsd  0xe58(%rip),%xmm0
divsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
mov    %r12,%rdi
call   1040 <modf@plt>
xorpd  %xmm2,%xmm2
movapd %xmm0,%xmm1
addsd  0xe40(%rip),%xmm1
mulsd  0xe30(%rip),%xmm1
cvttsd2si %xmm1,%eax
add    $0x30,%al
mov    %al,-0x1(%r14,%r13,1)
mov    %ebp,0x8(%rsp)
movsd  0x30(%rsp),%xmm1
add    $0xffffffffffffffff,%r13
add    $0x1,%rbp
ucomisd %xmm2,%xmm1
jne    11a0 <cvt+0x60>
jp     11a0 <cvt+0x60>
mov    %r13d,%edx
neg    %edx
add    %r14,%r13
mov    %r14,%rcx
sub    %rbp,%rcx
movsd  0x10(%rsp),%xmm2
jmp    1214 <cvt+0xd4>
lea    -0x1(%r14),%rcx
xor    %edx,%edx
mov    %r14,%r13
lea    0x1(%rbx),%rbp
movsd  %xmm0,0x18(%rsp)
mov    0x28(%rsp),%rax
add    $0xffffffbb,%eax
cmp    $0x22,%al
ja     159a <cvt+0x45a>
mov    $0x1,%sil
mov    %esi,0x10(%rsp)
movzbl %al,%eax
lea    0xde1(%rip),%rsi
movslq (%rsi,%rax,4),%rax
add    %rsi,%rax
mov    %rbp,%r12
jmp    *%rax
test   %r15d,%r15d
mov    $0x1,%r11d
cmovne %r15d,%r11d
cmp    %r11d,%edx
jg     1287 <cvt+0x147>
xorpd  %xmm0,%xmm0
test   %edx,%edx
jne    159f <cvt+0x45f>
ucomisd %xmm0,%xmm2
jne    1275 <cvt+0x135>
jnp    159f <cvt+0x45f>
movsd  0xd93(%rip),%xmm1
ucomisd %xmm2,%xmm1
jbe    159f <cvt+0x45f>
add    $0xffffffff,%r11d
mov    0x28(%rsp),%rax
add    $0xfe,%al
mov    %rax,0x28(%rsp)
movl   $0x0,0x10(%rsp)
mov    %r11d,%r15d
test   %edx,%edx
je     12d0 <cvt+0x190>
mov    0x0(%r13),%al
mov    %al,0x1(%rbx)
mov    %r15d,%eax
or     0xc(%rsp),%eax
je     13f8 <cvt+0x2b8>
movb   $0x2e,0x2(%rbx)
add    $0x3,%rbx
test   %r15d,%r15d
jne    1401 <cvt+0x2c1>
jmp    142e <cvt+0x2ee>
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm2
jne    12e0 <cvt+0x1a0>
jnp    1688 <cvt+0x548>
movl   $0xffffffff,0x8(%rsp)
ff
mulsd  0xd10(%rip),%xmm2
lea    0x18(%rsp),%rdi
movapd %xmm2,%xmm0
call   1040 <modf@plt>
movapd %xmm0,%xmm2
movsd  0x18(%rsp),%xmm0
ucomisd 0xd08(%rip),%xmm0
jne    1318 <cvt+0x1d8>
jnp    1736 <cvt+0x5f6>
mov    %rbp,%r12
mov    0x10(%rsp),%r13d
jmp    1781 <cvt+0x641>
test   %edx,%edx
je     16a6 <cvt+0x566>
lea    0x1(%rcx),%rax
mov    %rbp,%r12
cmp    %r14,%rax
jae    16b1 <cvt+0x571>
mov    %rcx,%rdx
not    %rdx
add    %r14,%rdx
cmp    $0x20,%rdx
jb     1367 <cvt+0x227>
cmp    %r14,%rbp
jae    1840 <cvt+0x700>
mov    %r14,%rsi
sub    %rcx,%rsi
add    %rbx,%rsi
cmp    %rsi,%rax
jae    1840 <cvt+0x700>
mov    %rbp,%r12
mov    %r14d,%edx
sub    %eax,%edx
mov    %rax,%rcx
not    %rcx
add    %r14,%rcx
and    $0x7,%rdx
je     1395 <cvt+0x255>
xchg   %ax,%ax
movzbl (%rax),%ebx
mov    %bl,(%r12)
add    $0x1,%r12
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1380 <cvt+0x240>
cmp    $0x7,%rcx
jb     16b1 <cvt+0x571>
nop
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    %r14,%rax
jne    13a0 <cvt+0x260>
jmp    16b1 <cvt+0x571>
add    $0x2,%rbx
test   %r15d,%r15d
je     142e <cvt+0x2ee>
add    $0x1,%r13
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %r14,%r13
jae    1464 <cvt+0x324>
movzbl 0x0(%r13),%eax
mov    %al,(%rbx)
add    $0x1,%rbx
add    $0x1,%r13
add    $0xffffffff,%r15d
jne    1410 <cvt+0x2d0>
add    $0xffffffffffffffff,%r13
add    $0x1,%r13
xor    %r15d,%r15d
cmp    %r14,%r13
jae    1464 <cvt+0x324>
lea    -0x1(%rbx),%rdx
movzbl 0x0(%r13),%ecx
lea    0x8(%rsp),%rdi
xorpd  %xmm0,%xmm0
mov    %rbp,%rsi
mov    0x20(%rsp),%r8
call   1030 <cvtround@plt>
xorpd  %xmm2,%xmm2
mov    %rax,%rbp
mov    0x8(%rsp),%edx
mov    0x10(%rsp),%r13d
add    $0xffffffff,%edx
mov    %edx,0x8(%rsp)
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm2
jne    1480 <cvt+0x340>
jnp    1505 <cvt+0x3c5>
mov    %rbp,%r12
test   %r15d,%r15d
je     14d0 <cvt+0x390>
lea    0x18(%rsp),%r14
nopl   (%rax)
mov    %r15d,%ebp
mulsd  0xb65(%rip),%xmm2
movapd %xmm2,%xmm0
mov    %r14,%rdi
call   1040 <modf@plt>
movapd %xmm0,%xmm2
cvttsd2si 0x18(%rsp),%eax
add    $0x30,%al
mov    %al,(%rbx)
add    $0x1,%rbx
lea    -0x1(%rbp),%r15d
cmp    $0x1,%ebp
je     14d3 <cvt+0x393>
ucomisd 0xb4e(%rip),%xmm2
jne    1490 <cvt+0x350>
jp     1490 <cvt+0x350>
jmp    14d3 <cvt+0x393>
xor    %r15d,%r15d
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm2
jne    14e3 <cvt+0x3a3>
jnp    158c <cvt+0x44c>
lea    -0x1(%rbx),%rdx
lea    0x8(%rsp),%rdi
movapd %xmm2,%xmm0
mov    %r12,%rsi
mov    $0x30,%ecx
mov    0x20(%rsp),%r8
call   1030 <cvtround@plt>
mov    %rax,%rbp
test   %r15d,%r15d
je     1525 <cvt+0x3e5>
mov    %r15d,%edx
mov    %rbx,%rdi
mov    $0x30,%esi
call   1050 <memset@plt>
add    $0xffffffff,%r15d
add    %r15,%rbx
add    $0x1,%rbx
cmpl   $0x0,0xc(%rsp)
setne  %al
or     %r13b,%al
jne    1563 <cvt+0x423>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %rbp,%rbx
jbe    1553 <cvt+0x413>
movzbl -0x1(%rbx),%eax
add    $0xffffffffffffffff,%rbx
cmp    $0x30,%al
je     1540 <cvt+0x400>
jmp    1555 <cvt+0x415>
mov    (%rbx),%al
xor    %ecx,%ecx
cmp    $0x2e,%al
sete   %cl
sub    %rcx,%rbx
add    $0x1,%rbx
mov    0x8(%rsp),%esi
movzbl 0x28(%rsp),%edx
mov    %rbx,%rdi
call   1060 <exponent@plt>
mov    %rax,%r12
sub    %ebp,%r12d
mov    %r12d,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r12,%rbp
test   %r15d,%r15d
jne    150a <cvt+0x3ca>
jmp    1525 <cvt+0x3e5>
mov    %rbp,%r12
jmp    1577 <cvt+0x437>
cmpneqsd %xmm2,%xmm0
movq   %xmm0,%rax
test   %edx,%edx
je     1817 <cvt+0x6d7>
lea    0x1(%rcx),%rdx
cmp    %r14,%rdx
jae    1838 <cvt+0x6f8>
add    %ecx,%r11d
mov    %rcx,%r9
not    %r9
add    %r14,%r9
cmp    $0x20,%r9
jb     15eb <cvt+0x4ab>
cmp    %r14,%rbp
jae    186b <cvt+0x72b>
mov    %r14,%rsi
sub    %rcx,%rsi
add    %rbx,%rsi
cmp    %rsi,%rdx
jae    186b <cvt+0x72b>
mov    %rbp,%r12
mov    %r14d,%esi
sub    %edx,%esi
mov    %rdx,%rcx
not    %rcx
add    %r14,%rcx
and    $0x7,%rsi
je     1625 <cvt+0x4e5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rdx),%ebx
mov    %bl,(%r12)
add    $0x1,%r12
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    1610 <cvt+0x4d0>
cmp    $0x7,%rcx
jb     1a01 <cvt+0x8c1>
nop
movzbl (%rdx),%ecx
mov    %cl,(%r12)
movzbl 0x1(%rdx),%ecx
mov    %cl,0x1(%r12)
movzbl 0x2(%rdx),%ecx
mov    %cl,0x2(%r12)
movzbl 0x3(%rdx),%ecx
mov    %cl,0x3(%r12)
movzbl 0x4(%rdx),%ecx
mov    %cl,0x4(%r12)
movzbl 0x5(%rdx),%ecx
mov    %cl,0x5(%r12)
movzbl 0x6(%rdx),%ecx
mov    %cl,0x6(%r12)
movzbl 0x7(%rdx),%ecx
mov    %cl,0x7(%r12)
add    $0x8,%r12
add    $0x8,%rdx
cmp    %r14,%rdx
jne    1630 <cvt+0x4f0>
jmp    1a01 <cvt+0x8c1>
movb   $0x30,0x1(%rbx)
mov    %r15d,%eax
or     0xc(%rsp),%eax
je     1827 <cvt+0x6e7>
movb   $0x2e,0x2(%rbx)
add    $0x3,%rbx
jmp    182e <cvt+0x6ee>
movb   $0x30,0x1(%rbx)
add    $0x2,%rbx
mov    %rbx,%r12
or     %r15d,0xc(%rsp)
je     16c1 <cvt+0x581>
movb   $0x2e,(%r12)
add    $0x1,%r12
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm2
jne    16d1 <cvt+0x591>
jnp    17e1 <cvt+0x6a1>
mov    %rbp,%r14
test   %r15d,%r15d
je     17b2 <cvt+0x672>
lea    0x18(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r15d,%ebp
mulsd  0x905(%rip),%xmm2
movapd %xmm2,%xmm0
mov    %rbx,%rdi
call   1040 <modf@plt>
movapd %xmm0,%xmm2
cvttsd2si 0x18(%rsp),%eax
add    $0x30,%al
mov    %al,(%r12)
add    $0x1,%r12
lea    -0x1(%rbp),%r15d
cmp    $0x1,%ebp
je     17b5 <cvt+0x675>
ucomisd 0x8e8(%rip),%xmm2
jne    16f0 <cvt+0x5b0>
jp     16f0 <cvt+0x5b0>
jmp    17b5 <cvt+0x675>
mov    %rbp,%r12
mov    $0xfffffffe,%ebp
lea    0x18(%rsp),%r14
mov    0x10(%rsp),%r13d
nopl   0x0(%rax,%rax,1)
mov    %ebp,0x8(%rsp)
mulsd  0x8a4(%rip),%xmm2
movapd %xmm2,%xmm0
mov    %r14,%rdi
call   1040 <modf@plt>
movapd %xmm0,%xmm2
movsd  0x18(%rsp),%xmm0
add    $0xffffffff,%ebp
ucomisd 0x89b(%rip),%xmm0
jne    1781 <cvt+0x641>
jnp    1750 <cvt+0x610>
cvttsd2si %xmm0,%eax
add    $0x30,%al
mov    %al,0x1(%rbx)
mov    %r15d,%eax
or     0xc(%rsp),%eax
je     17a3 <cvt+0x663>
movb   $0x2e,0x2(%rbx)
add    $0x3,%rbx
mov    %r12,%rbp
jmp    1470 <cvt+0x330>
add    $0x2,%rbx
xor    %r15d,%r15d
mov    %r12,%rbp
jmp    1470 <cvt+0x330>
xor    %r15d,%r15d
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm2
jne    17c1 <cvt+0x681>
jnp    180a <cvt+0x6ca>
lea    -0x1(%r12),%rdx
movapd %xmm2,%xmm0
xor    %edi,%edi
mov    %r14,%rsi
mov    $0x30,%ecx
mov    0x20(%rsp),%r8
call   1030 <cvtround@plt>
mov    %rax,%rbp
test   %r15d,%r15d
je     1577 <cvt+0x437>
mov    %r15d,%edx
mov    %r12,%rdi
mov    $0x30,%esi
call   1050 <memset@plt>
add    $0xffffffff,%r15d
add    %r15,%r12
add    $0x1,%r12
jmp    1577 <cvt+0x437>
mov    %r14,%rbp
test   %r15d,%r15d
jne    17ea <cvt+0x6aa>
jmp    1577 <cvt+0x437>
movb   $0x30,0x1(%rbx)
add    $0x2,%rbx
mov    %rbx,%r12
jmp    1a08 <cvt+0x8c8>
add    $0x2,%rbx
xor    %r15d,%r15d
mov    0x10(%rsp),%r13d
jmp    1470 <cvt+0x330>
mov    %rbp,%r12
jmp    1a08 <cvt+0x8c8>
mov    %rbp,%r9
mov    %rdx,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rsi
mov    %rsi,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%ebp
and    $0x3,%ebp
cmp    $0x60,%rsi
jae    1899 <cvt+0x759>
xor    %esi,%esi
jmp    18fe <cvt+0x7be>
mov    %r9,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rsi
mov    %rsi,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r10d
and    $0x3,%r10d
cmp    $0x60,%rsi
jae    1957 <cvt+0x817>
xor    %esi,%esi
jmp    19bb <cvt+0x87b>
and    $0xfffffffffffffffc,%rdi
xor    %esi,%esi
nop
movups 0x1(%rcx,%rsi,1),%xmm0
movups 0x11(%rcx,%rsi,1),%xmm1
movups %xmm0,0x1(%rbx,%rsi,1)
movups %xmm1,0x11(%rbx,%rsi,1)
movups 0x21(%rcx,%rsi,1),%xmm0
movups 0x31(%rcx,%rsi,1),%xmm1
movups %xmm0,0x21(%rbx,%rsi,1)
movups %xmm1,0x31(%rbx,%rsi,1)
movups 0x41(%rcx,%rsi,1),%xmm0
movups 0x51(%rcx,%rsi,1),%xmm1
movups %xmm0,0x41(%rbx,%rsi,1)
movups %xmm1,0x51(%rbx,%rsi,1)
movupd 0x61(%rcx,%rsi,1),%xmm0
movupd 0x71(%rcx,%rsi,1),%xmm1
movupd %xmm0,0x61(%rbx,%rsi,1)
movupd %xmm1,0x71(%rbx,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rdi
jne    18a0 <cvt+0x760>
test   %rbp,%rbp
je     193f <cvt+0x7ff>
lea    (%rbx,%rsi,1),%rdi
add    $0x11,%rdi
add    %rsi,%rcx
add    $0x11,%rcx
shl    $0x5,%rbp
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rcx,%rsi,1),%xmm0
movupd (%rcx,%rsi,1),%xmm1
movupd %xmm0,-0x10(%rdi,%rsi,1)
movupd %xmm1,(%rdi,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rbp
jne    1920 <cvt+0x7e0>
mov    %r9,%rbp
lea    (%r9,%r8,1),%r12
cmp    %r8,%rdx
je     16b1 <cvt+0x571>
add    %r8,%rax
jmp    136a <cvt+0x22a>
and    $0xfffffffffffffffc,%rdi
xor    %esi,%esi
movups 0x1(%rcx,%rsi,1),%xmm0
movups 0x11(%rcx,%rsi,1),%xmm1
movups %xmm0,0x1(%rbx,%rsi,1)
movups %xmm1,0x11(%rbx,%rsi,1)
movups 0x21(%rcx,%rsi,1),%xmm0
movups 0x31(%rcx,%rsi,1),%xmm1
movups %xmm0,0x21(%rbx,%rsi,1)
movups %xmm1,0x31(%rbx,%rsi,1)
movups 0x41(%rcx,%rsi,1),%xmm0
movups 0x51(%rcx,%rsi,1),%xmm1
movups %xmm0,0x41(%rbx,%rsi,1)
movups %xmm1,0x51(%rbx,%rsi,1)
movupd 0x61(%rcx,%rsi,1),%xmm0
movupd 0x71(%rcx,%rsi,1),%xmm1
movupd %xmm0,0x61(%rbx,%rsi,1)
movupd %xmm1,0x71(%rbx,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rdi
jne    195d <cvt+0x81d>
test   %r10,%r10
je     19f4 <cvt+0x8b4>
lea    (%rbx,%rsi,1),%rdi
add    $0x11,%rdi
add    %rsi,%rcx
add    $0x11,%rcx
shl    $0x5,%r10
xor    %esi,%esi
movupd -0x10(%rcx,%rsi,1),%xmm0
movupd (%rcx,%rsi,1),%xmm1
movupd %xmm0,-0x10(%rdi,%rsi,1)
movupd %xmm1,(%rdi,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r10
jne    19d5 <cvt+0x895>
lea    (%r8,%rbp,1),%r12
cmp    %r8,%r9
jne    1b28 <cvt+0x9e8>
sub    %r14d,%r11d
add    $0x1,%r11d
and    $0x1,%eax
mov    %r11d,%r14d
or     0xc(%rsp),%r14d
je     1a1e <cvt+0x8de>
movb   $0x2e,(%r12)
add    $0x1,%r12
mov    %rbp,%r15
test   %r11d,%r11d
je     1a8d <cvt+0x94d>
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm2
jne    1a32 <cvt+0x8f2>
jnp    1a8d <cvt+0x94d>
lea    0x18(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
mov    %r11d,%ebp
mulsd  0x5b5(%rip),%xmm2
movapd %xmm2,%xmm0
mov    %rbx,%rdi
call   1040 <modf@plt>
xorpd  %xmm1,%xmm1
movapd %xmm0,%xmm2
cvttsd2si 0x18(%rsp),%eax
add    $0x30,%al
mov    %al,(%r12)
add    $0x1,%r12
lea    -0x1(%rbp),%r11d
cmpneqsd %xmm1,%xmm0
movq   %xmm0,%rax
and    $0x1,%eax
cmp    $0x1,%ebp
je     1a8d <cvt+0x94d>
ucomisd %xmm1,%xmm2
jne    1a40 <cvt+0x900>
jp     1a40 <cvt+0x900>
test   %al,%al
je     1ae9 <cvt+0x9a9>
lea    -0x1(%r12),%rdx
movapd %xmm2,%xmm0
xor    %edi,%edi
mov    %r15,%rsi
mov    $0x30,%ecx
mov    0x20(%rsp),%r8
mov    %r11,%rbx
call   1030 <cvtround@plt>
mov    %rbx,%r11
mov    %rax,%rbp
cmpl   $0x0,0xc(%rsp)
je     1af3 <cvt+0x9b3>
test   %r11d,%r11d
je     1577 <cvt+0x437>
mov    %r11d,%edx
mov    %r12,%rdi
mov    $0x30,%esi
mov    %r11,%rbx
call   1050 <memset@plt>
add    $0xffffffff,%ebx
add    %rbx,%r12
add    $0x1,%r12
jmp    1577 <cvt+0x437>
mov    %r15,%rbp
cmpl   $0x0,0xc(%rsp)
jne    1abe <cvt+0x97e>
test   %r14d,%r14d
je     1577 <cvt+0x437>
nopl   0x0(%rax)
cmp    %rbp,%r12
jbe    1b15 <cvt+0x9d5>
movzbl -0x1(%r12),%eax
add    $0xffffffffffffffff,%r12
cmp    $0x30,%al
je     1b00 <cvt+0x9c0>
jmp    1b19 <cvt+0x9d9>
mov    (%r12),%al
xor    %ecx,%ecx
cmp    $0x2e,%al
setne  %cl
add    %rcx,%r12
jmp    1577 <cvt+0x437>
add    %r8,%rdx
jmp    15ee <cvt+0x4ae>

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

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