#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 */
long double LDBL_MAX;
long double LDBL_MIN;
long double floorld(long double);
scalar_t__ fmod(long double, int);
int /*<<< orphan*/ insert_char(char *, int, char, int);
int /*<<< orphan*/ lltoa(int, char *, int);
long double modld(long double, long double *);
long double precise_round(long double, int);
char *ldtoa(long double number, char *buffer, int precission,
            bool use_exponent_notation) {
  char reversed_int_part[311];
  int i, count = 0, exponent = 0;
  long double number_int_part, number_fractional_part;
  bool is_negative = false, first_digit_found = false;
  if (number != number)
    return (buffer = "nan");
  else if (number == LDBL_MAX)
    return (buffer = "inf");
  else if (number == LDBL_MIN)
    return (buffer = "-inf");
  if (number < 0) {
    is_negative = true;
    number = -number;
  }
  number_fractional_part = modld(number, &number_int_part);
  number_fractional_part = precise_round(number_fractional_part, precission);
  while (number_int_part > 0) {
    reversed_int_part[count++] = '0' + (int)fmod(number_int_part, 10);
    number_int_part = floorld(number_int_part / 10);
    exponent++;
    first_digit_found = true;
  }
  if (number_int_part == 0) {
    exponent = -1;
    if (!use_exponent_notation)
      reversed_int_part[count++] = '0';
  }
  if (is_negative)
    reversed_int_part[count++] = '-';
  for (i = 0; i < count; i++)
    buffer[i] = reversed_int_part[count - i - 1];
  if (!use_exponent_notation)
    buffer[count++] = '.';
  while (number_fractional_part > 0 && precission-- >= 0) {
    number_fractional_part *= 10;
    number_fractional_part = modld(number_fractional_part, &number_int_part);
    if (use_exponent_notation && number_int_part == 0 && !first_digit_found)
      exponent--;
    else {
      first_digit_found = true;
      buffer[count++] = '0' + (int)number_int_part;
    }
  }
  if (!number_fractional_part) {
    buffer[count++] = '0';
    if (!number_int_part && use_exponent_notation)
      buffer[count++] = '0';
  }
  if (use_exponent_notation) {
    insert_char(buffer, count++ + 1, '.', 1 + is_negative);
    buffer[count++] = 'e';
    lltoa(exponent, buffer + count, -10);
  } else
    buffer[count] = 0;
  return buffer;
}


x86 assembly (clang, -O0):
<ldtoa>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1d0,%rsp
fldt   0x10(%rbp)
fstpt  -0x20(%rbp)
mov    %rdi,-0x28(%rbp)
mov    %esi,-0x2c(%rbp)
mov    %edx,-0x30(%rbp)
movl   $0x0,-0x178(%rbp)
movl   $0x0,-0x17c(%rbp)
movl   $0x0,-0x1a4(%rbp)
movl   $0x0,-0x1a8(%rbp)
fldt   -0x20(%rbp)
fucomip %st(0),%st
jnp    11ce <ldtoa+0x6e>
jmp    11b3 <ldtoa+0x53>
lea    0xe4a(%rip),%rax
mov    %rax,-0x28(%rbp)
lea    0xe3f(%rip),%rax
mov    %rax,-0x8(%rbp)
jmp    166b <ldtoa+0x50b>
fldt   -0x20(%rbp)
mov    0x2e08(%rip),%rax
fldt   (%rax)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    120c <ldtoa+0xac>
jp     120c <ldtoa+0xac>
jmp    11f1 <ldtoa+0x91>
lea    0xe11(%rip),%rax
mov    %rax,-0x28(%rbp)
lea    0xe06(%rip),%rax
mov    %rax,-0x8(%rbp)
jmp    166b <ldtoa+0x50b>
fldt   -0x20(%rbp)
mov    0x2dc2(%rip),%rax
fldt   (%rax)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    124a <ldtoa+0xea>
jp     124a <ldtoa+0xea>
jmp    122f <ldtoa+0xcf>
lea    0xdd2(%rip),%rax
mov    %rax,-0x28(%rbp)
lea    0xdc7(%rip),%rax
mov    %rax,-0x8(%rbp)
jmp    166b <ldtoa+0x50b>
jmp    124f <ldtoa+0xef>
jmp    1254 <ldtoa+0xf4>
fldt   -0x20(%rbp)
fldz
fucomip %st(1),%st
fstp   %st(0)
jbe    127a <ldtoa+0x11a>
jmp    1268 <ldtoa+0x108>
movl   $0x1,-0x1a4(%rbp)
fldt   -0x20(%rbp)
fchs
fstpt  -0x20(%rbp)
fldt   -0x20(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
lea    -0x190(%rbp),%rdi
call   1070 <modld@plt>
fstpt  -0x1a0(%rbp)
fldt   -0x1a0(%rbp)
mov    -0x2c(%rbp),%edi
mov    %rsp,%rax
fstpt  (%rax)
call   1030 <precise_round@plt>
fstpt  -0x1a0(%rbp)
fldt   -0x190(%rbp)
fldz
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jbe    1335 <ldtoa+0x1d5>
jmp    12c6 <ldtoa+0x166>
fldt   -0x190(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
mov    $0xa,%edi
call   1040 <fmod@plt>
mov    %al,%cl
add    $0x30,%cl
movslq -0x178(%rbp),%rax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x178(%rbp)
mov    %cl,-0x170(%rbp,%rax,1)
fldt   -0x190(%rbp)
flds   0xcfb(%rip)
fdivrp %st,%st(1)
mov    %rsp,%rax
fstpt  (%rax)
call   1050 <floorld@plt>
fstpt  -0x190(%rbp)
mov    -0x17c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x17c(%rbp)
movl   $0x1,-0x1a8(%rbp)
jmp    12ad <ldtoa+0x14d>
fldt   -0x190(%rbp)
fldz
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    1388 <ldtoa+0x228>
jp     1388 <ldtoa+0x228>
jmp    1354 <ldtoa+0x1f4>
movl   $0xffffffff,-0x17c(%rbp)
ff ff ff
cmpl   $0x0,-0x30(%rbp)
jne    1383 <ldtoa+0x223>
mov    -0x178(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x178(%rbp)
cltq
movb   $0x30,-0x170(%rbp,%rax,1)
30
jmp    1388 <ldtoa+0x228>
cmpl   $0x0,-0x1a4(%rbp)
je     13b0 <ldtoa+0x250>
mov    -0x178(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x178(%rbp)
cltq
movb   $0x2d,-0x170(%rbp,%rax,1)
2d
movl   $0x0,-0x174(%rbp)
mov    -0x174(%rbp),%eax
cmp    -0x178(%rbp),%eax
jge    1406 <ldtoa+0x2a6>
mov    -0x178(%rbp),%eax
sub    -0x174(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x170(%rbp,%rax,1),%dl
mov    -0x28(%rbp),%rax
movslq -0x174(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x174(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x174(%rbp)
jmp    13ba <ldtoa+0x25a>
cmpl   $0x0,-0x30(%rbp)
jne    142c <ldtoa+0x2cc>
mov    -0x28(%rbp),%rax
mov    -0x178(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x178(%rbp)
movslq %ecx,%rcx
movb   $0x2e,(%rax,%rcx,1)
jmp    1431 <ldtoa+0x2d1>
fldt   -0x1a0(%rbp)
xor    %eax,%eax
fldz
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
mov    %al,-0x1b1(%rbp)
jbe    1469 <ldtoa+0x309>
jmp    1452 <ldtoa+0x2f2>
mov    -0x2c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x2c(%rbp)
cmp    $0x0,%eax
setge  %al
mov    %al,-0x1b1(%rbp)
mov    -0x1b1(%rbp),%al
test   $0x1,%al
jne    147c <ldtoa+0x31c>
jmp    155d <ldtoa+0x3fd>
fldt   -0x1a0(%rbp)
flds   0xb78(%rip)
fmulp  %st,%st(1)
fstpt  -0x1a0(%rbp)
fldt   -0x1a0(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
lea    -0x190(%rbp),%rdi
call   1070 <modld@plt>
fstpt  -0x1a0(%rbp)
cmpl   $0x0,-0x30(%rbp)
je     14f7 <ldtoa+0x397>
fldt   -0x190(%rbp)
fldz
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    14f7 <ldtoa+0x397>
jp     14f7 <ldtoa+0x397>
jmp    14d6 <ldtoa+0x376>
cmpl   $0x0,-0x1a8(%rbp)
jne    14f7 <ldtoa+0x397>
mov    -0x17c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x17c(%rbp)
jmp    1558 <ldtoa+0x3f8>
movl   $0x1,-0x1a8(%rbp)
fldt   -0x190(%rbp)
fnstcw -0x1ae(%rbp)
movzwl -0x1ae(%rbp),%eax
or     $0xc00,%eax
mov    %ax,-0x1b0(%rbp)
fldcw  -0x1b0(%rbp)
fistpl -0x1ac(%rbp)
fldcw  -0x1ae(%rbp)
mov    -0x1ac(%rbp),%eax
add    $0x30,%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
mov    -0x178(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x178(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1431 <ldtoa+0x2d1>
fldt   -0x1a0(%rbp)
fldz
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    15e0 <ldtoa+0x480>
jp     15e0 <ldtoa+0x480>
jmp    157c <ldtoa+0x41c>
mov    -0x28(%rbp),%rax
movslq -0x178(%rbp),%rcx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x178(%rbp)
movb   $0x30,(%rax,%rcx,1)
fldt   -0x190(%rbp)
fldz
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    15db <ldtoa+0x47b>
jp     15db <ldtoa+0x47b>
jmp    15b5 <ldtoa+0x455>
cmpl   $0x0,-0x30(%rbp)
je     15db <ldtoa+0x47b>
mov    -0x28(%rbp),%rax
mov    -0x178(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x178(%rbp)
movslq %ecx,%rcx
movb   $0x30,(%rax,%rcx,1)
jmp    15e0 <ldtoa+0x480>
cmpl   $0x0,-0x30(%rbp)
je     1654 <ldtoa+0x4f4>
mov    -0x28(%rbp),%rdi
mov    -0x178(%rbp),%esi
mov    %esi,%eax
add    $0x1,%eax
mov    %eax,-0x178(%rbp)
add    $0x1,%esi
mov    -0x1a4(%rbp),%ecx
add    $0x1,%ecx
mov    $0x2e,%edx
call   1080 <insert_char@plt>
mov    -0x28(%rbp),%rax
mov    -0x178(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x178(%rbp)
movslq %ecx,%rcx
movb   $0x65,(%rax,%rcx,1)
mov    -0x17c(%rbp),%edi
mov    -0x28(%rbp),%rsi
movslq -0x178(%rbp),%rax
add    %rax,%rsi
mov    $0xfffffff6,%edx
call   1060 <lltoa@plt>
jmp    1663 <ldtoa+0x503>
mov    -0x28(%rbp),%rax
movslq -0x178(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x28(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1d0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ldtoa>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x188,%rsp
fldt   0x1c0(%rsp)
fucomi %st(0),%st
jp     15ca <ldtoa+0x46a>
mov    0x2e59(%rip),%rax
fldt   (%rax)
fucomip %st(1),%st
jne    119d <ldtoa+0x3d>
jp     119d <ldtoa+0x3d>
fstp   %st(0)
lea    0xe71(%rip),%rbx
jmp    15aa <ldtoa+0x44a>
mov    0x2e34(%rip),%rax
fldt   (%rax)
fucomip %st(1),%st
jne    11ba <ldtoa+0x5a>
jp     11ba <ldtoa+0x5a>
fstp   %st(0)
lea    0xe53(%rip),%rbx
jmp    15aa <ldtoa+0x44a>
mov    %edx,%r12d
mov    %esi,%ebp
mov    %rdi,%rbx
fldz
fld    %st(0)
fstpt  0x1c(%rsp)
fucomip %st(1),%st
seta   0x17(%rsp)
fld    %st(0)
fchs
fld    %st(1)
fstpt  0x44(%rsp)
fxch   %st(1)
fcmovnbe %st(1),%st
fstp   %st(1)
fstpt  (%rsp)
lea    0x30(%rsp),%rdi
call   1070 <modld@plt>
fstpt  (%rsp)
mov    %ebp,%edi
call   1030 <precise_round@plt>
fldt   0x30(%rsp)
xor    %r14d,%r14d
fldt   0x1c(%rsp)
fxch   %st(1)
fucomi %st(1),%st
fstp   %st(1)
jbe    1266 <ldtoa+0x106>
fxch   %st(1)
fstpt  0x1c(%rsp)
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
fstpt  (%rsp)
mov    $0xa,%edi
call   1040 <fmod@plt>
add    $0x30,%al
mov    %al,0x50(%rsp,%r14,1)
add    $0x1,%r14
fldt   0x30(%rsp)
fdivs  0xdbe(%rip)
fstpt  (%rsp)
call   1050 <floorld@plt>
fld    %st(0)
fstpt  0x30(%rsp)
fldz
fxch   %st(1)
fucomi %st(1),%st
fstp   %st(1)
ja     1220 <ldtoa+0xc0>
mov    $0x1,%r15d
fldt   0x1c(%rsp)
jmp    126b <ldtoa+0x10b>
xor    %r15d,%r15d
fxch   %st(1)
fldz
fxch   %st(2)
fucomi %st(2),%st
fstp   %st(2)
jne    1292 <ldtoa+0x132>
jp     1292 <ldtoa+0x132>
movl   $0xffffffff,0x1c(%rsp)
ff
test   %r12d,%r12d
jne    129a <ldtoa+0x13a>
mov    %r14d,%eax
add    $0x1,%r14d
movb   $0x30,0x50(%rsp,%rax,1)
jmp    129a <ldtoa+0x13a>
mov    %r14d,%eax
mov    %r14d,0x1c(%rsp)
fldz
fldt   0x44(%rsp)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jbe    12b4 <ldtoa+0x154>
movslq %r14d,%rax
add    $0x1,%r14d
movb   $0x2d,0x50(%rsp,%rax,1)
test   %r14d,%r14d
jle    1455 <ldtoa+0x2f5>
mov    %r14d,%edi
cmp    $0x8,%r14d
jae    12cd <ldtoa+0x16d>
xor    %ecx,%ecx
jmp    13f6 <ldtoa+0x296>
lea    -0x1(%rdi),%rsi
lea    -0x1(%r14),%edx
mov    %edx,%eax
sub    %esi,%eax
xor    %ecx,%ecx
cmp    %edx,%eax
jg     13f6 <ldtoa+0x296>
shr    $0x20,%rsi
jne    13f6 <ldtoa+0x296>
cmp    $0x20,%r14d
jae    12fa <ldtoa+0x19a>
xor    %ecx,%ecx
jmp    13a5 <ldtoa+0x245>
mov    %edi,%ecx
and    $0xffffffe0,%ecx
xor    %esi,%esi
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movslq %edx,%rdx
movdqu 0x31(%rsp,%rdx,1),%xmm1
movdqu 0x41(%rsp,%rdx,1),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,(%rbx,%rsi,1)
movdqu %xmm1,0x10(%rbx,%rsi,1)
add    $0x20,%rsi
add    $0xffffffe0,%edx
cmp    %rsi,%rcx
jne    1310 <ldtoa+0x1b0>
cmp    %rdi,%rcx
je     1455 <ldtoa+0x2f5>
test   $0x18,%dil
je     13f6 <ldtoa+0x296>
mov    %rcx,%rdx
mov    %edi,%ecx
and    $0xfffffff8,%ecx
mov    %edx,%esi
not    %esi
add    %r14d,%esi
pxor   %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movslq %esi,%rsi
movq   0x49(%rsp,%rsi,1),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rbx,%rdx,1)
add    $0x8,%rdx
add    $0xfffffff8,%esi
cmp    %rdx,%rcx
jne    13c0 <ldtoa+0x260>
cmp    %rdi,%rcx
je     1455 <ldtoa+0x2f5>
mov    %rcx,%rdx
not    %rdx
test   $0x1,%dil
je     1417 <ldtoa+0x2b7>
mov    %ecx,%esi
not    %esi
add    %r14d,%esi
movslq %esi,%rsi
mov    0x50(%rsp,%rsi,1),%al
mov    %al,(%rbx,%rcx,1)
or     $0x1,%rcx
add    %rdi,%rdx
je     1455 <ldtoa+0x2f5>
sub    %rcx,%rdi
mov    %ecx,%edx
not    %edx
add    %r14d,%edx
add    %rbx,%rcx
add    $0x1,%rcx
xor    %esi,%esi
nop
movslq %edx,%rdx
movzbl 0x50(%rsp,%rdx,1),%eax
mov    %al,-0x1(%rcx,%rsi,1)
lea    -0x1(%rdx),%eax
cltq
movzbl 0x50(%rsp,%rax,1),%eax
mov    %al,(%rcx,%rsi,1)
add    $0x2,%rsi
add    $0xfffffffe,%edx
cmp    %rsi,%rdi
jne    1430 <ldtoa+0x2d0>
test   %r12d,%r12d
jne    1465 <ldtoa+0x305>
movslq %r14d,%rax
add    $0x1,%r14d
movb   $0x2e,(%rbx,%rax,1)
fldz
fxch   %st(1)
fucomi %st(1),%st
fstp   %st(1)
mov    %r12d,0x28(%rsp)
jbe    151f <ldtoa+0x3bf>
test   %r12d,%r12d
sete   %r12b
test   %ebp,%ebp
js     151f <ldtoa+0x3bf>
fstp   %st(1)
lea    0x30(%rsp),%r13
fldz
fstp   %st(0)
fmuls  0xb68(%rip)
fstpt  (%rsp)
mov    %r13,%rdi
call   1070 <modld@plt>
fldt   0x30(%rsp)
fldz
fucomip %st(1),%st
setp   %cl
setne  %al
test   %r15d,%r15d
jne    14d0 <ldtoa+0x370>
or     %cl,%al
or     %r12b,%al
jne    14d0 <ldtoa+0x370>
addl   $0xffffffff,0x1c(%rsp)
xor    %r15d,%r15d
jmp    1506 <ldtoa+0x3a6>
nopw   0x0(%rax,%rax,1)
fnstcw 0x18(%rsp)
movzwl 0x18(%rsp),%eax
or     $0xc00,%eax
mov    %ax,0x1a(%rsp)
fldcw  0x1a(%rsp)
fistl  0x2c(%rsp)
fldcw  0x18(%rsp)
movzbl 0x2c(%rsp),%eax
add    $0x30,%al
movslq %r14d,%rcx
add    $0x1,%r14d
mov    %al,(%rbx,%rcx,1)
mov    $0x1,%r15d
fldz
fxch   %st(2)
fucomi %st(2),%st
fstp   %st(2)
jbe    1521 <ldtoa+0x3c1>
lea    -0x1(%rbp),%eax
test   %ebp,%ebp
mov    %eax,%ebp
jg     1490 <ldtoa+0x330>
jmp    1521 <ldtoa+0x3c1>
fxch   %st(1)
fldz
fxch   %st(2)
fucomip %st(2),%st
fstp   %st(1)
jne    152d <ldtoa+0x3cd>
jnp    1542 <ldtoa+0x3e2>
fstp   %st(0)
mov    %r14d,%eax
mov    0x28(%rsp),%ecx
test   %ecx,%ecx
jne    1570 <ldtoa+0x410>
cltq
movb   $0x0,(%rbx,%rax,1)
jmp    15aa <ldtoa+0x44a>
movslq %r14d,%rcx
lea    0x1(%rcx),%rax
movb   $0x30,(%rbx,%rcx,1)
mov    0x28(%rsp),%ecx
test   %ecx,%ecx
je     15bf <ldtoa+0x45f>
fldz
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    156c <ldtoa+0x40c>
jp     156c <ldtoa+0x40c>
add    $0x2,%r14d
movb   $0x30,(%rbx,%rax,1)
mov    %r14d,%eax
test   %ecx,%ecx
je     153a <ldtoa+0x3da>
xor    %ecx,%ecx
mov    0x17(%rsp),%dl
mov    %dl,%cl
add    $0x1,%ecx
movslq %eax,%rbp
lea    0x1(%rbp),%rsi
mov    %rbx,%rdi
mov    $0x2e,%edx
call   1080 <insert_char@plt>
movb   $0x65,0x1(%rbx,%rbp,1)
lea    (%rbx,%rbp,1),%rsi
add    $0x2,%rsi
mov    0x1c(%rsp),%edi
mov    $0xfffffff6,%edx
call   1060 <lltoa@plt>
mov    %rbx,%rax
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
fstp   %st(0)
test   %ecx,%ecx
jne    1570 <ldtoa+0x410>
jmp    153a <ldtoa+0x3da>
fstp   %st(0)
lea    0xa31(%rip),%rbx
jmp    15aa <ldtoa+0x44a>

LLVM IR (-O0):
@.str = [4 x i8] c"nan\00"
@LDBL_MAX = global x86_fp80 0xK00000000000000000000
@.str.1 = [4 x i8] c"inf\00"
@LDBL_MIN = global x86_fp80 0xK00000000000000000000
@.str.2 = [5 x i8] c"-inf\00"
define i8* @ldtoa(x86_fp80 %0, i8* %1, i32 %2, i32 %3) {
%5 = alloca i8*
%6 = alloca x86_fp80
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32
%10 = alloca [311 x i8]
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca x86_fp80
%15 = alloca x86_fp80
%16 = alloca i32
%17 = alloca i32
store x86_fp80 %0, x86_fp80* %6
store i8* %1, i8** %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store i32 0, i32* %12
store i32 0, i32* %13
store i32 0, i32* %16
store i32 0, i32* %17
%18 = load x86_fp80, x86_fp80* %6
%19 = load x86_fp80, x86_fp80* %6
%20 = fcmp une x86_fp80 %18, %19
br i1 %20, label %21, label %22
21: ; preds = %4
store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8** %7
store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8** %5
br label %200
22: ; preds = %4
%23 = load x86_fp80, x86_fp80* %6
%24 = load x86_fp80, x86_fp80* @LDBL_MAX
%25 = fcmp oeq x86_fp80 %23, %24
br i1 %25, label %26, label %27
26: ; preds = %22
store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i8** %7
store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i8** %5
br label %200
27: ; preds = %22
%28 = load x86_fp80, x86_fp80* %6
%29 = load x86_fp80, x86_fp80* @LDBL_MIN
%30 = fcmp oeq x86_fp80 %28, %29
br i1 %30, label %31, label %32
31: ; preds = %27
store i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i8** %7
store i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i8** %5
br label %200
32: ; preds = %27
br label %33
33: ; preds = %32
br label %34
34: ; preds = %33
%35 = load x86_fp80, x86_fp80* %6
%36 = fcmp olt x86_fp80 %35, 0xK00000000000000000000
br i1 %36, label %37, label %40
37: ; preds = %34
store i32 1, i32* %16
%38 = load x86_fp80, x86_fp80* %6
%39 = fneg x86_fp80 %38
store x86_fp80 %39, x86_fp80* %6
br label %40
40: ; preds = %37, %34
%41 = load x86_fp80, x86_fp80* %6
%42 = call x86_fp80 @modld(x86_fp80 %41, x86_fp80* %14)
store x86_fp80 %42, x86_fp80* %15
%43 = load x86_fp80, x86_fp80* %15
%44 = load i32, i32* %8
%45 = call x86_fp80 @precise_round(x86_fp80 %43, i32 %44)
store x86_fp80 %45, x86_fp80* %15
br label %46
46: ; preds = %49, %40
%47 = load x86_fp80, x86_fp80* %14
%48 = fcmp ogt x86_fp80 %47, 0xK00000000000000000000
br i1 %48, label %49, label %64
49: ; preds = %46
%50 = load x86_fp80, x86_fp80* %14
%51 = call i64 @fmod(x86_fp80 %50, i32 10)
%52 = trunc i64 %51 to i32
%53 = add nsw i32 48, %52
%54 = trunc i32 %53 to i8
%55 = load i32, i32* %12
%56 = add nsw i32 %55, 1
store i32 %56, i32* %12
%57 = sext i32 %55 to i64
%58 = getelementptr inbounds [311 x i8], [311 x i8]* %10, i64 0, i64 %57
store i8 %54, i8* %58
%59 = load x86_fp80, x86_fp80* %14
%60 = fdiv x86_fp80 %59, 0xK4002A000000000000000
%61 = call x86_fp80 @floorld(x86_fp80 %60)
store x86_fp80 %61, x86_fp80* %14
%62 = load i32, i32* %13
%63 = add nsw i32 %62, 1
store i32 %63, i32* %13
store i32 1, i32* %17
br label %46
64: ; preds = %46
%65 = load x86_fp80, x86_fp80* %14
%66 = fcmp oeq x86_fp80 %65, 0xK00000000000000000000
br i1 %66, label %67, label %76
67: ; preds = %64
store i32 -1, i32* %13
%68 = load i32, i32* %9
%69 = icmp ne i32 %68, 0
br i1 %69, label %75, label %70
70: ; preds = %67
%71 = load i32, i32* %12
%72 = add nsw i32 %71, 1
store i32 %72, i32* %12
%73 = sext i32 %71 to i64
%74 = getelementptr inbounds [311 x i8], [311 x i8]* %10, i64 0, i64 %73
store i8 48, i8* %74
br label %75
75: ; preds = %70, %67
br label %76
76: ; preds = %75, %64
%77 = load i32, i32* %16
%78 = icmp ne i32 %77, 0
br i1 %78, label %79, label %84
79: ; preds = %76
%80 = load i32, i32* %12
%81 = add nsw i32 %80, 1
store i32 %81, i32* %12
%82 = sext i32 %80 to i64
%83 = getelementptr inbounds [311 x i8], [311 x i8]* %10, i64 0, i64 %82
store i8 45, i8* %83
br label %84
84: ; preds = %79, %76
store i32 0, i32* %11
br label %85
85: ; preds = %101, %84
%86 = load i32, i32* %11
%87 = load i32, i32* %12
%88 = icmp slt i32 %86, %87
br i1 %88, label %89, label %104
89: ; preds = %85
%90 = load i32, i32* %12
%91 = load i32, i32* %11
%92 = sub nsw i32 %90, %91
%93 = sub nsw i32 %92, 1
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds [311 x i8], [311 x i8]* %10, i64 0, i64 %94
%96 = load i8, i8* %95
%97 = load i8*, i8** %7
%98 = load i32, i32* %11
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds i8, i8* %97, i64 %99
store i8 %96, i8* %100
br label %101
101: ; preds = %89
%102 = load i32, i32* %11
%103 = add nsw i32 %102, 1
store i32 %103, i32* %11
br label %85
104: ; preds = %85
%105 = load i32, i32* %9
%106 = icmp ne i32 %105, 0
br i1 %106, label %113, label %107
107: ; preds = %104
%108 = load i8*, i8** %7
%109 = load i32, i32* %12
%110 = add nsw i32 %109, 1
store i32 %110, i32* %12
%111 = sext i32 %109 to i64
%112 = getelementptr inbounds i8, i8* %108, i64 %111
store i8 46, i8* %112
br label %113
113: ; preds = %107, %104
br label %114
114: ; preds = %149, %113
%115 = load x86_fp80, x86_fp80* %15
%116 = fcmp ogt x86_fp80 %115, 0xK00000000000000000000
br i1 %116, label %117, label %121
117: ; preds = %114
%118 = load i32, i32* %8
%119 = add nsw i32 %118, -1
store i32 %119, i32* %8
%120 = icmp sge i32 %118, 0
br label %121
121: ; preds = %117, %114
%122 = phi i1 [ false, %114 ], [ %120, %117 ]
br i1 %122, label %123, label %150
123: ; preds = %121
%124 = load x86_fp80, x86_fp80* %15
%125 = fmul x86_fp80 %124, 0xK4002A000000000000000
store x86_fp80 %125, x86_fp80* %15
%126 = load x86_fp80, x86_fp80* %15
%127 = call x86_fp80 @modld(x86_fp80 %126, x86_fp80* %14)
store x86_fp80 %127, x86_fp80* %15
%128 = load i32, i32* %9
%129 = icmp ne i32 %128, 0
br i1 %129, label %130, label %139
130: ; preds = %123
%131 = load x86_fp80, x86_fp80* %14
%132 = fcmp oeq x86_fp80 %131, 0xK00000000000000000000
br i1 %132, label %133, label %139
133: ; preds = %130
%134 = load i32, i32* %17
%135 = icmp ne i32 %134, 0
br i1 %135, label %139, label %136
136: ; preds = %133
%137 = load i32, i32* %13
%138 = add nsw i32 %137, -1
store i32 %138, i32* %13
br label %149
139: ; preds = %133, %130, %123
store i32 1, i32* %17
%140 = load x86_fp80, x86_fp80* %14
%141 = fptosi x86_fp80 %140 to i32
%142 = add nsw i32 48, %141
%143 = trunc i32 %142 to i8
%144 = load i8*, i8** %7
%145 = load i32, i32* %12
%146 = add nsw i32 %145, 1
store i32 %146, i32* %12
%147 = sext i32 %145 to i64
%148 = getelementptr inbounds i8, i8* %144, i64 %147
store i8 %143, i8* %148
br label %149
149: ; preds = %139, %136
br label %114
150: ; preds = %121
%151 = load x86_fp80, x86_fp80* %15
%152 = fcmp une x86_fp80 %151, 0xK00000000000000000000
br i1 %152, label %171, label %153
153: ; preds = %150
%154 = load i8*, i8** %7
%155 = load i32, i32* %12
%156 = add nsw i32 %155, 1
store i32 %156, i32* %12
%157 = sext i32 %155 to i64
%158 = getelementptr inbounds i8, i8* %154, i64 %157
store i8 48, i8* %158
%159 = load x86_fp80, x86_fp80* %14
%160 = fcmp une x86_fp80 %159, 0xK00000000000000000000
br i1 %160, label %170, label %161
161: ; preds = %153
%162 = load i32, i32* %9
%163 = icmp ne i32 %162, 0
br i1 %163, label %164, label %170
164: ; preds = %161
%165 = load i8*, i8** %7
%166 = load i32, i32* %12
%167 = add nsw i32 %166, 1
store i32 %167, i32* %12
%168 = sext i32 %166 to i64
%169 = getelementptr inbounds i8, i8* %165, i64 %168
store i8 48, i8* %169
br label %170
170: ; preds = %164, %161, %153
br label %171
171: ; preds = %170, %150
%172 = load i32, i32* %9
%173 = icmp ne i32 %172, 0
br i1 %173, label %174, label %193
174: ; preds = %171
%175 = load i8*, i8** %7
%176 = load i32, i32* %12
%177 = add nsw i32 %176, 1
store i32 %177, i32* %12
%178 = add nsw i32 %176, 1
%179 = load i32, i32* %16
%180 = add nsw i32 1, %179
%181 = call i32 @insert_char(i8* %175, i32 %178, i8 signext 46, i32 %180)
%182 = load i8*, i8** %7
%183 = load i32, i32* %12
%184 = add nsw i32 %183, 1
store i32 %184, i32* %12
%185 = sext i32 %183 to i64
%186 = getelementptr inbounds i8, i8* %182, i64 %185
store i8 101, i8* %186
%187 = load i32, i32* %13
%188 = load i8*, i8** %7
%189 = load i32, i32* %12
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds i8, i8* %188, i64 %190
%192 = call i32 @lltoa(i32 %187, i8* %191, i32 -10)
br label %198
193: ; preds = %171
%194 = load i8*, i8** %7
%195 = load i32, i32* %12
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds i8, i8* %194, i64 %196
store i8 0, i8* %197
br label %198
198: ; preds = %193, %174
%199 = load i8*, i8** %7
store i8* %199, i8** %5
br label %200
200: ; preds = %198, %31, %26, %21
%201 = load i8*, i8** %5
ret i8* %201
}

LLVM IR (-O2):
@.str = [4 x i8] c"nan\00"
@LDBL_MAX = global x86_fp80 0xK00000000000000000000
@.str.1 = [4 x i8] c"inf\00"
@LDBL_MIN = global x86_fp80 0xK00000000000000000000
@.str.2 = [5 x i8] c"-inf\00"
define i8* @ldtoa(x86_fp80 %0, i8* %1, i32 %2, i32 %3) {
%5 = alloca [311 x i8]
%6 = alloca x86_fp80
%7 = getelementptr inbounds [311 x i8], [311 x i8]* %5, i64 0, i64 0
%8 = bitcast x86_fp80* %6 to i8*
%9 = fcmp uno x86_fp80 %0, 0xK00000000000000000000
br i1 %9, label %230, label %10
10: ; preds = %4
%11 = load x86_fp80, x86_fp80* @LDBL_MAX
%12 = fcmp oeq x86_fp80 %11, %0
br i1 %12, label %230, label %13
13: ; preds = %10
%14 = load x86_fp80, x86_fp80* @LDBL_MIN
%15 = fcmp oeq x86_fp80 %14, %0
br i1 %15, label %230, label %16
16: ; preds = %13
%17 = fcmp olt x86_fp80 %0, 0xK00000000000000000000
%18 = fneg x86_fp80 %0
%19 = select i1 %17, x86_fp80 %18, x86_fp80 %0
%20 = select i1 %17, i32 2, i32 1
%21 = call x86_fp80 @modld(x86_fp80 %19, x86_fp80* %6)
%22 = call x86_fp80 @precise_round(x86_fp80 %21, i32 %2)
%23 = load x86_fp80, x86_fp80* %6
%24 = fcmp ogt x86_fp80 %23, 0xK00000000000000000000
br i1 %24, label %25, label %39
25: ; preds = %16, %25
%26 = phi i64 [ %31, %25 ], [ 0, %16 ]
%27 = phi x86_fp80 [ %35, %25 ], [ %23, %16 ]
%28 = call i64 @fmod(x86_fp80 %27, i32 10)
%29 = trunc i64 %28 to i8
%30 = add i8 %29, 48
%31 = add nuw i64 %26, 1
%32 = getelementptr inbounds [311 x i8], [311 x i8]* %5, i64 0, i64 %26
store i8 %30, i8* %32
%33 = load x86_fp80, x86_fp80* %6
%34 = fdiv x86_fp80 %33, 0xK4002A000000000000000
%35 = call x86_fp80 @floorld(x86_fp80 %34)
store x86_fp80 %35, x86_fp80* %6
%36 = fcmp ogt x86_fp80 %35, 0xK00000000000000000000
br i1 %36, label %25, label %37
37: ; preds = %25
%38 = trunc i64 %31 to i32
br label %39
39: ; preds = %37, %16
%40 = phi x86_fp80 [ %23, %16 ], [ %35, %37 ]
%41 = phi i32 [ 0, %16 ], [ %38, %37 ]
%42 = phi i32 [ 0, %16 ], [ 1, %37 ]
%43 = fcmp oeq x86_fp80 %40, 0xK00000000000000000000
br i1 %43, label %44, label %50
44: ; preds = %39
%45 = icmp eq i32 %3, 0
br i1 %45, label %46, label %50
46: ; preds = %44
%47 = add nuw nsw i32 %41, 1
%48 = zext i32 %41 to i64
%49 = getelementptr inbounds [311 x i8], [311 x i8]* %5, i64 0, i64 %48
store i8 48, i8* %49
br label %50
50: ; preds = %44, %46, %39
%51 = phi i32 [ %41, %44 ], [ %47, %46 ], [ %41, %39 ]
%52 = phi i32 [ -1, %44 ], [ -1, %46 ], [ %41, %39 ]
br i1 %17, label %53, label %57
53: ; preds = %50
%54 = add nsw i32 %51, 1
%55 = sext i32 %51 to i64
%56 = getelementptr inbounds [311 x i8], [311 x i8]* %5, i64 0, i64 %55
store i8 45, i8* %56
br label %57
57: ; preds = %53, %50
%58 = phi i32 [ %54, %53 ], [ %51, %50 ]
%59 = icmp sgt i32 %58, 0
br i1 %59, label %60, label %158
60: ; preds = %57
%61 = zext i32 %58 to i64
%62 = icmp ult i32 %58, 8
br i1 %62, label %121, label %63
63: ; preds = %60
%64 = add nsw i64 %61, -1
%65 = add i32 %58, -1
%66 = trunc i64 %64 to i32
%67 = sub i32 %65, %66
%68 = icmp sgt i32 %67, %65
%69 = icmp ugt i64 %64, 4294967295
%70 = or i1 %68, %69
br i1 %70, label %121, label %71
71: ; preds = %63
%72 = icmp ult i32 %58, 32
br i1 %72, label %101, label %73
73: ; preds = %71
%74 = and i64 %61, 4294967264
br label %75
75: ; preds = %75, %73
%76 = phi i64 [ 0, %73 ], [ %94, %75 ]
%77 = trunc i64 %76 to i32
%78 = xor i32 %77, -1
%79 = add i32 %58, %78
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds [311 x i8], [311 x i8]* %5, i64 0, i64 %80
%82 = getelementptr inbounds i8, i8* %81, i64 -15
%83 = bitcast i8* %82 to <16 x i8>*
%84 = load <16 x i8>, <16 x i8>* %83
%85 = shufflevector <16 x i8> %84, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%86 = getelementptr inbounds i8, i8* %81, i64 -31
%87 = bitcast i8* %86 to <16 x i8>*
%88 = load <16 x i8>, <16 x i8>* %87
%89 = shufflevector <16 x i8> %88, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%90 = getelementptr inbounds i8, i8* %1, i64 %76
%91 = bitcast i8* %90 to <16 x i8>*
store <16 x i8> %85, <16 x i8>* %91
%92 = getelementptr inbounds i8, i8* %90, i64 16
%93 = bitcast i8* %92 to <16 x i8>*
store <16 x i8> %89, <16 x i8>* %93
%94 = add nuw i64 %76, 32
%95 = icmp eq i64 %94, %74
br i1 %95, label %96, label %75
96: ; preds = %75
%97 = icmp eq i64 %74, %61
br i1 %97, label %158, label %98
98: ; preds = %96
%99 = and i64 %61, 24
%100 = icmp eq i64 %99, 0
br i1 %100, label %121, label %101
101: ; preds = %71, %98
%102 = phi i64 [ %74, %98 ], [ 0, %71 ]
%103 = and i64 %61, 4294967288
br label %104
104: ; preds = %104, %101
%105 = phi i64 [ %102, %101 ], [ %117, %104 ]
%106 = trunc i64 %105 to i32
%107 = xor i32 %106, -1
%108 = add i32 %58, %107
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds [311 x i8], [311 x i8]* %5, i64 0, i64 %109
%111 = getelementptr inbounds i8, i8* %110, i64 -7
%112 = bitcast i8* %111 to <8 x i8>*
%113 = load <8 x i8>, <8 x i8>* %112
%114 = shufflevector <8 x i8> %113, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%115 = getelementptr inbounds i8, i8* %1, i64 %105
%116 = bitcast i8* %115 to <8 x i8>*
store <8 x i8> %114, <8 x i8>* %116
%117 = add nuw i64 %105, 8
%118 = icmp eq i64 %117, %103
br i1 %118, label %119, label %104
119: ; preds = %104
%120 = icmp eq i64 %103, %61
br i1 %120, label %158, label %121
121: ; preds = %63, %60, %98, %119
%122 = phi i64 [ 0, %60 ], [ 0, %63 ], [ %74, %98 ], [ %103, %119 ]
%123 = xor i64 %122, -1
%124 = and i64 %61, 1
%125 = icmp eq i64 %124, 0
br i1 %125, label %135, label %126
126: ; preds = %121
%127 = trunc i64 %122 to i32
%128 = xor i32 %127, -1
%129 = add i32 %58, %128
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds [311 x i8], [311 x i8]* %5, i64 0, i64 %130
%132 = load i8, i8* %131
%133 = getelementptr inbounds i8, i8* %1, i64 %122
store i8 %132, i8* %133
%134 = or i64 %122, 1
br label %135
135: ; preds = %126, %121
%136 = phi i64 [ %122, %121 ], [ %134, %126 ]
%137 = sub nsw i64 0, %61
%138 = icmp eq i64 %123, %137
br i1 %138, label %158, label %139
139: ; preds = %135, %139
%140 = phi i64 [ %156, %139 ], [ %136, %135 ]
%141 = trunc i64 %140 to i32
%142 = xor i32 %141, -1
%143 = add i32 %58, %142
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds [311 x i8], [311 x i8]* %5, i64 0, i64 %144
%146 = load i8, i8* %145
%147 = getelementptr inbounds i8, i8* %1, i64 %140
store i8 %146, i8* %147
%148 = add nuw nsw i64 %140, 1
%149 = trunc i64 %148 to i32
%150 = xor i32 %149, -1
%151 = add i32 %58, %150
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds [311 x i8], [311 x i8]* %5, i64 0, i64 %152
%154 = load i8, i8* %153
%155 = getelementptr inbounds i8, i8* %1, i64 %148
store i8 %154, i8* %155
%156 = add nuw nsw i64 %140, 2
%157 = icmp eq i64 %156, %61
br i1 %157, label %158, label %139
158: ; preds = %135, %139, %96, %119, %57
%159 = icmp ne i32 %3, 0
br i1 %159, label %164, label %160
160: ; preds = %158
%161 = add nsw i32 %58, 1
%162 = sext i32 %58 to i64
%163 = getelementptr inbounds i8, i8* %1, i64 %162
store i8 46, i8* %163
br label %164
164: ; preds = %160, %158
%165 = phi i32 [ %58, %158 ], [ %161, %160 ]
%166 = fcmp ogt x86_fp80 %22, 0xK00000000000000000000
br i1 %166, label %167, label %200
167: ; preds = %164
%168 = xor i1 %159, true
%169 = icmp sgt i32 %2, -1
br i1 %169, label %170, label %200
170: ; preds = %167, %193
%171 = phi i32 [ %176, %193 ], [ %2, %167 ]
%172 = phi i32 [ %194, %193 ], [ %165, %167 ]
%173 = phi i32 [ %195, %193 ], [ %52, %167 ]
%174 = phi x86_fp80 [ %178, %193 ], [ %22, %167 ]
%175 = phi i32 [ %196, %193 ], [ %42, %167 ]
%176 = add nsw i32 %171, -1
%177 = fmul x86_fp80 %174, 0xK4002A000000000000000
%178 = call x86_fp80 @modld(x86_fp80 %177, x86_fp80* %6)
%179 = load x86_fp80, x86_fp80* %6
%180 = fcmp une x86_fp80 %179, 0xK00000000000000000000
%181 = select i1 %168, i1 true, i1 %180
%182 = icmp ne i32 %175, 0
%183 = or i1 %182, %181
br i1 %183, label %186, label %184
184: ; preds = %170
%185 = add nsw i32 %173, -1
br label %193
186: ; preds = %170
%187 = fptosi x86_fp80 %179 to i32
%188 = trunc i32 %187 to i8
%189 = add i8 %188, 48
%190 = add nsw i32 %172, 1
%191 = sext i32 %172 to i64
%192 = getelementptr inbounds i8, i8* %1, i64 %191
store i8 %189, i8* %192
br label %193
193: ; preds = %186, %184
%194 = phi i32 [ %190, %186 ], [ %172, %184 ]
%195 = phi i32 [ %173, %186 ], [ %185, %184 ]
%196 = phi i32 [ 1, %186 ], [ 0, %184 ]
%197 = fcmp ogt x86_fp80 %178, 0xK00000000000000000000
%198 = icmp sgt i32 %171, 0
%199 = select i1 %197, i1 %198, i1 false
br i1 %199, label %170, label %200
200: ; preds = %193, %167, %164
%201 = phi x86_fp80 [ %40, %164 ], [ %40, %167 ], [ %179, %193 ]
%202 = phi i32 [ %165, %164 ], [ %165, %167 ], [ %194, %193 ]
%203 = phi i32 [ %52, %164 ], [ %52, %167 ], [ %195, %193 ]
%204 = phi x86_fp80 [ %22, %164 ], [ %22, %167 ], [ %178, %193 ]
%205 = fcmp une x86_fp80 %204, 0xK00000000000000000000
br i1 %205, label %216, label %206
206: ; preds = %200
%207 = add nsw i32 %202, 1
%208 = sext i32 %202 to i64
%209 = getelementptr inbounds i8, i8* %1, i64 %208
store i8 48, i8* %209
%210 = fcmp oeq x86_fp80 %201, 0xK00000000000000000000
%211 = and i1 %159, %210
br i1 %211, label %212, label %216
212: ; preds = %206
%213 = add nsw i32 %202, 2
%214 = sext i32 %207 to i64
%215 = getelementptr inbounds i8, i8* %1, i64 %214
store i8 48, i8* %215
br label %216
216: ; preds = %206, %212, %200
%217 = phi i32 [ %202, %200 ], [ %213, %212 ], [ %207, %206 ]
br i1 %159, label %218, label %227
218: ; preds = %216
%219 = add nsw i32 %217, 1
%220 = call i32 @insert_char(i8* %1, i32 %219, i8 signext 46, i32 %20)
%221 = add nsw i32 %217, 2
%222 = sext i32 %219 to i64
%223 = getelementptr inbounds i8, i8* %1, i64 %222
store i8 101, i8* %223
%224 = sext i32 %221 to i64
%225 = getelementptr inbounds i8, i8* %1, i64 %224
%226 = call i32 @lltoa(i32 %203, i8* %225, i32 -10)
br label %230
227: ; preds = %216
%228 = sext i32 %217 to i64
%229 = getelementptr inbounds i8, i8* %1, i64 %228
store i8 0, i8* %229
br label %230
230: ; preds = %218, %227, %13, %10, %4
%231 = phi i8* [ getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), %4 ], [ getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), %10 ], [ getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), %13 ], [ %1, %227 ], [ %1, %218 ]
ret i8* %231
}