#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 */
int floor(double);
scalar_t__ isnan(double);
int log10(double);
int /*<<< orphan*/ memcpy(char *, char *, int);
double pow(double, int);
char *dtoa(double n, char *s) {
  if (isnan(n)) {
    memcpy(s, "nan", 4);
  } else if ((n == -n)) {
    memcpy(s, "inf", 4);
  } else if (n == 0.0) {
    memcpy(s, "0", 2);
  } else {
    int digit, m, m1;
    char *c = s;
    int neg = (n < 0);
    if (neg)
      n = -n;
    m = log10(n);
    int useExp = (m >= 14 || (neg && m >= 9) || m <= -9);
    if (neg)
      *(c++) = '-';
    if (useExp) {
      if (m < 0)
        m -= 1.0;
      n = n / pow(10.0, m);
      m1 = m;
      m = 0;
    }
    if (m < 1.0) {
      m = 0;
    }
    while (n > 0.00000000000001 || m >= 0) {
      double weight = pow(10.0, m);
      if (weight > 0 && !(weight == -weight)) {
        digit = floor(n / weight);
        n -= (digit * weight);
        *(c++) = '0' + digit;
      }
      if (m == 0 && n > 0)
        *(c++) = '.';
      m--;
    }
    if (useExp) {
      int i, j;
      *(c++) = 'e';
      if (m1 > 0) {
        *(c++) = '+';
      } else {
        *(c++) = '-';
        m1 = -m1;
      }
      m = 0;
      while (m1 > 0) {
        *(c++) = '0' + m1 % 10;
        m1 /= 10;
        m++;
      }
      c -= m;
      for (i = 0, j = m - 1; i < j; i++, j--) {
        c[i] ^= c[j];
        c[j] ^= c[i];
        c[i] ^= c[j];
      }
      c += m;
    }
    *(c) = '\0';
  }
  return s;
}


x86 assembly (clang, -O0):
<dtoa>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
movsd  %xmm0,-0x8(%rbp)
mov    %rdi,-0x10(%rbp)
movsd  -0x8(%rbp),%xmm0
call   1040 <isnan@plt>
cmp    $0x0,%rax
je     118f <dtoa+0x3f>
mov    -0x10(%rbp),%rdi
lea    0xe98(%rip),%rsi
mov    $0x4,%edx
call   1030 <memcpy@plt>
jmp    15d3 <dtoa+0x483>
movsd  -0x8(%rbp),%xmm0
movsd  -0x8(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
ucomisd %xmm1,%xmm0
jne    11da <dtoa+0x8a>
jp     11da <dtoa+0x8a>
mov    -0x10(%rbp),%rdi
lea    0xe51(%rip),%rsi
mov    $0x4,%edx
call   1030 <memcpy@plt>
jmp    15ce <dtoa+0x47e>
movsd  -0x8(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    120c <dtoa+0xbc>
jp     120c <dtoa+0xbc>
mov    -0x10(%rbp),%rdi
lea    0xe23(%rip),%rsi
mov    $0x2,%edx
call   1030 <memcpy@plt>
jmp    15c9 <dtoa+0x479>
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x8(%rbp),%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     1252 <dtoa+0x102>
movsd  -0x8(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
call   1060 <log10@plt>
mov    %eax,-0x18(%rbp)
mov    $0x1,%al
cmpl   $0xe,-0x18(%rbp)
mov    %al,-0x41(%rbp)
jge    1291 <dtoa+0x141>
cmpl   $0x0,-0x2c(%rbp)
je     1287 <dtoa+0x137>
mov    $0x1,%al
cmpl   $0x9,-0x18(%rbp)
mov    %al,-0x41(%rbp)
jge    1291 <dtoa+0x141>
cmpl   $0xfffffff7,-0x18(%rbp)
setle  %al
mov    %al,-0x41(%rbp)
mov    -0x41(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     12b8 <dtoa+0x168>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x2d,(%rax)
cmpl   $0x0,-0x30(%rbp)
je     131c <dtoa+0x1cc>
cmpl   $0x0,-0x18(%rbp)
jge    12e4 <dtoa+0x194>
cvtsi2sdl -0x18(%rbp),%xmm0
movsd  0xd27(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x18(%rbp)
movsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x18(%rbp),%edi
movsd  0xd0f(%rip),%xmm0
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x18(%rbp)
cvtsi2sdl -0x18(%rbp),%xmm1
movsd  0xcd7(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    133a <dtoa+0x1ea>
movl   $0x0,-0x18(%rbp)
jmp    133f <dtoa+0x1ef>
movsd  -0x8(%rbp),%xmm0
mov    $0x1,%al
movsd  0xcc2(%rip),%xmm1
ucomisd %xmm1,%xmm0
mov    %al,-0x51(%rbp)
ja     1365 <dtoa+0x215>
cmpl   $0x0,-0x18(%rbp)
setge  %al
mov    %al,-0x51(%rbp)
mov    -0x51(%rbp),%al
test   $0x1,%al
jne    1375 <dtoa+0x225>
jmp    146c <dtoa+0x31c>
mov    -0x18(%rbp),%edi
movsd  0xc88(%rip),%xmm0
call   1050 <pow@plt>
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1430 <dtoa+0x2e0>
movsd  -0x38(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
ucomisd %xmm1,%xmm0
jne    13d2 <dtoa+0x282>
jp     13d2 <dtoa+0x282>
jmp    1430 <dtoa+0x2e0>
movsd  -0x8(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
call   1070 <floor@plt>
mov    %eax,-0x14(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
movsd  -0x8(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%rbp)
mov    -0x14(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
cmpl   $0x0,-0x18(%rbp)
jne    145e <dtoa+0x30e>
movsd  -0x8(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    145e <dtoa+0x30e>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x2e,(%rax)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    133f <dtoa+0x1ef>
cmpl   $0x0,-0x30(%rbp)
je     15c2 <dtoa+0x472>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x65,(%rax)
cmpl   $0x0,-0x1c(%rbp)
jle    14a9 <dtoa+0x359>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x2b,(%rax)
jmp    14c3 <dtoa+0x373>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x2d,(%rax)
xor    %eax,%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x18(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jle    1511 <dtoa+0x3c1>
mov    -0x1c(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x1c(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    14ca <dtoa+0x37a>
mov    -0x18(%rbp),%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    15b1 <dtoa+0x461>
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%esi
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%esi
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%esi
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    1537 <dtoa+0x3e7>
mov    -0x18(%rbp),%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movb   $0x0,(%rax)
jmp    15ce <dtoa+0x47e>
jmp    15d3 <dtoa+0x483>
mov    -0x10(%rbp),%rax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dtoa>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x20,%rsp
mov    %rdi,%r14
movapd %xmm0,0x10(%rsp)
call   1040 <isnan@plt>
test   %rax,%rax
je     1178 <dtoa+0x28>
lea    0xeb2(%rip),%rsi
jmp    1199 <dtoa+0x49>
movapd 0xe80(%rip),%xmm2
movapd 0x10(%rsp),%xmm3
xorpd  %xmm3,%xmm2
ucomisd %xmm3,%xmm2
jne    11b6 <dtoa+0x66>
jp     11b6 <dtoa+0x66>
lea    0xe93(%rip),%rsi
mov    %r14,%rdi
mov    $0x4,%edx
call   1030 <memcpy@plt>
mov    %r14,%rax
add    $0x20,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm3
jne    11d3 <dtoa+0x83>
jp     11d3 <dtoa+0x83>
lea    0xe67(%rip),%rsi
mov    %r14,%rdi
mov    $0x2,%edx
jmp    11a1 <dtoa+0x51>
movapd %xmm3,%xmm0
cmpltsd %xmm1,%xmm0
andpd  %xmm0,%xmm2
andnpd %xmm3,%xmm0
orpd   %xmm2,%xmm0
movapd %xmm0,(%rsp)
call   1060 <log10@plt>
movapd 0x10(%rsp),%xmm1
mov    $0x1,%r12b
cmp    $0xd,%eax
jg     121d <dtoa+0xcd>
xorpd  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
seta   %cl
cmp    $0x9,%eax
setge  %dl
and    %cl,%dl
cmp    $0xfffffff8,%eax
setl   %r12b
or     %dl,%r12b
xorpd  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
mov    %r14,%rbp
jbe    1232 <dtoa+0xe2>
lea    0x1(%r14),%rbp
movb   $0x2d,(%r14)
test   %r12b,%r12b
je     1261 <dtoa+0x111>
mov    %eax,%r15d
sar    $0x1f,%r15d
add    %eax,%r15d
movsd  0xdc7(%rip),%xmm0
mov    %r15d,%edi
call   1050 <pow@plt>
movapd (%rsp),%xmm1
divsd  %xmm0,%xmm1
movapd %xmm1,(%rsp)
jmp    1265 <dtoa+0x115>
test   %eax,%eax
jg     1270 <dtoa+0x120>
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
mov    %eax,%ebx
movsd  0xd96(%rip),%xmm0
mov    %eax,%edi
call   1050 <pow@plt>
ucomisd 0xd97(%rip),%xmm0
jbe    12d7 <dtoa+0x187>
movapd %xmm0,%xmm1
xorpd  0xd69(%rip),%xmm0
ucomisd %xmm0,%xmm1
jne    129f <dtoa+0x14f>
jnp    12d7 <dtoa+0x187>
movapd (%rsp),%xmm0
divsd  %xmm1,%xmm0
movapd %xmm1,0x10(%rsp)
call   1070 <floor@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0x10(%rsp),%xmm0
movapd (%rsp),%xmm1
subsd  %xmm0,%xmm1
movapd %xmm1,(%rsp)
add    $0x30,%al
mov    %al,0x0(%rbp)
add    $0x1,%rbp
mov    %ebx,%eax
sub    $0x1,%eax
jae    12f5 <dtoa+0x1a5>
movapd (%rsp),%xmm0
ucomisd 0xd35(%rip),%xmm0
jbe    12f5 <dtoa+0x1a5>
movb   $0x2e,0x0(%rbp)
add    $0x1,%rbp
movapd (%rsp),%xmm0
ucomisd 0xd16(%rip),%xmm0
ja     1270 <dtoa+0x120>
test   %ebx,%ebx
jg     1270 <dtoa+0x120>
test   %r12b,%r12b
je     13bc <dtoa+0x26c>
movb   $0x65,0x0(%rbp)
test   %r15d,%r15d
jle    132c <dtoa+0x1dc>
movb   $0x2b,0x1(%rbp)
add    $0x2,%rbp
jmp    1340 <dtoa+0x1f0>
movb   $0x2d,0x1(%rbp)
add    $0x2,%rbp
test   %r15d,%r15d
je     13bc <dtoa+0x26c>
neg    %r15d
mov    $0x2,%eax
mov    $0xcccccccd,%edx
mov    %rbp,%rcx
nopl   (%rax)
mov    %r15d,%esi
imul   %rdx,%rsi
shr    $0x23,%rsi
lea    (%rsi,%rsi,1),%edi
lea    (%rdi,%rdi,4),%edi
mov    %r15d,%ebx
sub    %edi,%ebx
or     $0x30,%bl
mov    %bl,(%rcx)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
cmp    $0x9,%r15d
mov    %esi,%r15d
ja     1350 <dtoa+0x200>
cmp    $0x1,%eax
je     13b9 <dtoa+0x269>
neg    %rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movzbl 0x0(%rbp,%rdx,1),%ebx
xor    0x1(%rbp,%rax,1),%bl
mov    %bl,0x0(%rbp,%rdx,1)
xor    0x1(%rbp,%rax,1),%bl
mov    %bl,0x1(%rbp,%rax,1)
xor    %bl,0x0(%rbp,%rdx,1)
add    $0x1,%rdx
lea    -0x1(%rax),%rsi
cmp    %rax,%rdx
mov    %rsi,%rax
jl     1390 <dtoa+0x240>
mov    %rcx,%rbp
movb   $0x0,0x0(%rbp)
jmp    11a6 <dtoa+0x56>

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

LLVM IR (-O2):
@.str = [4 x i8] c"nan\00"
@.str.1 = [4 x i8] c"inf\00"
@.str.2 = [2 x i8] c"0\00"
define i8* @dtoa(double %0, i8* returned %1) {
%3 = tail call i64 @isnan(double %0)
%4 = icmp eq i64 %3, 0
br i1 %4, label %7, label %5
5: ; preds = %2
%6 = tail call i32 @memcpy(i8* %1, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 4)
br label %126
7: ; preds = %2
%8 = fneg double %0
%9 = fcmp oeq double %8, %0
br i1 %9, label %10, label %12
10: ; preds = %7
%11 = tail call i32 @memcpy(i8* %1, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 4)
br label %126
12: ; preds = %7
%13 = fcmp oeq double %0, 0.000000e+00
br i1 %13, label %14, label %16
14: ; preds = %12
%15 = tail call i32 @memcpy(i8* %1, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i32 2)
br label %126
16: ; preds = %12
%17 = fcmp olt double %0, 0.000000e+00
%18 = select i1 %17, double %8, double %0
%19 = tail call i32 @log10(double %18)
%20 = icmp sgt i32 %19, 13
br i1 %20, label %26, label %21
21: ; preds = %16
%22 = icmp sgt i32 %19, 8
%23 = select i1 %17, i1 %22, i1 false
%24 = icmp slt i32 %19, -8
%25 = select i1 %23, i1 true, i1 %24
br label %26
26: ; preds = %21, %16
%27 = phi i1 [ true, %16 ], [ %25, %21 ]
br i1 %17, label %28, label %30
28: ; preds = %26
%29 = getelementptr inbounds i8, i8* %1, i64 1
store i8 45, i8* %1
br label %30
30: ; preds = %28, %26
%31 = phi i8* [ %29, %28 ], [ %1, %26 ]
br i1 %27, label %32, label %37
32: ; preds = %30
%33 = ashr i32 %19, 31
%34 = add i32 %19, %33
%35 = tail call double @pow(double 1.000000e+01, i32 %34)
%36 = fdiv double %18, %35
br label %39
37: ; preds = %30
%38 = icmp slt i32 %19, 1
br i1 %38, label %39, label %42
39: ; preds = %32, %37
%40 = phi double [ %36, %32 ], [ %18, %37 ]
%41 = phi i32 [ %34, %32 ], [ undef, %37 ]
br label %42
42: ; preds = %39, %37
%43 = phi double [ %40, %39 ], [ %18, %37 ]
%44 = phi i32 [ %41, %39 ], [ undef, %37 ]
%45 = phi i32 [ 0, %39 ], [ %19, %37 ]
br label %46
46: ; preds = %42, %72
%47 = phi double [ %66, %72 ], [ %43, %42 ]
%48 = phi i32 [ %74, %72 ], [ %45, %42 ]
%49 = phi i8* [ %73, %72 ], [ %31, %42 ]
%50 = tail call double @pow(double 1.000000e+01, i32 %48)
%51 = fcmp ule double %50, 0.000000e+00
%52 = fneg double %50
%53 = fcmp oeq double %50, %52
%54 = or i1 %51, %53
br i1 %54, label %64, label %55
55: ; preds = %46
%56 = fdiv double %47, %50
%57 = tail call i32 @floor(double %56)
%58 = sitofp i32 %57 to double
%59 = fneg double %58
%60 = tail call double @llvm.fmuladd.f64(double %59, double %50, double %47)
%61 = trunc i32 %57 to i8
%62 = add i8 %61, 48
%63 = getelementptr inbounds i8, i8* %49, i64 1
store i8 %62, i8* %49
br label %64
64: ; preds = %55, %46
%65 = phi i8* [ %63, %55 ], [ %49, %46 ]
%66 = phi double [ %60, %55 ], [ %47, %46 ]
%67 = icmp eq i32 %48, 0
%68 = fcmp ogt double %66, 0.000000e+00
%69 = select i1 %67, i1 %68, i1 false
br i1 %69, label %70, label %72
70: ; preds = %64
%71 = getelementptr inbounds i8, i8* %65, i64 1
store i8 46, i8* %65
br label %72
72: ; preds = %70, %64
%73 = phi i8* [ %71, %70 ], [ %65, %64 ]
%74 = add nsw i32 %48, -1
%75 = fcmp ogt double %66, 0x3D06849B86A12B9B
%76 = icmp sgt i32 %48, 0
%77 = or i1 %75, %76
br i1 %77, label %46, label %78
78: ; preds = %72
br i1 %27, label %79, label %124
79: ; preds = %78
%80 = getelementptr inbounds i8, i8* %73, i64 1
store i8 101, i8* %73
%81 = icmp sgt i32 %44, 0
br i1 %81, label %82, label %84
82: ; preds = %79
store i8 43, i8* %80
%83 = getelementptr inbounds i8, i8* %73, i64 2
br label %88
84: ; preds = %79
store i8 45, i8* %80
%85 = sub nsw i32 0, %44
%86 = getelementptr inbounds i8, i8* %73, i64 2
%87 = icmp eq i32 %44, 0
br i1 %87, label %124, label %88
88: ; preds = %82, %84
%89 = phi i32 [ %85, %84 ], [ %44, %82 ]
%90 = phi i8* [ %86, %84 ], [ %83, %82 ]
br label %91
91: ; preds = %88, %91
%92 = phi i32 [ %100, %91 ], [ 0, %88 ]
%93 = phi i32 [ %99, %91 ], [ %89, %88 ]
%94 = phi i8* [ %98, %91 ], [ %90, %88 ]
%95 = urem i32 %93, 10
%96 = trunc i32 %95 to i8
%97 = or i8 %96, 48
%98 = getelementptr inbounds i8, i8* %94, i64 1
store i8 %97, i8* %94
%99 = udiv i32 %93, 10
%100 = add nuw nsw i32 %92, 1
%101 = icmp ult i32 %93, 10
br i1 %101, label %102, label %91
102: ; preds = %91
%103 = zext i32 %100 to i64
%104 = sub nsw i64 0, %103
%105 = getelementptr inbounds i8, i8* %98, i64 %104
%106 = icmp eq i32 %92, 0
br i1 %106, label %124, label %107
107: ; preds = %102
%108 = zext i32 %92 to i64
br label %109
109: ; preds = %107, %109
%110 = phi i64 [ 0, %107 ], [ %121, %109 ]
%111 = phi i64 [ %108, %107 ], [ %122, %109 ]
%112 = getelementptr inbounds i8, i8* %105, i64 %111
%113 = load i8, i8* %112
%114 = getelementptr inbounds i8, i8* %105, i64 %110
%115 = load i8, i8* %114
%116 = xor i8 %115, %113
store i8 %116, i8* %114
%117 = load i8, i8* %112
%118 = xor i8 %117, %116
store i8 %118, i8* %112
%119 = load i8, i8* %114
%120 = xor i8 %119, %118
store i8 %120, i8* %114
%121 = add nuw nsw i64 %110, 1
%122 = add nsw i64 %111, -1
%123 = icmp slt i64 %121, %122
br i1 %123, label %109, label %124
124: ; preds = %109, %84, %102, %78
%125 = phi i8* [ %73, %78 ], [ %98, %102 ], [ %86, %84 ], [ %98, %109 ]
store i8 0, i8* %125
br label %126
126: ; preds = %10, %124, %14, %5
ret i8* %1
}