#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 */
char *gcvt(double f, size_t ndigit, char *buf) {
  int i;
  unsigned long long z, k;
  int exp = 0;
  char *c = buf;
  double f2, t, scal;
  int sign = 0;
  if ((int)ndigit == -1)
    ndigit = 5;
  if (ndigit > 20)
    ndigit = 20;
  if (f < 0.0) {
    sign = 1;
    f = -f;
    buf++;
  }
  scal = 1;
  for (i = ndigit; i > 0; i--)
    scal *= 10;
  k = f + 0.1 / scal;
  f2 = f - k;
  if (!f) {
    (*(buf++) = ('0'));
    if (ndigit > 0)
      (*(buf++) = ('.'));
    for (i = 0; i < ndigit; i++)
      (*(buf++) = ('0'));
    (*(buf++) = (0));
    return c;
  }
  i = 1;
  while (f >= 10.0) {
    f /= 10.0;
    i++;
  }
  buf += i + ndigit + 1;
  (*(buf--) = (0));
  if (ndigit > 0) {
    t = f2 * scal;
    z = t + 0.5;
    for (i = 0; i < ndigit; i++) {
      (*(buf--) = ('0' + (z % 10)));
      z /= 10;
    }
    (*(buf--) = ('.'));
  } else
    (*(buf--) = (0));
  do {
    (*(buf--) = ('0' + (k % 10)));
    k /= 10;
  } while (k);
  if (sign)
    (*(buf--) = ('-'));
  return c;
}


x86 assembly (clang, -O0):
<gcvt>:
push   %rbp
mov    %rsp,%rbp
movsd  %xmm0,-0x10(%rbp)
mov    %rdi,-0x18(%rbp)
mov    %rsi,-0x20(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x18(%rbp),%rax
cmp    $0xffffffff,%eax
jne    113c <gcvt+0x3c>
movq   $0x5,-0x18(%rbp)
cmpq   $0x14,-0x18(%rbp)
jbe    114f <gcvt+0x4f>
movq   $0x14,-0x18(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x10(%rbp),%xmm0
jbe    1191 <gcvt+0x91>
movl   $0x1,-0x64(%rbp)
movsd  -0x10(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
movsd  0xe67(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    11cf <gcvt+0xcf>
movsd  0xe61(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    11a5 <gcvt+0xa5>
movsd  -0x10(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  0xe27(%rip),%xmm1
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movaps %xmm0,%xmm1
cvttsd2si %xmm1,%rax
mov    %rax,%rdx
sar    $0x3f,%rdx
movsd  0xe10(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%rcx
and    %rdx,%rcx
or     %rcx,%rax
mov    %rax,-0x38(%rbp)
movsd  -0x10(%rbp),%xmm0
movaps 0xe11(%rip),%xmm2
movq   -0x38(%rbp),%xmm1
punpckldq %xmm2,%xmm1
movapd 0xe10(%rip),%xmm2
subpd  %xmm2,%xmm1
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm1
addsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x10(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    12e3 <gcvt+0x1e3>
jp     12e3 <gcvt+0x1e3>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movb   $0x30,(%rax)
cmpq   $0x0,-0x18(%rbp)
jbe    128f <gcvt+0x18f>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movb   $0x2e,(%rax)
movl   $0x0,-0x24(%rbp)
movslq -0x24(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    12c4 <gcvt+0x1c4>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movb   $0x30,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1296 <gcvt+0x196>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movb   $0x0,(%rax)
mov    -0x48(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1492 <gcvt+0x392>
movl   $0x1,-0x24(%rbp)
movsd  -0x10(%rbp),%xmm0
movsd  0xd21(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     1325 <gcvt+0x225>
movsd  -0x10(%rbp),%xmm0
movsd  0xd0a(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x10(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12ea <gcvt+0x1ea>
movslq -0x24(%rbp),%rax
add    -0x18(%rbp),%rax
add    $0x1,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
movb   $0x0,(%rax)
cmpq   $0x0,-0x18(%rbp)
jbe    1415 <gcvt+0x315>
movsd  -0x50(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  0xcaa(%rip),%xmm1
addsd  %xmm1,%xmm0
movaps %xmm0,%xmm1
cvttsd2si %xmm1,%rax
mov    %rax,%rdx
sar    $0x3f,%rdx
movsd  0xc7f(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%rcx
and    %rdx,%rcx
or     %rcx,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x24(%rbp)
movslq -0x24(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    13fe <gcvt+0x2fe>
mov    -0x30(%rbp),%rax
mov    $0xa,%ecx
xor    %edx,%edx
div    %rcx
add    $0x30,%rdx
mov    %dl,%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
mov    $0xa,%ecx
xor    %edx,%edx
div    %rcx
mov    %rax,-0x30(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13ab <gcvt+0x2ab>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
movb   $0x2e,(%rax)
jmp    1427 <gcvt+0x327>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
movb   $0x0,(%rax)
jmp    142c <gcvt+0x32c>
mov    -0x38(%rbp),%rax
mov    $0xa,%ecx
xor    %edx,%edx
div    %rcx
add    $0x30,%rdx
mov    %dl,%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
mov    -0x38(%rbp),%rax
mov    $0xa,%ecx
xor    %edx,%edx
div    %rcx
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x38(%rbp)
jne    142c <gcvt+0x32c>
cmpl   $0x0,-0x64(%rbp)
je     148a <gcvt+0x38a>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
movb   $0x2d,(%rax)
mov    -0x48(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<gcvt>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %rsi,%r14
cmp    $0xffffffff,%edi
mov    $0x5,%eax
cmovne %rdi,%rax
cmp    $0x14,%rax
mov    $0x14,%r15d
cmovb  %rax,%r15
xorpd  %xmm1,%xmm1
xor    %r12d,%r12d
ucomisd %xmm0,%xmm1
seta   %r12b
ja     1187 <gcvt+0x77>
movapd %xmm0,%xmm1
test   %r15d,%r15d
je     1198 <gcvt+0x88>
lea    -0x1(%r15),%ecx
mov    %r15d,%eax
and    $0x7,%eax
je     11a2 <gcvt+0x92>
xor    %edx,%edx
movsd  0xecb(%rip),%xmm2
movsd  0xecb(%rip),%xmm3
nopl   (%rax)
mulsd  %xmm3,%xmm2
add    $0x1,%edx
cmp    %edx,%eax
jne    1170 <gcvt+0x60>
mov    %r15d,%eax
sub    %edx,%eax
cmp    $0x7,%ecx
jae    11b2 <gcvt+0xa2>
jmp    11e8 <gcvt+0xd8>
movapd 0xe71(%rip),%xmm1
xorpd  %xmm0,%xmm1
test   %r15d,%r15d
jne    114f <gcvt+0x3f>
movsd  0xe90(%rip),%xmm2
jmp    11e8 <gcvt+0xd8>
movsd  0xe86(%rip),%xmm2
mov    %r15d,%eax
cmp    $0x7,%ecx
jb     11e8 <gcvt+0xd8>
add    $0xffffffff,%eax
movsd  0xe7b(%rip),%xmm3
nopl   (%rax)
mulsd  %xmm3,%xmm2
mulsd  %xmm3,%xmm2
mulsd  %xmm3,%xmm2
mulsd  %xmm3,%xmm2
mulsd  %xmm3,%xmm2
mulsd  %xmm3,%xmm2
mulsd  %xmm3,%xmm2
mulsd  %xmm3,%xmm2
add    $0xfffffff8,%eax
cmp    $0xfffffffe,%eax
jb     11c0 <gcvt+0xb0>
add    %r14,%r12
xorpd  %xmm3,%xmm3
ucomisd %xmm3,%xmm1
jne    11fb <gcvt+0xeb>
jnp    1367 <gcvt+0x257>
movsd  0xe3d(%rip),%xmm3
divsd  %xmm2,%xmm3
addsd  %xmm1,%xmm3
cvttsd2si %xmm3,%rcx
mov    %rcx,%rdx
subsd  0xe2d(%rip),%xmm3
sar    $0x3f,%rdx
cvttsd2si %xmm3,%rax
and    %rdx,%rax
mov    $0x1,%edx
ucomisd 0xe04(%rip),%xmm1
jb     125e <gcvt+0x14e>
mov    $0x1,%edx
movsd  0xdf5(%rip),%xmm3
movapd %xmm1,%xmm4
nopw   0x0(%rax,%rax,1)
divsd  %xmm3,%xmm4
add    $0x1,%rdx
ucomisd %xmm3,%xmm4
jae    1250 <gcvt+0x140>
or     %rax,%rcx
add    %r15,%rdx
lea    (%r12,%rdx,1),%rbx
movb   $0x0,0x1(%r12,%rdx,1)
movabs $0xcccccccccccccccd,%r8
cc cc cc
test   %r15,%r15
je     1392 <gcvt+0x282>
movq   %rcx,%xmm3
punpckldq 0xd82(%rip),%xmm3
subpd  0xd8a(%rip),%xmm3
movapd %xmm3,%xmm4
unpckhpd %xmm3,%xmm4
addsd  %xmm3,%xmm4
subsd  %xmm4,%xmm1
mulsd  %xmm1,%xmm2
addsd  0xd9e(%rip),%xmm2
cvttsd2si %xmm2,%rax
mov    %rax,%rdx
subsd  0xd86(%rip),%xmm2
cvttsd2si %xmm2,%rsi
sar    $0x3f,%rdx
and    %rdx,%rsi
or     %rax,%rsi
cmp    $0x1,%r15
je     1340 <gcvt+0x230>
mov    %r15d,%r9d
and    $0x1e,%r9d
movabs $0x28f5c28f5c28f5c3,%r10
c2 f5 28
nopl   0x0(%rax,%rax,1)
mov    %rsi,%rax
mul    %r8
mov    %rdx,%rdi
shr    $0x3,%rdi
lea    (%rdi,%rdi,1),%eax
lea    (%rax,%rax,4),%eax
mov    %esi,%edx
sub    %eax,%edx
or     $0x30,%dl
mov    %dl,(%rbx)
mov    %rdi,%rax
mul    %r8
shr    $0x2,%edx
and    $0xfffffffe,%edx
lea    (%rdx,%rdx,4),%eax
sub    %eax,%edi
or     $0x30,%dil
mov    %dil,-0x1(%rbx)
add    $0xfffffffffffffffe,%rbx
shr    $0x2,%rsi
mov    %rsi,%rax
mul    %r10
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0xfffffffffffffffe,%r9
jne    12f0 <gcvt+0x1e0>
test   $0x1,%r15b
je     1362 <gcvt+0x252>
mov    %rsi,%rax
mul    %r8
shr    $0x2,%edx
and    $0xfffffffe,%edx
lea    (%rdx,%rdx,4),%eax
sub    %eax,%esi
or     $0x30,%sil
mov    %sil,(%rbx)
add    $0xffffffffffffffff,%rbx
movb   $0x2e,(%rbx)
jmp    1395 <gcvt+0x285>
movb   $0x30,(%r12)
test   %r15,%r15
je     13d7 <gcvt+0x2c7>
lea    0x2(%r12),%rdi
movb   $0x2e,0x1(%r12)
mov    $0x30,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
add    %r15,%r12
add    $0x2,%r12
jmp    13db <gcvt+0x2cb>
movb   $0x0,(%rbx)
add    $0xffffffffffffffff,%rbx
nopl   0x0(%rax)
mov    %rcx,%rax
mul    %r8
shr    $0x3,%rdx
lea    (%rdx,%rdx,1),%eax
lea    (%rax,%rax,4),%eax
mov    %ecx,%esi
sub    %eax,%esi
or     $0x30,%sil
mov    %sil,(%rbx)
add    $0xffffffffffffffff,%rbx
cmp    $0x9,%rcx
mov    %rdx,%rcx
ja     13a0 <gcvt+0x290>
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
jbe    13e0 <gcvt+0x2d0>
movb   $0x2d,(%rbx)
jmp    13e0 <gcvt+0x2d0>
add    $0x1,%r12
movb   $0x0,(%r12)
mov    %r14,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define i8* @gcvt(double %0, i64 %1, i8* %2) {
%4 = alloca i8*
%5 = alloca double
%6 = alloca i64
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i64
%10 = alloca i64
%11 = alloca i32
%12 = alloca i8*
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca i32
store double %0, double* %5
store i64 %1, i64* %6
store i8* %2, i8** %7
store i32 0, i32* %11
%17 = load i8*, i8** %7
store i8* %17, i8** %12
store i32 0, i32* %16
%18 = load i64, i64* %6
%19 = trunc i64 %18 to i32
%20 = icmp eq i32 %19, -1
br i1 %20, label %21, label %22
21: ; preds = %3
store i64 5, i64* %6
br label %22
22: ; preds = %21, %3
%23 = load i64, i64* %6
%24 = icmp ugt i64 %23, 20
br i1 %24, label %25, label %26
25: ; preds = %22
store i64 20, i64* %6
br label %26
26: ; preds = %25, %22
%27 = load double, double* %5
%28 = fcmp olt double %27, 0.000000e+00
br i1 %28, label %29, label %34
29: ; preds = %26
store i32 1, i32* %16
%30 = load double, double* %5
%31 = fneg double %30
store double %31, double* %5
%32 = load i8*, i8** %7
%33 = getelementptr inbounds i8, i8* %32, i32 1
store i8* %33, i8** %7
br label %34
34: ; preds = %29, %26
store double 1.000000e+00, double* %15
%35 = load i64, i64* %6
%36 = trunc i64 %35 to i32
store i32 %36, i32* %8
br label %37
37: ; preds = %43, %34
%38 = load i32, i32* %8
%39 = icmp sgt i32 %38, 0
br i1 %39, label %40, label %46
40: ; preds = %37
%41 = load double, double* %15
%42 = fmul double %41, 1.000000e+01
store double %42, double* %15
br label %43
43: ; preds = %40
%44 = load i32, i32* %8
%45 = add nsw i32 %44, -1
store i32 %45, i32* %8
br label %37
46: ; preds = %37
%47 = load double, double* %5
%48 = load double, double* %15
%49 = fdiv double 1.000000e-01, %48
%50 = fadd double %47, %49
%51 = fptoui double %50 to i64
store i64 %51, i64* %10
%52 = load double, double* %5
%53 = load i64, i64* %10
%54 = uitofp i64 %53 to double
%55 = fsub double %52, %54
store double %55, double* %13
%56 = load double, double* %5
%57 = fcmp une double %56, 0.000000e+00
br i1 %57, label %82, label %58
58: ; preds = %46
%59 = load i8*, i8** %7
%60 = getelementptr inbounds i8, i8* %59, i32 1
store i8* %60, i8** %7
store i8 48, i8* %59
%61 = load i64, i64* %6
%62 = icmp ugt i64 %61, 0
br i1 %62, label %63, label %66
63: ; preds = %58
%64 = load i8*, i8** %7
%65 = getelementptr inbounds i8, i8* %64, i32 1
store i8* %65, i8** %7
store i8 46, i8* %64
br label %66
66: ; preds = %63, %58
store i32 0, i32* %8
br label %67
67: ; preds = %75, %66
%68 = load i32, i32* %8
%69 = sext i32 %68 to i64
%70 = load i64, i64* %6
%71 = icmp ult i64 %69, %70
br i1 %71, label %72, label %78
72: ; preds = %67
%73 = load i8*, i8** %7
%74 = getelementptr inbounds i8, i8* %73, i32 1
store i8* %74, i8** %7
store i8 48, i8* %73
br label %75
75: ; preds = %72
%76 = load i32, i32* %8
%77 = add nsw i32 %76, 1
store i32 %77, i32* %8
br label %67
78: ; preds = %67
%79 = load i8*, i8** %7
%80 = getelementptr inbounds i8, i8* %79, i32 1
store i8* %80, i8** %7
store i8 0, i8* %79
%81 = load i8*, i8** %12
store i8* %81, i8** %4
br label %154
82: ; preds = %46
store i32 1, i32* %8
br label %83
83: ; preds = %86, %82
%84 = load double, double* %5
%85 = fcmp oge double %84, 1.000000e+01
br i1 %85, label %86, label %91
86: ; preds = %83
%87 = load double, double* %5
%88 = fdiv double %87, 1.000000e+01
store double %88, double* %5
%89 = load i32, i32* %8
%90 = add nsw i32 %89, 1
store i32 %90, i32* %8
br label %83
91: ; preds = %83
%92 = load i32, i32* %8
%93 = sext i32 %92 to i64
%94 = load i64, i64* %6
%95 = add i64 %93, %94
%96 = add i64 %95, 1
%97 = load i8*, i8** %7
%98 = getelementptr inbounds i8, i8* %97, i64 %96
store i8* %98, i8** %7
%99 = load i8*, i8** %7
%100 = getelementptr inbounds i8, i8* %99, i32 -1
store i8* %100, i8** %7
store i8 0, i8* %99
%101 = load i64, i64* %6
%102 = icmp ugt i64 %101, 0
br i1 %102, label %103, label %130
103: ; preds = %91
%104 = load double, double* %13
%105 = load double, double* %15
%106 = fmul double %104, %105
store double %106, double* %14
%107 = load double, double* %14
%108 = fadd double %107, 5.000000e-01
%109 = fptoui double %108 to i64
store i64 %109, i64* %9
store i32 0, i32* %8
br label %110
110: ; preds = %124, %103
%111 = load i32, i32* %8
%112 = sext i32 %111 to i64
%113 = load i64, i64* %6
%114 = icmp ult i64 %112, %113
br i1 %114, label %115, label %127
115: ; preds = %110
%116 = load i64, i64* %9
%117 = urem i64 %116, 10
%118 = add i64 48, %117
%119 = trunc i64 %118 to i8
%120 = load i8*, i8** %7
%121 = getelementptr inbounds i8, i8* %120, i32 -1
store i8* %121, i8** %7
store i8 %119, i8* %120
%122 = load i64, i64* %9
%123 = udiv i64 %122, 10
store i64 %123, i64* %9
br label %124
124: ; preds = %115
%125 = load i32, i32* %8
%126 = add nsw i32 %125, 1
store i32 %126, i32* %8
br label %110
127: ; preds = %110
%128 = load i8*, i8** %7
%129 = getelementptr inbounds i8, i8* %128, i32 -1
store i8* %129, i8** %7
store i8 46, i8* %128
br label %133
130: ; preds = %91
%131 = load i8*, i8** %7
%132 = getelementptr inbounds i8, i8* %131, i32 -1
store i8* %132, i8** %7
store i8 0, i8* %131
br label %133
133: ; preds = %130, %127
br label %134
134: ; preds = %143, %133
%135 = load i64, i64* %10
%136 = urem i64 %135, 10
%137 = add i64 48, %136
%138 = trunc i64 %137 to i8
%139 = load i8*, i8** %7
%140 = getelementptr inbounds i8, i8* %139, i32 -1
store i8* %140, i8** %7
store i8 %138, i8* %139
%141 = load i64, i64* %10
%142 = udiv i64 %141, 10
store i64 %142, i64* %10
br label %143
143: ; preds = %134
%144 = load i64, i64* %10
%145 = icmp ne i64 %144, 0
br i1 %145, label %134, label %146
146: ; preds = %143
%147 = load i32, i32* %16
%148 = icmp ne i32 %147, 0
br i1 %148, label %149, label %152
149: ; preds = %146
%150 = load i8*, i8** %7
%151 = getelementptr inbounds i8, i8* %150, i32 -1
store i8* %151, i8** %7
store i8 45, i8* %150
br label %152
152: ; preds = %149, %146
%153 = load i8*, i8** %12
store i8* %153, i8** %4
br label %154
154: ; preds = %152, %78
%155 = load i8*, i8** %4
ret i8* %155
}

LLVM IR (-O2):
define i8* @gcvt(double %0, i64 %1, i8* returned writeonly %2) {
%4 = trunc i64 %1 to i32
%5 = icmp eq i32 %4, -1
%6 = select i1 %5, i64 5, i64 %1
%7 = icmp ult i64 %6, 20
%8 = select i1 %7, i64 %6, i64 20
%9 = fcmp olt double %0, 0.000000e+00
%10 = fneg double %0
%11 = zext i1 %9 to i64
%12 = getelementptr i8, i8* %2, i64 %11
%13 = select i1 %9, double %10, double %0
%14 = trunc i64 %8 to i32
%15 = icmp eq i32 %14, 0
br i1 %15, label %47, label %16
16: ; preds = %3
%17 = add nsw i32 %14, -1
%18 = and i32 %14, 7
%19 = icmp eq i32 %18, 0
br i1 %19, label %28, label %20
20: ; preds = %16, %20
%21 = phi double [ %24, %20 ], [ 1.000000e+00, %16 ]
%22 = phi i32 [ %25, %20 ], [ %14, %16 ]
%23 = phi i32 [ %26, %20 ], [ 0, %16 ]
%24 = fmul double %21, 1.000000e+01
%25 = add nsw i32 %22, -1
%26 = add i32 %23, 1
%27 = icmp eq i32 %26, %18
br i1 %27, label %28, label %20
28: ; preds = %20, %16
%29 = phi double [ 1.000000e+00, %16 ], [ %24, %20 ]
%30 = phi i32 [ %14, %16 ], [ %25, %20 ]
%31 = phi double [ undef, %16 ], [ %24, %20 ]
%32 = icmp ult i32 %17, 7
br i1 %32, label %47, label %33
33: ; preds = %28, %33
%34 = phi double [ %43, %33 ], [ %29, %28 ]
%35 = phi i32 [ %44, %33 ], [ %30, %28 ]
%36 = fmul double %34, 1.000000e+01
%37 = fmul double %36, 1.000000e+01
%38 = fmul double %37, 1.000000e+01
%39 = fmul double %38, 1.000000e+01
%40 = fmul double %39, 1.000000e+01
%41 = fmul double %40, 1.000000e+01
%42 = fmul double %41, 1.000000e+01
%43 = fmul double %42, 1.000000e+01
%44 = add nsw i32 %35, -8
%45 = add i32 %35, -9
%46 = icmp ult i32 %45, -2
br i1 %46, label %33, label %47
47: ; preds = %28, %33, %3
%48 = phi double [ 1.000000e+00, %3 ], [ %31, %28 ], [ %43, %33 ]
%49 = fdiv double 1.000000e-01, %48
%50 = fadd double %13, %49
%51 = fptoui double %50 to i64
%52 = uitofp i64 %51 to double
%53 = fsub double %13, %52
%54 = fcmp une double %13, 0.000000e+00
br i1 %54, label %55, label %57
55: ; preds = %47
%56 = fcmp ult double %13, 1.000000e+01
br i1 %56, label %73, label %65
57: ; preds = %47
%58 = getelementptr inbounds i8, i8* %12, i64 1
store i8 48, i8* %12
%59 = icmp eq i64 %8, 0
br i1 %59, label %63, label %60
60: ; preds = %57
%61 = getelementptr inbounds i8, i8* %12, i64 2
store i8 46, i8* %58
%62 = getelementptr i8, i8* %61, i64 %8
br label %63
63: ; preds = %57, %60
%64 = phi i8* [ %62, %60 ], [ %58, %57 ]
store i8 0, i8* %64
br label %131
65: ; preds = %55, %65
%66 = phi double [ %68, %65 ], [ %13, %55 ]
%67 = phi i32 [ %69, %65 ], [ 1, %55 ]
%68 = fdiv double %66, 1.000000e+01
%69 = add nuw nsw i32 %67, 1
%70 = fcmp ult double %68, 1.000000e+01
br i1 %70, label %71, label %65
71: ; preds = %65
%72 = zext i32 %69 to i64
br label %73
73: ; preds = %71, %55
%74 = phi i64 [ 1, %55 ], [ %72, %71 ]
%75 = add nuw nsw i64 %8, %74
%76 = add nuw nsw i64 %75, 1
%77 = getelementptr inbounds i8, i8* %12, i64 %76
%78 = getelementptr inbounds i8, i8* %12, i64 %75
store i8 0, i8* %77
%79 = icmp eq i64 %8, 0
br i1 %79, label %116, label %80
80: ; preds = %73
%81 = fmul double %48, %53
%82 = fadd double %81, 5.000000e-01
%83 = fptoui double %82 to i64
%84 = and i64 %8, 1
%85 = icmp eq i64 %8, 1
br i1 %85, label %104, label %86
86: ; preds = %80
%87 = and i64 %8, 30
br label %88
88: ; preds = %88, %86
%89 = phi i8* [ %78, %86 ], [ %100, %88 ]
%90 = phi i64 [ %83, %86 ], [ %101, %88 ]
%91 = phi i64 [ 0, %86 ], [ %102, %88 ]
%92 = urem i64 %90, 10
%93 = trunc i64 %92 to i8
%94 = or i8 %93, 48
%95 = getelementptr inbounds i8, i8* %89, i64 -1
store i8 %94, i8* %89
%96 = udiv i64 %90, 10
%97 = urem i64 %96, 10
%98 = trunc i64 %97 to i8
%99 = or i8 %98, 48
%100 = getelementptr inbounds i8, i8* %89, i64 -2
store i8 %99, i8* %95
%101 = udiv i64 %90, 100
%102 = add i64 %91, 2
%103 = icmp eq i64 %102, %87
br i1 %103, label %104, label %88
104: ; preds = %88, %80
%105 = phi i8* [ undef, %80 ], [ %100, %88 ]
%106 = phi i8* [ %78, %80 ], [ %100, %88 ]
%107 = phi i64 [ %83, %80 ], [ %101, %88 ]
%108 = icmp eq i64 %84, 0
br i1 %108, label %114, label %109
109: ; preds = %104
%110 = urem i64 %107, 10
%111 = trunc i64 %110 to i8
%112 = or i8 %111, 48
%113 = getelementptr inbounds i8, i8* %106, i64 -1
store i8 %112, i8* %106
br label %114
114: ; preds = %104, %109
%115 = phi i8* [ %105, %104 ], [ %113, %109 ]
store i8 46, i8* %115
br label %117
116: ; preds = %73
store i8 0, i8* %78
br label %117
117: ; preds = %116, %114
%118 = phi i8* [ %115, %114 ], [ %78, %116 ]
%119 = getelementptr inbounds i8, i8* %118, i64 -1
br label %120
120: ; preds = %120, %117
%121 = phi i64 [ %51, %117 ], [ %127, %120 ]
%122 = phi i8* [ %119, %117 ], [ %126, %120 ]
%123 = urem i64 %121, 10
%124 = trunc i64 %123 to i8
%125 = or i8 %124, 48
%126 = getelementptr inbounds i8, i8* %122, i64 -1
store i8 %125, i8* %122
%127 = udiv i64 %121, 10
%128 = icmp ult i64 %121, 10
br i1 %128, label %129, label %120
129: ; preds = %120
br i1 %9, label %130, label %131
130: ; preds = %129
store i8 45, i8* %126
br label %131
131: ; preds = %129, %130, %63
ret i8* %2
}