int fp_display(int ch, double *lvd, char buff[], int flags, char **lvprefix,
               int *lvprecision, int *lvbefore_dot, int *lvafter_dot) {
  int len = 0;
  double d = *lvd;
  switch (ch) {
  case 'f': {
    int dx = fp_digits(buff, d);
    if (dx & 1)
      *lvprefix = "-";
    else
      *lvprefix = (flags & 02) ? "+" : (flags & 04) ? " " : "";
    dx = (dx & ~1) / 2;
    if (dx < 0) {
      dx = -dx;
      if (dx > *lvprecision + 1) {
        len = 0;
        buff[len++] = '0';
        buff[len++] = '.';
        *lvafter_dot = *lvprecision;
      } else {
        len = *lvprecision - dx + 2;
        if (len > 17 + 1) {
          *lvafter_dot = len - (17 + 2);
          len = 17 + 2;
        }
        if (fp_round(buff, len))
          dx--, len++;
        if (dx == 0) {
          buff[0] = buff[1];
          buff[1] = '.';
        } else if (dx == 1) {
          int w;
          for (w = len; w > 0; w--)
            buff[w + 1] = buff[w];
          len += 1;
          buff[0] = '0';
          buff[1] = '.';
        } else {
          int w;
          for (w = len; w > 0; w--)
            buff[w + 2] = buff[w];
          len += 2;
          buff[0] = '0';
          buff[1] = '.';
          buff[2] = '<';
          *lvbefore_dot = dx - 1;
        }
      }
      if (*lvafter_dot > 0)
        buff[len++] = '>';
    } else {
      len = dx + *lvprecision + 2;
      if (len > 17 + 1) {
        len = 17 + 2;
        if (fp_round(buff, len))
          dx++, len++;
        if (dx < len - 1) {
          {
            int w;
            for (w = 0; w <= dx; w++)
              buff[w] = buff[w + 1];
            buff[dx + 1] = '.';
          };
          *lvafter_dot = dx + *lvprecision - 17;
          if (*lvafter_dot != 0)
            buff[len++] = '>';
        } else {
          int w;
          for (w = 0; w < len - 1; w++)
            buff[w] = buff[w + 1];
          buff[len - 1] = '<';
          *lvbefore_dot = dx - len + 2;
          buff[len++] = '.';
          if (*lvprecision != 0) {
            *lvafter_dot = *lvprecision;
            buff[len++] = '>';
          }
        }
      } else {
        if (fp_round(buff, len))
          dx++, len++;
        {
          int w;
          for (w = 0; w <= dx; w++)
            buff[w] = buff[w + 1];
          buff[dx + 1] = '.';
        };
      }
    }
    if ((*lvprecision == 0) && ((flags & 010) == 0))
      len -= 1;
  } break;
  default: {
    int dx = fp_digits(buff, d);
    if (dx & 1)
      *lvprefix = "-";
    else
      *lvprefix = (flags & 02) ? "+" : (flags & 04) ? " " : "";
    dx = (dx & ~1) / 2;
    if (*lvprecision < 1)
      *lvprecision = 1;
    len = (*lvprecision > 17) ? 17 + 1 : *lvprecision + 1;
    dx += fp_round(buff, len);
    if ((dx >= *lvprecision) || (dx < -4)) {
      buff[0] = buff[1];
      buff[1] = '.';
    } else {
      ch = 'f';
      if (dx >= 0) {
        {
          int w;
          for (w = 0; w <= dx; w++)
            buff[w] = buff[w + 1];
          buff[dx + 1] = '.';
        }
      } else {
        int w;
        dx = -dx;
        for (w = len; w >= 0; w--)
          buff[w + dx] = buff[w];
        len += dx;
        for (w = 0; w <= dx; w++)
          buff[w] = '0';
        buff[1] = '.';
      }
    }
    if ((flags & 010) == 0) {
      *lvafter_dot = -1;
      if (buff[len] != '.')
        while (buff[len - 1] == '0')
          len--;
      if (buff[len - 1] == '.')
        len--;
    } else {
      if (*lvprecision > 17) {
        *lvafter_dot = *lvprecision - 17;
        buff[len++] = '>';
      }
    }
    if (ch != 'f')
      len = fp_addexp(buff, len, dx, ch + ('e' - 'g'));
  } break;
  case 'e':
  case 'E': {
    int dx = fp_digits(buff, d);
    if (dx & 1)
      *lvprefix = "-";
    else
      *lvprefix = (flags & 02) ? "+" : (flags & 04) ? " " : "";
    dx = (dx & ~1) / 2;
    if (*lvprecision > 17) {
      *lvafter_dot = *lvprecision - 17;
      *lvprecision = 17;
    }
    len = *lvprecision + 2;
    dx += fp_round(buff, len);
    buff[0] = buff[1];
    if ((*lvprecision == 0) && !(flags & 010))
      len = 1;
    else
      buff[1] = '.';
    if (*lvafter_dot > 0)
      buff[len++] = '>';
    len = fp_addexp(buff, len, dx, ch);
  } break;
  }
  return len;
}


x86 assembly (clang, -O0):
<fp_display>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x6c(%rbp)
sub    $0x45,%eax
je     1933 <fp_display+0x803>
jmp    1181 <fp_display+0x51>
mov    -0x6c(%rbp),%eax
sub    $0x65,%eax
je     1933 <fp_display+0x803>
jmp    1192 <fp_display+0x62>
mov    -0x6c(%rbp),%eax
sub    $0x66,%eax
jne    1642 <fp_display+0x512>
jmp    11a3 <fp_display+0x73>
mov    -0x18(%rbp),%rdi
movsd  -0x40(%rbp),%xmm0
mov    $0x1,%al
call   1030 <fp_digits@plt>
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     11d8 <fp_display+0xa8>
mov    -0x28(%rbp),%rax
lea    0xe30(%rip),%rcx
mov    %rcx,(%rax)
jmp    1221 <fp_display+0xf1>
mov    -0x1c(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     11f7 <fp_display+0xc7>
lea    0xe14(%rip),%rax
mov    %rax,-0x78(%rbp)
jmp    1216 <fp_display+0xe6>
mov    -0x1c(%rbp),%edx
and    $0x4,%edx
lea    0xe01(%rip),%rax
lea    0xdf9(%rip),%rcx
cmp    $0x0,%edx
cmovne %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x44(%rbp),%eax
and    $0xfffffffe,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jge    140c <fp_display+0x2dc>
xor    %eax,%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jle    129c <fp_display+0x16c>
movl   $0x0,-0x34(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0x30,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0x2e,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    (%rax),%ecx
mov    0x18(%rbp),%rax
mov    %ecx,(%rax)
jmp    13e4 <fp_display+0x2b4>
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
sub    -0x44(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x12,-0x34(%rbp)
jle    12c8 <fp_display+0x198>
mov    -0x34(%rbp),%ecx
sub    $0x13,%ecx
mov    0x18(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x13,-0x34(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    $0x0,%al
call   1040 <fp_round@plt>
cmp    $0x0,%eax
je     12f1 <fp_display+0x1c1>
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x44(%rbp)
jne    1315 <fp_display+0x1e5>
mov    -0x18(%rbp),%rax
mov    0x1(%rax),%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x2e,0x1(%rax)
jmp    13df <fp_display+0x2af>
cmpl   $0x1,-0x44(%rbp)
jne    1375 <fp_display+0x245>
mov    -0x34(%rbp),%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x48(%rbp)
jle    1358 <fp_display+0x228>
mov    -0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x48(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x48(%rbp)
jmp    1325 <fp_display+0x1f5>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movb   $0x30,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x2e,0x1(%rax)
jmp    13da <fp_display+0x2aa>
mov    -0x34(%rbp),%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jle    13ae <fp_display+0x27e>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x4c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x4c(%rbp)
jmp    137b <fp_display+0x24b>
mov    -0x34(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movb   $0x30,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x2e,0x1(%rax)
mov    -0x18(%rbp),%rax
movb   $0x3c,0x2(%rax)
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
jmp    13df <fp_display+0x2af>
jmp    13e4 <fp_display+0x2b4>
mov    0x18(%rbp),%rax
cmpl   $0x0,(%rax)
jle    1407 <fp_display+0x2d7>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0x3e,(%rax,%rcx,1)
jmp    1618 <fp_display+0x4e8>
mov    -0x44(%rbp),%eax
mov    -0x30(%rbp),%rcx
add    (%rcx),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x12,-0x34(%rbp)
jle    159d <fp_display+0x46d>
movl   $0x13,-0x34(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    $0x0,%al
call   1040 <fp_round@plt>
cmp    $0x0,%eax
je     1455 <fp_display+0x325>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    14ed <fp_display+0x3bd>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     14a2 <fp_display+0x372>
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    146d <fp_display+0x33d>
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x2e,(%rax,%rcx,1)
mov    -0x44(%rbp),%ecx
mov    -0x30(%rbp),%rax
add    (%rax),%ecx
sub    $0x11,%ecx
mov    0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    0x18(%rbp),%rax
cmpl   $0x0,(%rax)
je     14e8 <fp_display+0x3b8>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0x3e,(%rax,%rcx,1)
jmp    1598 <fp_display+0x468>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    152e <fp_display+0x3fe>
mov    -0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    14f4 <fp_display+0x3c4>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x3c,(%rax,%rcx,1)
mov    -0x44(%rbp),%ecx
sub    -0x34(%rbp),%ecx
add    $0x2,%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0x2e,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
cmpl   $0x0,(%rax)
je     1593 <fp_display+0x463>
mov    -0x30(%rbp),%rax
mov    (%rax),%ecx
mov    0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0x3e,(%rax,%rcx,1)
jmp    1598 <fp_display+0x468>
jmp    1613 <fp_display+0x4e3>
mov    -0x18(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    $0x0,%al
call   1040 <fp_round@plt>
cmp    $0x0,%eax
je     15c6 <fp_display+0x496>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     1602 <fp_display+0x4d2>
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    15cd <fp_display+0x49d>
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x2e,(%rax,%rcx,1)
jmp    1618 <fp_display+0x4e8>
mov    -0x30(%rbp),%rax
cmpl   $0x0,(%rax)
jne    163d <fp_display+0x50d>
mov    -0x1c(%rbp),%eax
and    $0x8,%eax
cmp    $0x0,%eax
jne    163d <fp_display+0x50d>
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1a88 <fp_display+0x958>
mov    -0x18(%rbp),%rdi
movsd  -0x40(%rbp),%xmm0
mov    $0x1,%al
call   1030 <fp_digits@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1677 <fp_display+0x547>
mov    -0x28(%rbp),%rax
lea    0x991(%rip),%rcx
mov    %rcx,(%rax)
jmp    16c0 <fp_display+0x590>
mov    -0x1c(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     1696 <fp_display+0x566>
lea    0x975(%rip),%rax
mov    %rax,-0x80(%rbp)
jmp    16b5 <fp_display+0x585>
mov    -0x1c(%rbp),%edx
and    $0x4,%edx
lea    0x962(%rip),%rax
lea    0x95a(%rip),%rcx
cmp    $0x0,%edx
cmovne %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x5c(%rbp),%eax
and    $0xfffffffe,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x5c(%rbp)
mov    -0x30(%rbp),%rax
cmpl   $0x1,(%rax)
jge    16e8 <fp_display+0x5b8>
mov    -0x30(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x30(%rbp),%rax
cmpl   $0x11,(%rax)
jle    1705 <fp_display+0x5d5>
mov    $0x12,%eax
mov    %eax,-0x84(%rbp)
jmp    1714 <fp_display+0x5e4>
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    $0x0,%al
call   1040 <fp_round@plt>
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x30(%rbp),%rcx
cmp    (%rcx),%eax
jge    174a <fp_display+0x61a>
cmpl   $0xfffffffc,-0x5c(%rbp)
jge    1764 <fp_display+0x634>
mov    -0x18(%rbp),%rax
mov    0x1(%rax),%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x2e,0x1(%rax)
jmp    184b <fp_display+0x71b>
movl   $0x66,-0x4(%rbp)
cmpl   $0x0,-0x5c(%rbp)
jl     17c7 <fp_display+0x697>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     17b1 <fp_display+0x681>
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    177c <fp_display+0x64c>
mov    -0x18(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x2e,(%rax,%rcx,1)
jmp    1846 <fp_display+0x716>
xor    %eax,%eax
sub    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x64(%rbp)
cmpl   $0x0,-0x64(%rbp)
jl     1808 <fp_display+0x6d8>
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x64(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x64(%rbp)
jmp    17d5 <fp_display+0x6a5>
mov    -0x5c(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     183e <fp_display+0x70e>
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
movb   $0x30,(%rax,%rcx,1)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1818 <fp_display+0x6e8>
mov    -0x18(%rbp),%rax
movb   $0x2e,0x1(%rax)
jmp    184b <fp_display+0x71b>
mov    -0x1c(%rbp),%eax
and    $0x8,%eax
cmp    $0x0,%eax
jne    18d3 <fp_display+0x7a3>
mov    0x18(%rbp),%rax
movl   $0xffffffff,(%rax)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
je     18ab <fp_display+0x77b>
jmp    187e <fp_display+0x74e>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
jne    18a6 <fp_display+0x776>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    187e <fp_display+0x74e>
jmp    18ab <fp_display+0x77b>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
jne    18ce <fp_display+0x79e>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    190a <fp_display+0x7da>
mov    -0x30(%rbp),%rax
cmpl   $0x11,(%rax)
jle    1905 <fp_display+0x7d5>
mov    -0x30(%rbp),%rax
mov    (%rax),%ecx
sub    $0x11,%ecx
mov    0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0x3e,(%rax,%rcx,1)
jmp    190a <fp_display+0x7da>
cmpl   $0x66,-0x4(%rbp)
je     192e <fp_display+0x7fe>
mov    -0x18(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    -0x5c(%rbp),%edx
mov    -0x4(%rbp),%ecx
add    $0xfffffffe,%ecx
mov    $0x0,%al
call   1050 <fp_addexp@plt>
mov    %eax,-0x34(%rbp)
jmp    1a88 <fp_display+0x958>
mov    -0x18(%rbp),%rdi
movsd  -0x40(%rbp),%xmm0
mov    $0x1,%al
call   1030 <fp_digits@plt>
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1968 <fp_display+0x838>
mov    -0x28(%rbp),%rax
lea    0x6a0(%rip),%rcx
mov    %rcx,(%rax)
jmp    19ba <fp_display+0x88a>
mov    -0x1c(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     198a <fp_display+0x85a>
lea    0x684(%rip),%rax
mov    %rax,-0x90(%rbp)
jmp    19ac <fp_display+0x87c>
mov    -0x1c(%rbp),%edx
and    $0x4,%edx
lea    0x66e(%rip),%rax
lea    0x666(%rip),%rcx
cmp    $0x0,%edx
cmovne %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x68(%rbp),%eax
and    $0xfffffffe,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x68(%rbp)
mov    -0x30(%rbp),%rax
cmpl   $0x11,(%rax)
jle    19f1 <fp_display+0x8c1>
mov    -0x30(%rbp),%rax
mov    (%rax),%ecx
sub    $0x11,%ecx
mov    0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%rax
movl   $0x11,(%rax)
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    $0x0,%al
call   1040 <fp_round@plt>
add    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x18(%rbp),%rax
mov    0x1(%rax),%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
cmpl   $0x0,(%rax)
jne    1a46 <fp_display+0x916>
mov    -0x1c(%rbp),%eax
and    $0x8,%eax
cmp    $0x0,%eax
jne    1a46 <fp_display+0x916>
movl   $0x1,-0x34(%rbp)
jmp    1a4e <fp_display+0x91e>
mov    -0x18(%rbp),%rax
movb   $0x2e,0x1(%rax)
mov    0x18(%rbp),%rax
cmpl   $0x0,(%rax)
jle    1a71 <fp_display+0x941>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0x3e,(%rax,%rcx,1)
mov    -0x18(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x4(%rbp),%ecx
mov    $0x0,%al
call   1050 <fp_addexp@plt>
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fp_display>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %r9,%r14
mov    %r8,%rbp
mov    %ecx,%r15d
mov    %rdx,%r13
mov    %edi,%r12d
mov    0x78(%rsp),%rbx
movsd  (%rsi),%xmm0
cmp    $0x45,%edi
je     11db <fp_display+0x8b>
cmp    $0x65,%r12d
je     11db <fp_display+0x8b>
cmp    $0x66,%r12d
mov    %r14,0x18(%rsp)
jne    121e <fp_display+0xce>
mov    0x70(%rsp),%rax
mov    %rax,0x8(%rsp)
mov    %r13,%rdi
mov    $0x1,%al
call   1030 <fp_digits@plt>
mov    %eax,%r12d
test   $0x1,%r12b
jne    12f4 <fp_display+0x1a4>
test   $0x4,%r15b
lea    0xe49(%rip),%rax
lea    0xe41(%rip),%rcx
cmove  %rax,%rcx
test   $0x2,%r15b
lea    0xe30(%rip),%rax
cmove  %rcx,%rax
jmp    12fb <fp_display+0x1ab>
mov    %rbx,0x10(%rsp)
mov    %r13,0x8(%rsp)
mov    %r13,%rdi
mov    $0x1,%al
call   1030 <fp_digits@plt>
mov    %eax,%ebx
test   $0x1,%bl
jne    125a <fp_display+0x10a>
mov    %r15d,%edx
test   $0x4,%dl
lea    0xe02(%rip),%rax
lea    0xdfa(%rip),%rcx
cmove  %rax,%rcx
test   $0x2,%dl
lea    0xdea(%rip),%rax
cmove  %rcx,%rax
jmp    1261 <fp_display+0x111>
mov    %r13,%rdi
mov    $0x1,%al
call   1030 <fp_digits@plt>
test   $0x1,%al
jne    133f <fp_display+0x1ef>
test   $0x4,%r15b
lea    0xdca(%rip),%rdx
lea    0xdc2(%rip),%rcx
cmove  %rdx,%rcx
test   $0x2,%r15b
lea    0xdb1(%rip),%rdx
cmove  %rcx,%rdx
jmp    1346 <fp_display+0x1f6>
lea    0xd9f(%rip),%rax
mov    %rax,0x0(%rbp)
mov    (%r14),%ebp
cmp    $0x12,%ebp
jl     1283 <fp_display+0x133>
add    $0xffffffef,%ebp
mov    0x10(%rsp),%rax
mov    %ebp,(%rax)
movl   $0x11,(%r14)
mov    $0x11,%ebp
sar    %ebx
add    $0x2,%ebp
mov    0x8(%rsp),%r13
mov    %r13,%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <fp_round@plt>
mov    0x1(%r13),%cl
mov    %cl,0x0(%r13)
and    $0x8,%r15d
or     (%r14),%r15d
je     12b1 <fp_display+0x161>
movb   $0x2e,0x1(%r13)
jmp    12b6 <fp_display+0x166>
mov    $0x1,%ebp
add    %ebx,%eax
mov    0x10(%rsp),%rcx
cmpl   $0x0,(%rcx)
jle    12d3 <fp_display+0x183>
movslq %ebp,%rcx
add    $0x1,%ebp
mov    0x8(%rsp),%rdi
movb   $0x3e,(%rdi,%rcx,1)
jmp    12d8 <fp_display+0x188>
mov    0x8(%rsp),%rdi
mov    %ebp,%esi
mov    %eax,%edx
mov    %r12d,%ecx
xor    %eax,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1070 <fp_addexp@plt>
lea    0xd05(%rip),%rax
mov    %rax,0x0(%rbp)
mov    %r12d,%eax
and    $0xfffffffe,%eax
sar    %r12d
cmp    $0xfffffffe,%eax
jg     1373 <fp_display+0x223>
mov    %r12d,%ebp
neg    %ebp
mov    (%r14),%eax
lea    0x1(%rax),%ecx
cmp    %ebp,%ecx
jge    145d <fp_display+0x30d>
movw   $0x2e30,0x0(%r13)
mov    (%r14),%eax
mov    %eax,(%rbx)
mov    $0x2,%r14d
test   %eax,%eax
jg     1ad9 <fp_display+0x989>
jmp    1ae7 <fp_display+0x997>
lea    0xcba(%rip),%rdx
mov    %rdx,0x0(%rbp)
sar    %eax
mov    %rax,0x8(%rsp)
mov    (%r14),%eax
test   %eax,%eax
jle    13de <fp_display+0x28e>
mov    $0x12,%r14d
cmp    $0x11,%eax
ja     13eb <fp_display+0x29b>
add    $0x1,%eax
mov    %eax,%r14d
jmp    13eb <fp_display+0x29b>
mov    (%r14),%eax
lea    (%rax,%r12,1),%r14d
cmp    $0x11,%r14d
jl     147e <fp_display+0x32e>
mov    %rbx,0x10(%rsp)
mov    %r13,%rdi
mov    $0x13,%esi
xor    %eax,%eax
call   1050 <fp_round@plt>
mov    %eax,%ebx
xor    %ecx,%ecx
xor    %eax,%eax
test   %ebx,%ebx
setne  %cl
sete   %al
mov    $0x14,%ebp
sub    %eax,%ebp
add    %ecx,%r12d
xor    $0x13,%eax
cmp    %eax,%r12d
jge    164a <fp_display+0x4fa>
test   %r12d,%r12d
js     1801 <fp_display+0x6b1>
lea    0x1(%r13),%rsi
lea    0x1(%r12),%ebx
mov    %r13,%rdi
mov    %rbx,%rdx
call   1060 <memmove@plt>
jmp    1806 <fp_display+0x6b6>
movl   $0x1,(%r14)
mov    $0x2,%r14d
mov    %r13,%rdi
mov    %r14d,%esi
xor    %eax,%eax
call   1050 <fp_round@plt>
mov    0x8(%rsp),%rbp
lea    (%rax,%rbp,1),%r10d
mov    0x18(%rsp),%rcx
cmp    (%rcx),%r10d
jge    144c <fp_display+0x2fc>
cmp    $0xfffffffb,%r10d
jle    144c <fp_display+0x2fc>
test   %r10d,%r10d
js     14c0 <fp_display+0x370>
lea    0x1(%r13),%rsi
mov    %rbx,%r12
mov    %r10d,%ebx
lea    0x1(%rbx),%rdx
mov    %r13,%rdi
mov    %r10d,%ebp
call   1060 <memmove@plt>
mov    %ebp,%r10d
lea    (%rbx,%r13,1),%rax
add    $0x1,%rax
mov    %r12,%rbx
mov    $0x66,%r12d
jmp    15bd <fp_display+0x46d>
lea    0x1(%r13),%rax
mov    0x1(%r13),%cl
mov    %cl,0x0(%r13)
jmp    15bd <fp_display+0x46d>
lea    (%rax,%r12,1),%ecx
cmp    $0x11,%ecx
mov    %rbx,0x10(%rsp)
jl     16a2 <fp_display+0x552>
add    $0xffffffef,%ecx
mov    %ecx,(%rbx)
mov    $0x13,%ebx
jmp    16a9 <fp_display+0x559>
lea    (%rax,%r12,1),%ebp
add    $0x2,%ebp
mov    %r13,%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <fp_round@plt>
add    $0x3,%r14d
xor    %ebx,%ebx
test   %eax,%eax
setne  %bl
cmove  %ebp,%r14d
add    %r12d,%ebx
js     1736 <fp_display+0x5e6>
lea    0x1(%r13),%rsi
add    $0x1,%ebx
mov    %r13,%rdi
mov    %rbx,%rdx
call   1060 <memmove@plt>
jmp    1739 <fp_display+0x5e9>
mov    %r14d,%r12d
cmp    $0x3,%r14d
mov    %rbx,0x10(%rsp)
jae    1740 <fp_display+0x5f0>
mov    %r12,%rcx
lea    0x1(%rcx),%edx
mov    %rcx,%rax
and    $0x3,%rdx
je     1508 <fp_display+0x3b8>
mov    %r10d,%esi
neg    %esi
mov    %rcx,%rax
nopl   0x0(%rax)
movzbl 0x0(%r13,%rax,1),%ebx
lea    (%rsi,%rax,1),%edi
mov    %bl,0x0(%r13,%rdi,1)
add    $0xffffffffffffffff,%rax
add    $0xffffffffffffffff,%rdx
jne    14f0 <fp_display+0x3a0>
cmp    $0x3,%rcx
jb     1581 <fp_display+0x431>
mov    %r10d,%ecx
neg    %ecx
lea    -0x3(%rax),%r8
mov    $0xfffffffe,%esi
sub    %r10d,%esi
mov    %r10d,%edi
not    %edi
mov    $0xffffffffffffffff,%rbx
mov    %r13,%rdx
xchg   %ax,%ax
movzbl (%rdx,%rax,1),%r9d
lea    (%rax,%rcx,1),%ebp
mov    %r9b,0x0(%r13,%rbp,1)
movzbl -0x1(%rdx,%rax,1),%r9d
lea    (%rdi,%rax,1),%ebp
mov    %r9b,0x0(%r13,%rbp,1)
movzbl -0x2(%rdx,%rax,1),%r9d
lea    (%rsi,%rax,1),%ebp
mov    %r9b,0x0(%r13,%rbp,1)
movzbl -0x3(%rdx,%rax,1),%r9d
lea    (%r8,%rcx,1),%ebp
mov    %r9b,0x0(%r13,%rbp,1)
add    $0x4,%rbx
add    $0xfffffffffffffffc,%rcx
add    $0xfffffffffffffffc,%rdx
add    $0xfffffffffffffffc,%rsi
add    $0xfffffffffffffffc,%rdi
cmp    %rbx,%rax
jne    1530 <fp_display+0x3e0>
mov    %r10d,%ebx
neg    %ebx
test   %r10d,%r10d
jg     15a8 <fp_display+0x458>
xor    %edx,%edx
test   %ebx,%ebx
cmovg  %ebx,%edx
add    $0x1,%edx
mov    %r13,%rdi
mov    $0x30,%esi
mov    %r10d,%ebp
call   1040 <memset@plt>
mov    %ebp,%r10d
sub    %r10d,%r14d
lea    0x1(%r13),%rax
mov    $0x66,%r12d
mov    %ebx,%r10d
mov    0x10(%rsp),%rbx
movb   $0x2e,(%rax)
test   $0x8,%r15b
jne    1610 <fp_display+0x4c0>
movl   $0xffffffff,(%rbx)
movslq %r14d,%rax
cmpb   $0x2e,0x0(%r13,%rax,1)
je     15fd <fp_display+0x4ad>
add    $0x1,%r14d
add    %r13,%rax
add    $0xffffffffffffffff,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0xffffffff,%r14d
cmpb   $0x30,(%rax)
lea    -0x1(%rax),%rax
je     15f0 <fp_display+0x4a0>
movslq %r14d,%r14
lea    -0x1(%r14),%rax
cmpb   $0x2e,-0x1(%r13,%r14,1)
cmove  %eax,%r14d
jmp    162e <fp_display+0x4de>
mov    0x18(%rsp),%rax
mov    (%rax),%eax
cmp    $0x12,%eax
jl     162e <fp_display+0x4de>
add    $0xffffffef,%eax
mov    %eax,(%rbx)
movslq %r14d,%rax
add    $0x1,%r14d
movb   $0x3e,0x0(%r13,%rax,1)
cmp    $0x66,%r12d
je     1afb <fp_display+0x9ab>
add    $0xfffffffe,%r12d
mov    %r13,%rdi
mov    %r14d,%esi
mov    %r10d,%edx
jmp    12dc <fp_display+0x18c>
lea    0x1(%r13),%rsi
mov    %eax,%r14d
mov    %r13,%rdi
mov    %r14,%rdx
call   1060 <memmove@plt>
cmp    $0x1,%ebx
adc    $0x0,%r12d
movb   $0x3c,0x0(%r13,%r14,1)
add    $0xffffffee,%r12d
mov    0x8(%rsp),%rax
mov    %r12d,(%rax)
lea    0x1(%rbp),%r14d
mov    %ebp,%eax
movb   $0x2e,0x0(%r13,%rax,1)
mov    0x18(%rsp),%rax
mov    (%rax),%eax
test   %eax,%eax
je     1ae7 <fp_display+0x997>
mov    0x10(%rsp),%rcx
mov    %eax,(%rcx)
add    $0x2,%ebp
mov    %r14d,%ebx
jmp    1827 <fp_display+0x6d7>
lea    (%rax,%r12,1),%ebx
add    $0x2,%ebx
mov    %r13,%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <fp_round@plt>
xor    %ecx,%ecx
test   %eax,%eax
setne  %cl
not    %r12d
cmove  %ebp,%r12d
lea    (%rbx,%rcx,1),%r14d
test   %r12d,%r12d
je     17ba <fp_display+0x66a>
cmp    $0x1,%r12d
jne    17cc <fp_display+0x67c>
test   %r14d,%r14d
jle    1726 <fp_display+0x5d6>
mov    %r14d,%eax
add    %ebx,%ecx
add    $0xffffffff,%ecx
mov    %r14d,%edx
and    $0x3,%edx
je     1704 <fp_display+0x5b4>
nop
movzbl 0x0(%r13,%rax,1),%ebx
mov    %bl,0x1(%r13,%rax,1)
add    $0xffffffffffffffff,%rax
add    $0xffffffff,%edx
jne    16f0 <fp_display+0x5a0>
cmp    $0x3,%ecx
jb     1726 <fp_display+0x5d6>
nopl   0x0(%rax)
mov    -0x3(%r13,%rax,1),%ecx
mov    %ecx,-0x2(%r13,%rax,1)
add    $0xfffffffffffffffc,%rax
lea    0x1(%rax),%ecx
cmp    $0x1,%ecx
jg     1710 <fp_display+0x5c0>
add    $0x1,%r14d
movw   $0x2e30,0x0(%r13)
jmp    1ace <fp_display+0x97e>
add    $0x1,%ebx
mov    $0x2e,%al
jmp    1ae2 <fp_display+0x992>
mov    %r14d,%ecx
sub    %r10d,%ecx
mov    %r10d,%esi
neg    %esi
cmp    %esi,%ecx
jb     14d2 <fp_display+0x382>
lea    (%rcx,%r13,1),%rsi
mov    %rsi,%rdi
sub    %r12,%rdi
cmp    %rsi,%rdi
ja     14d2 <fp_display+0x382>
lea    (%r12,%r13,1),%rsi
cmp    %r13,%rsi
jb     14d2 <fp_display+0x382>
mov    %rcx,%rsi
sub    %r12,%rsi
add    %r13,%rsi
lea    (%r12,%r13,1),%rdi
add    $0x1,%rdi
cmp    %rdi,%rsi
jae    1799 <fp_display+0x649>
add    %r13,%rcx
add    $0x1,%rcx
cmp    %r13,%rcx
ja     14d2 <fp_display+0x382>
lea    0x1(%r12),%r9
movabs $0x1fffffff0,%r11
cmp    $0xf,%r14d
jae    185f <fp_display+0x70f>
xor    %r8d,%r8d
jmp    1a38 <fp_display+0x8e8>
mov    0x1(%r13),%al
mov    %al,0x0(%r13)
movb   $0x2e,0x1(%r13)
jmp    1ace <fp_display+0x97e>
test   %r14d,%r14d
jle    1ab2 <fp_display+0x962>
mov    %r14d,%r9d
lea    (%rbx,%rcx,1),%eax
add    $0xffffffff,%eax
cmp    $0x3,%eax
jb     1a85 <fp_display+0x935>
lea    0x1(%rax),%r11
movabs $0x1fffffff0,%r8
cmp    $0xf,%eax
jae    1839 <fp_display+0x6e9>
xor    %edi,%edi
jmp    190d <fp_display+0x7bd>
lea    0x1(%r12),%ebx
mov    0x18(%rsp),%rax
movb   $0x2e,0x0(%r13,%rbx,1)
add    (%rax),%r12d
add    $0xffffffef,%r12d
mov    0x10(%rsp),%rax
mov    %r12d,(%rax)
je     1831 <fp_display+0x6e1>
mov    %ebp,%ebx
add    $0x1,%ebp
mov    $0x3e,%al
mov    %ebp,%r14d
jmp    1ae2 <fp_display+0x992>
mov    %ebp,%r14d
jmp    1ae7 <fp_display+0x997>
mov    %r11,%rdi
and    %r8,%rdi
lea    -0x10(%rdi),%rax
mov    %rax,%rdx
shr    $0x4,%rdx
add    $0x1,%rdx
mov    %edx,%r10d
and    $0x3,%r10d
cmp    $0x30,%rax
jae    188a <fp_display+0x73a>
xor    %eax,%eax
jmp    18cc <fp_display+0x77c>
mov    %r9,%r8
and    %r11,%r8
lea    -0x10(%r8),%rsi
mov    %rsi,%rcx
shr    $0x4,%rcx
add    $0x1,%rcx
mov    %ecx,%edi
and    $0x3,%edi
cmp    $0x30,%rsi
jae    1951 <fp_display+0x801>
xor    %esi,%esi
jmp    19e8 <fp_display+0x898>
and    $0xfffffffffffffffc,%rdx
lea    (%r9,%r13,1),%rsi
add    $0xfffffffffffffff3,%rsi
xor    %eax,%eax
movups -0x32(%rsi,%rax,1),%xmm0
movups -0x22(%rsi,%rax,1),%xmm1
movups -0x12(%rsi,%rax,1),%xmm2
movups -0x2(%rsi,%rax,1),%xmm3
movups %xmm3,(%rsi,%rax,1)
movups %xmm2,-0x10(%rsi,%rax,1)
movups %xmm1,-0x20(%rsi,%rax,1)
movups %xmm0,-0x30(%rsi,%rax,1)
add    $0xffffffffffffffc0,%rax
add    $0xfffffffffffffffc,%rdx
jne    1898 <fp_display+0x748>
neg    %rax
test   %r10,%r10
je     18fa <fp_display+0x7aa>
mov    %r9,%rdx
sub    %rax,%rdx
lea    (%rdx,%r13,1),%rax
add    $0xfffffffffffffff3,%rax
shl    $0x4,%r10
xor    %edx,%edx
movups -0x2(%rax,%rdx,1),%xmm0
movups %xmm0,(%rax,%rdx,1)
add    $0xfffffffffffffff0,%rdx
mov    %r10,%rsi
add    %rdx,%rsi
jne    18e5 <fp_display+0x795>
cmp    %rdi,%r11
je     1ab2 <fp_display+0x962>
test   $0xc,%r11b
je     1a82 <fp_display+0x932>
lea    (%rbx,%rcx,1),%eax
add    $0xffffffff,%eax
add    $0x1,%rax
add    $0xc,%r8
and    %rax,%r8
and    $0xfffffffffffffffc,%r11
neg    %r11
neg    %rdi
lea    (%r9,%r13,1),%rcx
add    $0xffffffffffffffff,%rcx
sub    %r8,%r9
mov    -0x2(%rcx,%rdi,1),%edx
mov    %edx,(%rcx,%rdi,1)
add    $0xfffffffffffffffc,%rdi
cmp    %rdi,%r11
jne    1933 <fp_display+0x7e3>
cmp    %r8,%rax
jne    1a85 <fp_display+0x935>
jmp    1ab2 <fp_display+0x962>
mov    %rdi,0x28(%rsp)
mov    %r9,0x30(%rsp)
mov    %r10d,0x24(%rsp)
and    $0xfffffffffffffffc,%rcx
lea    (%r12,%r13,1),%rbx
add    $0xfffffffffffffff1,%rbx
mov    %r14d,%r11d
sub    %eax,%r11d
sub    %ebp,%r11d
lea    -0x20(%r11),%ebp
lea    -0x10(%r11),%edi
lea    -0x30(%r11),%r9d
xor    %esi,%esi
movups (%rbx,%rsi,1),%xmm0
lea    (%r11,%rsi,1),%r10d
movups %xmm0,-0xf(%r13,%r10,1)
movups -0x10(%rbx,%rsi,1),%xmm0
lea    (%rdi,%rsi,1),%edx
movups %xmm0,-0xf(%r13,%rdx,1)
movups -0x20(%rbx,%rsi,1),%xmm0
lea    0x0(%rbp,%rsi,1),%edx
movups %xmm0,-0xf(%r13,%rdx,1)
movups -0x30(%rbx,%rsi,1),%xmm0
lea    (%r9,%rsi,1),%edx
movups %xmm0,-0xf(%r13,%rdx,1)
add    $0xffffffffffffffc0,%rsi
add    $0xfffffffffffffffc,%rcx
jne    1983 <fp_display+0x833>
neg    %rsi
mov    0x24(%rsp),%r10d
mov    0x8(%rsp),%rbp
mov    0x30(%rsp),%r9
movabs $0x1fffffff0,%r11
mov    0x28(%rsp),%rdi
test   %rdi,%rdi
je     1a25 <fp_display+0x8d5>
lea    (%rax,%rbp,1),%ecx
lea    (%rsi,%rcx,1),%edx
mov    %r14d,%ecx
sub    %edx,%ecx
mov    %r12,%rdx
sub    %rsi,%rdx
lea    (%rdx,%r13,1),%rsi
add    $0xfffffffffffffff1,%rsi
shl    $0x4,%rdi
xor    %ebx,%ebx
movups (%rsi,%rbx,1),%xmm0
lea    (%rcx,%rbx,1),%edx
movups %xmm0,-0xf(%r13,%rdx,1)
add    $0xfffffffffffffff0,%rbx
mov    %rdi,%rdx
add    %rbx,%rdx
jne    1a0c <fp_display+0x8bc>
cmp    %r8,%r9
je     1581 <fp_display+0x431>
test   $0xc,%r9b
je     1b0d <fp_display+0x9bd>
add    $0xc,%r11
and    %r9,%r11
mov    %r12,%rcx
sub    %r11,%rcx
add    %ebp,%eax
lea    (%r8,%rax,1),%edx
mov    %r14d,%eax
sub    %edx,%eax
sub    %r8,%r12
sub    %r11,%r8
lea    (%r12,%r13,1),%rdx
add    $0xfffffffffffffffd,%rdx
xor    %esi,%esi
mov    (%rdx,%rsi,1),%ebx
lea    (%rax,%rsi,1),%edi
mov    %ebx,-0x3(%r13,%rdi,1)
add    $0xfffffffffffffffc,%rsi
cmp    %rsi,%r8
jne    1a60 <fp_display+0x910>
cmp    %r11,%r9
jne    14d5 <fp_display+0x385>
jmp    1581 <fp_display+0x431>
sub    %rdi,%r9
lea    0x1(%r9),%eax
lea    (%r9,%r13,1),%rcx
add    $0x2,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl -0x2(%rcx),%edx
mov    %dl,(%rcx)
add    $0xffffffff,%eax
add    $0xffffffffffffffff,%rcx
cmp    $0x1,%eax
jg     1aa0 <fp_display+0x950>
add    $0x2,%r14d
movw   $0x2e30,0x0(%r13)
movb   $0x3c,0x2(%r13)
add    $0xffffffff,%r12d
mov    0x8(%rsp),%rax
mov    %r12d,(%rax)
mov    0x10(%rsp),%rax
mov    (%rax),%eax
test   %eax,%eax
jle    1ae7 <fp_display+0x997>
movslq %r14d,%rbx
add    $0x1,%r14d
mov    $0x3e,%al
mov    %al,0x0(%r13,%rbx,1)
and    $0x8,%r15d
xor    %eax,%eax
mov    0x18(%rsp),%rcx
or     (%rcx),%r15d
sete   %al
sub    %eax,%r14d
mov    %r14d,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
sub    %r8,%r12
jmp    14d2 <fp_display+0x382>

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

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