#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 */
typedef int uint64_t;

/* Variables and functions */
int /*<<< orphan*/ assert(int);
scalar_t__ ceil(int /*<<< orphan*/);
int /*<<< orphan*/ log10(double);
double pow(double, int);
char *convert(double value, char *buf, int ndigit, int *decpt, int *sign,
              int fflag) {
  int bufsize = ndigit + 4;
  union {
    uint64_t l;
    double f;
  } x;
  x.f = value;
  int exp2 = (0x7ff & (x.l >> 52)) - 1023;
  uint64_t mant = x.l & 0x000fffffffffffffULL;
  if ((*sign = x.l >> 63))
    value = -value;
  if (exp2 == 0x400) {
    *decpt = 0;
    return mant ? "nan" : "inf";
  }
  int exp10 = (value == 0) ? !fflag : (int)ceil(log10(value));
  if (exp10 < -307)
    exp10 = -307;
  value *= pow(10.0, -exp10);
  if (value) {
    while (value < 0.1) {
      value *= 10;
      --exp10;
    }
    while (value >= 1.0) {
      value /= 10;
      ++exp10;
    }
  }
  assert(value == 0 || (0.1 <= value && value < 1.0));
  if (fflag) {
    if (ndigit + exp10 < 0) {
      *decpt = -ndigit;
      return "";
    }
    ndigit += exp10;
  }
  *decpt = exp10;
  if (bufsize < ndigit + 2) {
    bufsize = ndigit + 2;
    assert(0);
  }
  int ptr = 1;
  x.f = value;
  exp2 = (0x7ff & (x.l >> 52)) - 1023;
  assert(value == 0 || (-4 <= exp2 && exp2 <= -1));
  mant = x.l & 0x000fffffffffffffULL;
  if (exp2 == -1023)
    ++exp2;
  else
    mant |= 0x0010000000000000ULL;
  mant <<= (exp2 + 4);
  while (ptr <= ndigit) {
    mant &= 0x00ffffffffffffffULL;
    mant = (mant << 1) + (mant << 3);
    buf[ptr++] = '0' + (mant >> 56);
  }
  if (mant & 0x0080000000000000ULL)
    while (--ptr && ++buf[ptr] > '9')
      buf[ptr] = '0';
  if (ptr) {
    buf[ndigit + 1] = 0;
    return buf + 1;
  }
  if (fflag) {
    ++ndigit;
    ++*decpt;
  }
  buf[0] = '1';
  buf[ndigit] = 0;
  return buf;
}


x86 assembly (clang, -O0):
<convert>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
movsd  %xmm0,-0x10(%rbp)
mov    %rdi,-0x18(%rbp)
mov    %esi,-0x1c(%rbp)
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %r8d,-0x34(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x38(%rbp)
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    $0x34,%ecx
sar    %cl,%eax
and    $0x7ff,%eax
sub    $0x3ff,%eax
mov    %eax,-0x44(%rbp)
movslq -0x40(%rbp),%rax
movabs $0xfffffffffffff,%rcx
and    %rcx,%rax
mov    %eax,-0x48(%rbp)
mov    -0x40(%rbp),%eax
mov    $0x3f,%ecx
sar    %cl,%eax
mov    -0x30(%rbp),%rcx
mov    %eax,(%rcx)
cmp    $0x0,%eax
je     11d8 <convert+0x98>
movsd  -0x10(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x10(%rbp)
cmpl   $0x400,-0x44(%rbp)
jne    1210 <convert+0xd0>
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x48(%rbp),%edx
lea    0xe23(%rip),%rax
lea    0xe18(%rip),%rcx
cmp    $0x0,%edx
cmovne %rcx,%rax
mov    %rax,-0x8(%rbp)
jmp    15f0 <convert+0x4b0>
movsd  -0x10(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    123e <convert+0xfe>
jp     123e <convert+0xfe>
cmpl   $0x0,-0x34(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x54(%rbp)
jmp    1252 <convert+0x112>
movsd  -0x10(%rbp),%xmm0
call   1060 <log10@plt>
mov    %eax,%edi
call   1030 <ceil@plt>
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0xfffffecd,-0x4c(%rbp)
jge    126c <convert+0x12c>
movl   $0xfffffecd,-0x4c(%rbp)
xor    %edi,%edi
sub    -0x4c(%rbp),%edi
movsd  0xd87(%rip),%xmm0
call   1050 <pow@plt>
mulsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x10(%rbp)
movsd  -0x10(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    12a5 <convert+0x165>
jp     12a5 <convert+0x165>
jmp    1322 <convert+0x1e2>
jmp    12aa <convert+0x16a>
movsd  0xd56(%rip),%xmm0
ucomisd -0x10(%rbp),%xmm0
jbe    12dd <convert+0x19d>
movsd  0xd3b(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x10(%rbp)
mov    -0x4c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x4c(%rbp)
jmp    12aa <convert+0x16a>
jmp    12e2 <convert+0x1a2>
movsd  -0x10(%rbp),%xmm0
movsd  0xd21(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     131d <convert+0x1dd>
movsd  -0x10(%rbp),%xmm0
movsd  0xcfa(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x10(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12e2 <convert+0x1a2>
jmp    1322 <convert+0x1e2>
movsd  -0x10(%rbp),%xmm0
mov    $0x1,%al
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
mov    %al,-0x55(%rbp)
jne    1344 <convert+0x204>
jp     1344 <convert+0x204>
jmp    1379 <convert+0x239>
movsd  -0x10(%rbp),%xmm0
xor    %eax,%eax
movsd  0xcb5(%rip),%xmm1
ucomisd %xmm1,%xmm0
mov    %al,-0x56(%rbp)
jb     1373 <convert+0x233>
movsd  0xca8(%rip),%xmm0
ucomisd -0x10(%rbp),%xmm0
seta   %al
mov    %al,-0x56(%rbp)
mov    -0x56(%rbp),%al
mov    %al,-0x55(%rbp)
mov    -0x55(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
cmpl   $0x0,-0x34(%rbp)
je     13c3 <convert+0x283>
mov    -0x1c(%rbp),%eax
add    -0x4c(%rbp),%eax
cmp    $0x0,%eax
jge    13ba <convert+0x27a>
xor    %ecx,%ecx
sub    -0x1c(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
lea    0xc6e(%rip),%rax
mov    %rax,-0x8(%rbp)
jmp    15f0 <convert+0x4b0>
mov    -0x4c(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x38(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
jge    13ed <convert+0x2ad>
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x38(%rbp)
xor    %edi,%edi
call   1040 <assert@plt>
movl   $0x1,-0x50(%rbp)
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    $0x34,%ecx
sar    %cl,%eax
and    $0x7ff,%eax
sub    $0x3ff,%eax
mov    %eax,-0x44(%rbp)
movsd  -0x10(%rbp),%xmm0
mov    $0x1,%al
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
mov    %al,-0x57(%rbp)
jne    1437 <convert+0x2f7>
jp     1437 <convert+0x2f7>
jmp    145a <convert+0x31a>
xor    %eax,%eax
mov    $0xfffffffc,%ecx
cmp    -0x44(%rbp),%ecx
mov    %al,-0x58(%rbp)
jg     1454 <convert+0x314>
cmpl   $0xffffffff,-0x44(%rbp)
setle  %al
mov    %al,-0x58(%rbp)
mov    -0x58(%rbp),%al
mov    %al,-0x57(%rbp)
mov    -0x57(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
movslq -0x40(%rbp),%rax
movabs $0xfffffffffffff,%rcx
and    %rcx,%rax
mov    %eax,-0x48(%rbp)
cmpl   $0xfffffc01,-0x44(%rbp)
jne    1496 <convert+0x356>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    14aa <convert+0x36a>
movslq -0x48(%rbp),%rax
movabs $0x10000000000000,%rcx
or     %rcx,%rax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%ecx
add    $0x4,%ecx
mov    -0x48(%rbp),%eax
shl    %cl,%eax
mov    %eax,-0x48(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1512 <convert+0x3d2>
movslq -0x48(%rbp),%rax
movabs $0xffffffffffffff,%rcx
and    %rcx,%rax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
shl    $0x1,%eax
mov    -0x48(%rbp),%ecx
shl    $0x3,%ecx
add    %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    $0x38,%ecx
sar    %cl,%eax
add    $0x30,%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x50(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    14b8 <convert+0x378>
movslq -0x48(%rbp),%rax
movabs $0x80000000000000,%rcx
and    %rcx,%rax
cmp    $0x0,%rax
je     158b <convert+0x44b>
jmp    1532 <convert+0x3f2>
mov    -0x50(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x50(%rbp)
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x59(%rbp)
je     1565 <convert+0x425>
mov    -0x18(%rbp),%rcx
movslq -0x50(%rbp),%rdx
mov    (%rcx,%rdx,1),%al
add    $0x1,%al
mov    %al,(%rcx,%rdx,1)
movsbl %al,%eax
cmp    $0x39,%eax
setg   %al
mov    %al,-0x59(%rbp)
mov    -0x59(%rbp),%al
test   $0x1,%al
jne    1575 <convert+0x435>
jmp    1586 <convert+0x446>
mov    -0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movb   $0x30,(%rax,%rcx,1)
jmp    1532 <convert+0x3f2>
jmp    158b <convert+0x44b>
cmpl   $0x0,-0x50(%rbp)
je     15b7 <convert+0x477>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    15f0 <convert+0x4b0>
cmpl   $0x0,-0x34(%rbp)
je     15d5 <convert+0x495>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x31,(%rax)
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<convert>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %r8d,%r12d
mov    %rdx,%r14
mov    %esi,%r13d
mov    %rdi,%r15
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
movsd  %xmm0,(%rsp)
jne    1172 <convert+0x32>
jp     1172 <convert+0x32>
xor    %eax,%eax
test   %r12d,%r12d
sete   %al
jmp    117e <convert+0x3e>
call   1060 <log10@plt>
mov    %eax,%edi
call   1030 <ceil@plt>
cmp    $0xfffffece,%eax
mov    $0xfffffecd,%ebp
cmovge %eax,%ebp
mov    %ebp,%edi
neg    %edi
movsd  0xe69(%rip),%xmm0
call   1050 <pow@plt>
mulsd  (%rsp),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11ad <convert+0x6d>
jnp    11fd <convert+0xbd>
movsd  0xe53(%rip),%xmm2
movsd  0xe43(%rip),%xmm3
ucomisd %xmm0,%xmm2
jbe    11dd <convert+0x9d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mulsd  %xmm3,%xmm0
add    $0xffffffff,%ebp
ucomisd %xmm0,%xmm2
ja     11d0 <convert+0x90>
ucomisd 0xe2b(%rip),%xmm0
jb     11fd <convert+0xbd>
movsd  0xe21(%rip),%xmm2
nop
divsd  %xmm3,%xmm0
add    $0x1,%ebp
ucomisd %xmm2,%xmm0
jae    11f0 <convert+0xb0>
ucomisd %xmm1,%xmm0
setnp  %al
sete   %cl
and    %al,%cl
ucomisd 0xdf7(%rip),%xmm0
setae  %al
movsd  0xdf4(%rip),%xmm1
ucomisd %xmm0,%xmm1
seta   %dl
and    %al,%dl
or     %cl,%dl
movzbl %dl,%edi
call   1040 <assert@plt>
test   %r12d,%r12d
je     124f <convert+0x10f>
mov    %ebp,%ebx
add    %r13d,%ebx
js     1280 <convert+0x140>
mov    %ebp,(%r14)
cmp    $0x3,%ebp
jl     124a <convert+0x10a>
xor    %edi,%edi
call   1040 <assert@plt>
mov    %ebx,%r13d
jmp    1252 <convert+0x112>
mov    %ebp,(%r14)
mov    $0x1,%edi
call   1040 <assert@plt>
test   %r13d,%r13d
jle    133b <convert+0x1fb>
movabs $0xa00000000,%rax
lea    -0x1(%r13),%edx
mov    %r13d,%ecx
and    $0x7,%ecx
cmp    $0x7,%edx
jae    1292 <convert+0x152>
jmp    12e5 <convert+0x1a5>
neg    %r13d
mov    %r13d,(%r14)
lea    0xd8b(%rip),%r15
jmp    1354 <convert+0x214>
mov    %r13d,%esi
and    $0xfffffff8,%esi
nopl   0x0(%rax,%rax,1)
imul   %rax,%rdx
sar    $0x20,%rdx
imul   %rax,%rdx
sar    $0x20,%rdx
imul   %rax,%rdx
sar    $0x20,%rdx
imul   %rax,%rdx
sar    $0x20,%rdx
imul   %rax,%rdx
sar    $0x20,%rdx
imul   %rax,%rdx
sar    $0x20,%rdx
imul   %rax,%rdx
sar    $0x20,%rdx
imul   %rax,%rdx
sar    $0x20,%rdx
add    $0xfffffff8,%esi
jne    12a0 <convert+0x160>
test   %ecx,%ecx
je     12fd <convert+0x1bd>
nopl   0x0(%rax)
imul   %rax,%rdx
sar    $0x20,%rdx
add    $0xffffffff,%ecx
jne    12f0 <convert+0x1b0>
bt     $0x37,%rdx
movslq %r13d,%rax
jb     1313 <convert+0x1d3>
movb   $0x0,0x1(%rax,%r15,1)
add    $0x1,%r15
jmp    1354 <convert+0x214>
lea    (%r15,%rax,1),%rcx
mov    %r13d,%edx
neg    %edx
xor    %esi,%esi
xchg   %ax,%ax
movzbl (%rcx,%rsi,1),%ebx
add    $0x1,%bl
mov    %bl,(%rcx,%rsi,1)
cmp    $0x3a,%bl
jl     1307 <convert+0x1c7>
movb   $0x30,(%rcx,%rsi,1)
add    $0xffffffffffffffff,%rsi
cmp    %esi,%edx
jne    1320 <convert+0x1e0>
test   %r12d,%r12d
je     1348 <convert+0x208>
add    $0x1,%r13d
addl   $0x1,(%r14)
movb   $0x31,(%r15)
movslq %r13d,%rax
movb   $0x0,(%r15,%rax,1)
mov    %r15,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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