#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;
typedef int uint32_t;

/* Variables and functions */
int /*<<< orphan*/ assert(char *);
int grisu3(double, char *, int *, int *);
scalar_t__ i_to_str(int, char *);
int /*<<< orphan*/ memmove(char *, char *, int);
int sprintf(char *, char *, double, ...);
int dtoa_grisu3(double v, char *dst) {
  int d_exp, len, success, decimals, i;
  uint64_t u64 = (*(uint64_t *)&v);
  char *s2 = dst;
  assert(dst);
  if ((u64 << 1) > 0xFFE0000000000000ULL) {
    return sprintf(dst, "NaN(%08X%08X)", (uint32_t)(u64 >> 32), (uint32_t)u64);
  }
  if ((u64 & 0x8000000000000000ULL) != 0) {
    *s2++ = '-';
    v = -v;
    u64 ^= 0x8000000000000000ULL;
  }
  if (!u64) {
    *s2++ = '0';
    *s2 = '\0';
    return (int)(s2 - dst);
  }
  if (u64 == 0x7FF0000000000000ULL) {
    *s2++ = 'i';
    *s2++ = 'n';
    *s2++ = 'f';
    *s2 = '\0';
    return (int)(s2 - dst);
  }
  success = grisu3(v, s2, &len, &d_exp);
  if (!success) {
    return sprintf(s2, "%.17g", v) + (int)(s2 - dst);
  }
  if (d_exp >= 0 && d_exp <= ((2) >= (15 - len) ? (2) : (15 - len))) {
    while (d_exp-- > 0) {
      s2[len++] = '0';
    }
    s2[len] = '\0';
    return (int)(s2 + len - dst);
  }
  decimals = ((-d_exp) <= (((1) >= (len - 1) ? (1) : (len - 1)))
                  ? (-d_exp)
                  : (((1) >= (len - 1) ? (1) : (len - 1))));
  if (d_exp < 0 && (len + d_exp) > -3 && len <= -d_exp) {
    memmove(s2 + 2 - d_exp - len, s2, len);
    s2[0] = '0';
    s2[1] = '.';
    for (i = 2; i < 2 - d_exp - len; ++i) {
      s2[i] = '0';
    }
    len += i;
  } else if (d_exp < 0 && len > 1) {
    for (i = 0; i < decimals; ++i) {
      s2[len - i] = s2[len - i - 1];
    }
    s2[len++ - decimals] = '.';
    d_exp += decimals;
    if (d_exp != 0) {
      s2[len++] = 'e';
      len += i_to_str(d_exp, s2 + len);
    }
  } else if (d_exp < 0 || d_exp > 2) {
    s2[len++] = 'e';
    len += i_to_str(d_exp, s2 + len);
  }
  s2[len] = '\0';
  return (int)(s2 + len - dst);
}


x86 assembly (clang, -O0):
<dtoa_grisu3>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
movsd  %xmm0,-0x10(%rbp)
mov    %rdi,-0x18(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rdi
call   1040 <assert@plt>
mov    -0x30(%rbp),%eax
shl    $0x1,%eax
cltq
movabs $0xffe0000000000000,%rcx
cmp    %rcx,%rax
jbe    11be <dtoa_grisu3+0x6e>
mov    -0x18(%rbp),%rdi
mov    -0x30(%rbp),%eax
mov    $0x20,%ecx
sar    %cl,%eax
cvtsi2sd %eax,%xmm0
mov    -0x30(%rbp),%edx
lea    0xe51(%rip),%rsi
mov    $0x1,%al
call   1070 <sprintf@plt>
mov    %eax,-0x4(%rbp)
jmp    160f <dtoa_grisu3+0x4bf>
movslq -0x30(%rbp),%rax
movabs $0x8000000000000000,%rcx
and    %rcx,%rax
cmp    $0x0,%rax
je     1220 <dtoa_grisu3+0xd0>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x2d,(%rax)
movsd  -0x10(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x10(%rbp)
movslq -0x30(%rbp),%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jne    1256 <dtoa_grisu3+0x106>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x30,(%rax)
mov    -0x38(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x4(%rbp)
jmp    160f <dtoa_grisu3+0x4bf>
movslq -0x30(%rbp),%rax
movabs $0x7ff0000000000000,%rcx
cmp    %rcx,%rax
jne    12bd <dtoa_grisu3+0x16d>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x69,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x6e,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x66,(%rax)
mov    -0x38(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x4(%rbp)
jmp    160f <dtoa_grisu3+0x4bf>
movsd  -0x10(%rbp),%xmm0
mov    -0x38(%rbp),%rdi
lea    -0x20(%rbp),%rsi
lea    -0x1c(%rbp),%rdx
call   1030 <grisu3@plt>
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jne    130c <dtoa_grisu3+0x1bc>
mov    -0x38(%rbp),%rdi
movsd  -0x10(%rbp),%xmm0
lea    0xd1e(%rip),%rsi
mov    $0x1,%al
call   1070 <sprintf@plt>
mov    -0x38(%rbp),%rcx
mov    -0x18(%rbp),%rdx
sub    %rdx,%rcx
add    %ecx,%eax
mov    %eax,-0x4(%rbp)
jmp    160f <dtoa_grisu3+0x4bf>
cmpl   $0x0,-0x1c(%rbp)
jl     13b1 <dtoa_grisu3+0x261>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    $0xf,%ecx
sub    -0x20(%rbp),%ecx
mov    $0x2,%eax
cmp    %ecx,%eax
jl     133e <dtoa_grisu3+0x1ee>
mov    $0x2,%eax
mov    %eax,-0x40(%rbp)
jmp    1349 <dtoa_grisu3+0x1f9>
mov    $0xf,%eax
sub    -0x20(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x40(%rbp),%ecx
cmp    %ecx,%eax
jg     13b1 <dtoa_grisu3+0x261>
jmp    135c <dtoa_grisu3+0x20c>
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x1c(%rbp)
cmp    $0x0,%eax
jle    138b <dtoa_grisu3+0x23b>
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x20(%rbp)
movslq %ecx,%rcx
movb   $0x30,(%rax,%rcx,1)
jmp    135c <dtoa_grisu3+0x20c>
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x4(%rbp)
jmp    160f <dtoa_grisu3+0x4bf>
xor    %eax,%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
mov    $0x1,%eax
cmp    %ecx,%eax
jl     13d9 <dtoa_grisu3+0x289>
mov    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    13e2 <dtoa_grisu3+0x292>
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x48(%rbp),%ecx
cmp    %ecx,%eax
jg     13fd <dtoa_grisu3+0x2ad>
xor    %eax,%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    142c <dtoa_grisu3+0x2dc>
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
mov    $0x1,%eax
cmp    %ecx,%eax
jl     141d <dtoa_grisu3+0x2cd>
mov    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1426 <dtoa_grisu3+0x2d6>
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jge    14db <dtoa_grisu3+0x38b>
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
cmp    $0xfffffffd,%eax
jle    14db <dtoa_grisu3+0x38b>
mov    -0x20(%rbp),%eax
xor    %ecx,%ecx
sub    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jg     14db <dtoa_grisu3+0x38b>
mov    -0x38(%rbp),%rdi
add    $0x2,%rdi
movslq -0x1c(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rdi
movslq -0x20(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rdi
mov    -0x38(%rbp),%rsi
mov    -0x20(%rbp),%edx
call   1060 <memmove@plt>
mov    -0x38(%rbp),%rax
movb   $0x30,(%rax)
mov    -0x38(%rbp),%rax
movb   $0x2e,0x1(%rax)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x2,%ecx
sub    -0x1c(%rbp),%ecx
sub    -0x20(%rbp),%ecx
cmp    %ecx,%eax
jge    14cd <dtoa_grisu3+0x37d>
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movb   $0x30,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    149d <dtoa_grisu3+0x34d>
mov    -0x2c(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    15ee <dtoa_grisu3+0x49e>
cmpl   $0x0,-0x1c(%rbp)
jge    159a <dtoa_grisu3+0x44a>
cmpl   $0x1,-0x20(%rbp)
jle    159a <dtoa_grisu3+0x44a>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1533 <dtoa_grisu3+0x3e3>
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14f6 <dtoa_grisu3+0x3a6>
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x20(%rbp)
sub    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x2e,(%rax,%rcx,1)
mov    -0x28(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
je     1595 <dtoa_grisu3+0x445>
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x20(%rbp)
movslq %ecx,%rcx
movb   $0x65,(%rax,%rcx,1)
mov    -0x1c(%rbp),%edi
mov    -0x38(%rbp),%rsi
movslq -0x20(%rbp),%rax
add    %rax,%rsi
call   1050 <i_to_str@plt>
mov    %rax,%rcx
movslq -0x20(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x20(%rbp)
jmp    15e9 <dtoa_grisu3+0x499>
cmpl   $0x0,-0x1c(%rbp)
jl     15ae <dtoa_grisu3+0x45e>
cmpl   $0x2,-0x1c(%rbp)
jle    15e4 <dtoa_grisu3+0x494>
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x20(%rbp)
movslq %ecx,%rcx
movb   $0x65,(%rax,%rcx,1)
mov    -0x1c(%rbp),%edi
mov    -0x38(%rbp),%rsi
movslq -0x20(%rbp),%rax
add    %rax,%rsi
call   1050 <i_to_str@plt>
mov    %rax,%rcx
movslq -0x20(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x20(%rbp)
jmp    15e9 <dtoa_grisu3+0x499>
jmp    15ee <dtoa_grisu3+0x49e>
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dtoa_grisu3>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x20,%rsp
mov    %rdi,%r13
movdqa %xmm0,0x10(%rsp)
movq   %xmm0,%rbx
call   1050 <assert@plt>
test   $0x40000000,%ebx
jne    1229 <dtoa_grisu3+0xc9>
movaps 0x10(%rsp),%xmm0
test   $0x80000000,%ebx
jne    1249 <dtoa_grisu3+0xe9>
mov    %r13,%r14
test   %ebx,%ebx
je     1261 <dtoa_grisu3+0x101>
lea    0x8(%rsp),%rsi
lea    0xc(%rsp),%rdx
movaps %xmm0,0x10(%rsp)
mov    %r14,%rdi
call   1030 <grisu3@plt>
test   %eax,%eax
je     1276 <dtoa_grisu3+0x116>
movslq 0xc(%rsp),%r12
mov    %r12d,%edx
mov    0x8(%rsp),%r15d
movslq %r15d,%rdi
test   %r12,%r12
js     11f9 <dtoa_grisu3+0x99>
mov    $0xf,%eax
sub    %r15d,%eax
cmp    $0xd,%r15d
mov    $0x2,%ecx
cmovl  %eax,%ecx
cmp    %ecx,%r12d
jle    129a <dtoa_grisu3+0x13a>
mov    %edx,%ecx
neg    %ecx
lea    -0x1(%r15),%esi
cmp    $0x3,%r15d
mov    $0x1,%eax
cmovge %esi,%eax
cmp    %ecx,%eax
cmovge %ecx,%eax
test   %edx,%edx
js     12b8 <dtoa_grisu3+0x158>
cmp    $0x3,%r12d
jae    1345 <dtoa_grisu3+0x1e5>
jmp    136f <dtoa_grisu3+0x20f>
lea    0xde0(%rip),%rsi
mov    %r13,%rdi
mov    %ebx,%edx
mov    $0x1,%al
add    $0x20,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
jmp    1080 <sprintf@plt>
lea    0x1(%r13),%r14
movb   $0x2d,0x0(%r13)
xorps  0xda7(%rip),%xmm0
test   %ebx,%ebx
jne    11a8 <dtoa_grisu3+0x48>
movw   $0x30,(%r14)
sub    %r13d,%r14d
add    $0x1,%r14d
mov    %r14d,%eax
jmp    137e <dtoa_grisu3+0x21e>
lea    0xda1(%rip),%rsi
mov    %r14,%rdi
movaps 0x10(%rsp),%xmm0
mov    $0x1,%al
call   1080 <sprintf@plt>
sub    %r13d,%r14d
add    %eax,%r14d
mov    %r14d,%eax
jmp    137e <dtoa_grisu3+0x21e>
test   %rdx,%rdx
je     136f <dtoa_grisu3+0x20f>
add    %r14,%rdi
mov    $0x30,%esi
call   1040 <memset@plt>
add    %r12d,%r15d
jmp    136a <dtoa_grisu3+0x20a>
lea    (%r15,%r12,1),%esi
cmp    $0xfffffffe,%esi
jl     131f <dtoa_grisu3+0x1bf>
cmp    %ecx,%r15d
jg     131f <dtoa_grisu3+0x1bf>
neg    %r12
lea    (%r14,%r12,1),%rax
add    $0x2,%rax
sub    %rdi,%rax
mov    %rax,%rdi
mov    %r14,%rsi
mov    %r15d,%edx
call   1070 <memmove@plt>
movw   $0x2e30,(%r14)
mov    0x8(%rsp),%r15d
mov    0xc(%rsp),%ebx
add    %r15d,%ebx
mov    $0x2,%eax
cmp    $0x80000003,%ebx
jb     131a <dtoa_grisu3+0x1ba>
lea    0x2(%r14),%rdi
mov    %ebx,%edx
neg    %edx
mov    $0x30,%esi
call   1040 <memset@plt>
mov    $0x2,%eax
sub    %ebx,%eax
add    %eax,%r15d
jmp    136a <dtoa_grisu3+0x20a>
cmp    $0x2,%r15d
jl     1345 <dtoa_grisu3+0x1e5>
test   %eax,%eax
jle    13d1 <dtoa_grisu3+0x271>
mov    %eax,%r9d
lea    -0x1(%r9),%rcx
mov    %r9d,%r8d
and    $0x3,%r8d
cmp    $0x3,%rcx
jae    138c <dtoa_grisu3+0x22c>
xor    %ebx,%ebx
jmp    13ad <dtoa_grisu3+0x24d>
lea    0x1(%rdi),%rax
mov    %eax,0x8(%rsp)
movb   $0x65,(%r14,%rdi,1)
lea    (%r14,%rdi,1),%rsi
add    $0x1,%rsi
mov    %r12d,%edi
call   1060 <i_to_str@plt>
mov    %rax,%r15
add    0x8(%rsp),%r15d
mov    %r15d,0x8(%rsp)
movslq %r15d,%rcx
lea    (%r14,%rcx,1),%rax
movb   $0x0,(%r14,%rcx,1)
sub    %r13d,%eax
add    $0x20,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret
lea    (%r14,%r15,1),%rcx
and    $0xfffffffc,%r9d
neg    %r9
xor    %ebx,%ebx
mov    -0x4(%rcx,%rbx,1),%esi
mov    %esi,-0x3(%rcx,%rbx,1)
add    $0xfffffffffffffffc,%rbx
cmp    %rbx,%r9
jne    1399 <dtoa_grisu3+0x239>
neg    %rbx
test   %r8,%r8
je     13d1 <dtoa_grisu3+0x271>
mov    %r15,%rcx
sub    %rbx,%rcx
add    %r14,%rcx
neg    %r8
xor    %esi,%esi
movzbl -0x1(%rcx,%rsi,1),%ebx
mov    %bl,(%rcx,%rsi,1)
add    $0xffffffffffffffff,%rsi
cmp    %rsi,%r8
jne    13c0 <dtoa_grisu3+0x260>
lea    0x1(%rdi),%rcx
sub    %eax,%r15d
movslq %r15d,%rsi
movb   $0x2e,(%r14,%rsi,1)
add    %eax,%edx
mov    %edx,0xc(%rsp)
je     1404 <dtoa_grisu3+0x2a4>
lea    0x2(%rdi),%rax
mov    %eax,0x8(%rsp)
movb   $0x65,(%r14,%rcx,1)
lea    (%r14,%rdi,1),%rsi
add    $0x2,%rsi
mov    %edx,%edi
jmp    135d <dtoa_grisu3+0x1fd>
mov    %ecx,%r15d
jmp    136f <dtoa_grisu3+0x20f>

LLVM IR (-O0):
@.str = [14 x i8] c"NaN(%08X%08X)\00"
@.str.1 = [6 x i8] c"%.17g\00"
define i32 @dtoa_grisu3(double %0, i8* %1) {
%3 = alloca i32
%4 = alloca double
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i8*
store double %0, double* %4
store i8* %1, i8** %5
%13 = bitcast double* %4 to i32*
%14 = load i32, i32* %13
store i32 %14, i32* %11
%15 = load i8*, i8** %5
store i8* %15, i8** %12
%16 = load i8*, i8** %5
%17 = call i32 @assert(i8* %16)
%18 = load i32, i32* %11
%19 = shl i32 %18, 1
%20 = sext i32 %19 to i64
%21 = icmp ugt i64 %20, -9007199254740992
br i1 %21, label %22, label %29
22: ; preds = %2
%23 = load i8*, i8** %5
%24 = load i32, i32* %11
%25 = ashr i32 %24, 32
%26 = sitofp i32 %25 to double
%27 = load i32, i32* %11
%28 = call i32 (i8*, i8*, double, ...) @sprintf(i8* %23, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0), double %26, i32 %27)
store i32 %28, i32* %3
br label %305
29: ; preds = %2
%30 = load i32, i32* %11
%31 = sext i32 %30 to i64
%32 = and i64 %31, -9223372036854775808
%33 = icmp ne i64 %32, 0
br i1 %33, label %34, label %43
34: ; preds = %29
%35 = load i8*, i8** %12
%36 = getelementptr inbounds i8, i8* %35, i32 1
store i8* %36, i8** %12
store i8 45, i8* %35
%37 = load double, double* %4
%38 = fneg double %37
store double %38, double* %4
%39 = load i32, i32* %11
%40 = sext i32 %39 to i64
%41 = xor i64 %40, -9223372036854775808
%42 = trunc i64 %41 to i32
store i32 %42, i32* %11
br label %43
43: ; preds = %34, %29
%44 = load i32, i32* %11
%45 = icmp ne i32 %44, 0
br i1 %45, label %56, label %46
46: ; preds = %43
%47 = load i8*, i8** %12
%48 = getelementptr inbounds i8, i8* %47, i32 1
store i8* %48, i8** %12
store i8 48, i8* %47
%49 = load i8*, i8** %12
store i8 0, i8* %49
%50 = load i8*, i8** %12
%51 = load i8*, i8** %5
%52 = ptrtoint i8* %50 to i64
%53 = ptrtoint i8* %51 to i64
%54 = sub i64 %52, %53
%55 = trunc i64 %54 to i32
store i32 %55, i32* %3
br label %305
56: ; preds = %43
%57 = load i32, i32* %11
%58 = sext i32 %57 to i64
%59 = icmp eq i64 %58, 9218868437227405312
br i1 %59, label %60, label %74
60: ; preds = %56
%61 = load i8*, i8** %12
%62 = getelementptr inbounds i8, i8* %61, i32 1
store i8* %62, i8** %12
store i8 105, i8* %61
%63 = load i8*, i8** %12
%64 = getelementptr inbounds i8, i8* %63, i32 1
store i8* %64, i8** %12
store i8 110, i8* %63
%65 = load i8*, i8** %12
%66 = getelementptr inbounds i8, i8* %65, i32 1
store i8* %66, i8** %12
store i8 102, i8* %65
%67 = load i8*, i8** %12
store i8 0, i8* %67
%68 = load i8*, i8** %12
%69 = load i8*, i8** %5
%70 = ptrtoint i8* %68 to i64
%71 = ptrtoint i8* %69 to i64
%72 = sub i64 %70, %71
%73 = trunc i64 %72 to i32
store i32 %73, i32* %3
br label %305
74: ; preds = %56
%75 = load double, double* %4
%76 = load i8*, i8** %12
%77 = call i32 @grisu3(double %75, i8* %76, i32* %7, i32* %6)
store i32 %77, i32* %8
%78 = load i32, i32* %8
%79 = icmp ne i32 %78, 0
br i1 %79, label %91, label %80
80: ; preds = %74
%81 = load i8*, i8** %12
%82 = load double, double* %4
%83 = call i32 (i8*, i8*, double, ...) @sprintf(i8* %81, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0), double %82)
%84 = load i8*, i8** %12
%85 = load i8*, i8** %5
%86 = ptrtoint i8* %84 to i64
%87 = ptrtoint i8* %85 to i64
%88 = sub i64 %86, %87
%89 = trunc i64 %88 to i32
%90 = add nsw i32 %83, %89
store i32 %90, i32* %3
br label %305
91: ; preds = %74
%92 = load i32, i32* %6
%93 = icmp sge i32 %92, 0
br i1 %93, label %94, label %131
94: ; preds = %91
%95 = load i32, i32* %6
%96 = load i32, i32* %7
%97 = sub nsw i32 15, %96
%98 = icmp sge i32 2, %97
br i1 %98, label %99, label %100
99: ; preds = %94
br label %103
100: ; preds = %94
%101 = load i32, i32* %7
%102 = sub nsw i32 15, %101
br label %103
103: ; preds = %100, %99
%104 = phi i32 [ 2, %99 ], [ %102, %100 ]
%105 = icmp sle i32 %95, %104
br i1 %105, label %106, label %131
106: ; preds = %103
br label %107
107: ; preds = %111, %106
%108 = load i32, i32* %6
%109 = add nsw i32 %108, -1
store i32 %109, i32* %6
%110 = icmp sgt i32 %108, 0
br i1 %110, label %111, label %117
111: ; preds = %107
%112 = load i8*, i8** %12
%113 = load i32, i32* %7
%114 = add nsw i32 %113, 1
store i32 %114, i32* %7
%115 = sext i32 %113 to i64
%116 = getelementptr inbounds i8, i8* %112, i64 %115
store i8 48, i8* %116
br label %107
117: ; preds = %107
%118 = load i8*, i8** %12
%119 = load i32, i32* %7
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds i8, i8* %118, i64 %120
store i8 0, i8* %121
%122 = load i8*, i8** %12
%123 = load i32, i32* %7
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds i8, i8* %122, i64 %124
%126 = load i8*, i8** %5
%127 = ptrtoint i8* %125 to i64
%128 = ptrtoint i8* %126 to i64
%129 = sub i64 %127, %128
%130 = trunc i64 %129 to i32
store i32 %130, i32* %3
br label %305
131: ; preds = %103, %91
%132 = load i32, i32* %6
%133 = sub nsw i32 0, %132
%134 = load i32, i32* %7
%135 = sub nsw i32 %134, 1
%136 = icmp sge i32 1, %135
br i1 %136, label %137, label %138
137: ; preds = %131
br label %141
138: ; preds = %131
%139 = load i32, i32* %7
%140 = sub nsw i32 %139, 1
br label %141
141: ; preds = %138, %137
%142 = phi i32 [ 1, %137 ], [ %140, %138 ]
%143 = icmp sle i32 %133, %142
br i1 %143, label %144, label %147
144: ; preds = %141
%145 = load i32, i32* %6
%146 = sub nsw i32 0, %145
br label %157
147: ; preds = %141
%148 = load i32, i32* %7
%149 = sub nsw i32 %148, 1
%150 = icmp sge i32 1, %149
br i1 %150, label %151, label %152
151: ; preds = %147
br label %155
152: ; preds = %147
%153 = load i32, i32* %7
%154 = sub nsw i32 %153, 1
br label %155
155: ; preds = %152, %151
%156 = phi i32 [ 1, %151 ], [ %154, %152 ]
br label %157
157: ; preds = %155, %144
%158 = phi i32 [ %146, %144 ], [ %156, %155 ]
store i32 %158, i32* %9
%159 = load i32, i32* %6
%160 = icmp slt i32 %159, 0
br i1 %160, label %161, label %208
161: ; preds = %157
%162 = load i32, i32* %7
%163 = load i32, i32* %6
%164 = add nsw i32 %162, %163
%165 = icmp sgt i32 %164, -3
br i1 %165, label %166, label %208
166: ; preds = %161
%167 = load i32, i32* %7
%168 = load i32, i32* %6
%169 = sub nsw i32 0, %168
%170 = icmp sle i32 %167, %169
br i1 %170, label %171, label %208
171: ; preds = %166
%172 = load i8*, i8** %12
%173 = getelementptr inbounds i8, i8* %172, i64 2
%174 = load i32, i32* %6
%175 = sext i32 %174 to i64
%176 = sub i64 0, %175
%177 = getelementptr inbounds i8, i8* %173, i64 %176
%178 = load i32, i32* %7
%179 = sext i32 %178 to i64
%180 = sub i64 0, %179
%181 = getelementptr inbounds i8, i8* %177, i64 %180
%182 = load i8*, i8** %12
%183 = load i32, i32* %7
%184 = call i32 @memmove(i8* %181, i8* %182, i32 %183)
%185 = load i8*, i8** %12
%186 = getelementptr inbounds i8, i8* %185, i64 0
store i8 48, i8* %186
%187 = load i8*, i8** %12
%188 = getelementptr inbounds i8, i8* %187, i64 1
store i8 46, i8* %188
store i32 2, i32* %10
br label %189
189: ; preds = %201, %171
%190 = load i32, i32* %10
%191 = load i32, i32* %6
%192 = sub nsw i32 2, %191
%193 = load i32, i32* %7
%194 = sub nsw i32 %192, %193
%195 = icmp slt i32 %190, %194
br i1 %195, label %196, label %204
196: ; preds = %189
%197 = load i8*, i8** %12
%198 = load i32, i32* %10
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds i8, i8* %197, i64 %199
store i8 48, i8* %200
br label %201
201: ; preds = %196
%202 = load i32, i32* %10
%203 = add nsw i32 %202, 1
store i32 %203, i32* %10
br label %189
204: ; preds = %189
%205 = load i32, i32* %10
%206 = load i32, i32* %7
%207 = add nsw i32 %206, %205
store i32 %207, i32* %7
br label %291
208: ; preds = %166, %161, %157
%209 = load i32, i32* %6
%210 = icmp slt i32 %209, 0
br i1 %210, label %211, label %267
211: ; preds = %208
%212 = load i32, i32* %7
%213 = icmp sgt i32 %212, 1
br i1 %213, label %214, label %267
214: ; preds = %211
store i32 0, i32* %10
br label %215
215: ; preds = %234, %214
%216 = load i32, i32* %10
%217 = load i32, i32* %9
%218 = icmp slt i32 %216, %217
br i1 %218, label %219, label %237
219: ; preds = %215
%220 = load i8*, i8** %12
%221 = load i32, i32* %7
%222 = load i32, i32* %10
%223 = sub nsw i32 %221, %222
%224 = sub nsw i32 %223, 1
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds i8, i8* %220, i64 %225
%227 = load i8, i8* %226
%228 = load i8*, i8** %12
%229 = load i32, i32* %7
%230 = load i32, i32* %10
%231 = sub nsw i32 %229, %230
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds i8, i8* %228, i64 %232
store i8 %227, i8* %233
br label %234
234: ; preds = %219
%235 = load i32, i32* %10
%236 = add nsw i32 %235, 1
store i32 %236, i32* %10
br label %215
237: ; preds = %215
%238 = load i8*, i8** %12
%239 = load i32, i32* %7
%240 = add nsw i32 %239, 1
store i32 %240, i32* %7
%241 = load i32, i32* %9
%242 = sub nsw i32 %239, %241
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds i8, i8* %238, i64 %243
store i8 46, i8* %244
%245 = load i32, i32* %9
%246 = load i32, i32* %6
%247 = add nsw i32 %246, %245
store i32 %247, i32* %6
%248 = load i32, i32* %6
%249 = icmp ne i32 %248, 0
br i1 %249, label %250, label %266
250: ; preds = %237
%251 = load i8*, i8** %12
%252 = load i32, i32* %7
%253 = add nsw i32 %252, 1
store i32 %253, i32* %7
%254 = sext i32 %252 to i64
%255 = getelementptr inbounds i8, i8* %251, i64 %254
store i8 101, i8* %255
%256 = load i32, i32* %6
%257 = load i8*, i8** %12
%258 = load i32, i32* %7
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds i8, i8* %257, i64 %259
%261 = call i64 @i_to_str(i32 %256, i8* %260)
%262 = load i32, i32* %7
%263 = sext i32 %262 to i64
%264 = add nsw i64 %263, %261
%265 = trunc i64 %264 to i32
store i32 %265, i32* %7
br label %266
266: ; preds = %250, %237
br label %290
267: ; preds = %211, %208
%268 = load i32, i32* %6
%269 = icmp slt i32 %268, 0
br i1 %269, label %273, label %270
270: ; preds = %267
%271 = load i32, i32* %6
%272 = icmp sgt i32 %271, 2
br i1 %272, label %273, label %289
273: ; preds = %270, %267
%274 = load i8*, i8** %12
%275 = load i32, i32* %7
%276 = add nsw i32 %275, 1
store i32 %276, i32* %7
%277 = sext i32 %275 to i64
%278 = getelementptr inbounds i8, i8* %274, i64 %277
store i8 101, i8* %278
%279 = load i32, i32* %6
%280 = load i8*, i8** %12
%281 = load i32, i32* %7
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds i8, i8* %280, i64 %282
%284 = call i64 @i_to_str(i32 %279, i8* %283)
%285 = load i32, i32* %7
%286 = sext i32 %285 to i64
%287 = add nsw i64 %286, %284
%288 = trunc i64 %287 to i32
store i32 %288, i32* %7
br label %289
289: ; preds = %273, %270
br label %290
290: ; preds = %289, %266
br label %291
291: ; preds = %290, %204
%292 = load i8*, i8** %12
%293 = load i32, i32* %7
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds i8, i8* %292, i64 %294
store i8 0, i8* %295
%296 = load i8*, i8** %12
%297 = load i32, i32* %7
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds i8, i8* %296, i64 %298
%300 = load i8*, i8** %5
%301 = ptrtoint i8* %299 to i64
%302 = ptrtoint i8* %300 to i64
%303 = sub i64 %301, %302
%304 = trunc i64 %303 to i32
store i32 %304, i32* %3
br label %305
305: ; preds = %291, %117, %80, %60, %46, %22
%306 = load i32, i32* %3
ret i32 %306
}

LLVM IR (-O2):
@.str = [14 x i8] c"NaN(%08X%08X)\00"
@.str.1 = [6 x i8] c"%.17g\00"
define i32 @dtoa_grisu3(double %0, i8* %1) {
%3 = alloca i32
%4 = alloca i32
%5 = bitcast i32* %3 to i8*
%6 = bitcast i32* %4 to i8*
%7 = bitcast double %0 to i64
%8 = trunc i64 %7 to i32
%9 = tail call i32 @assert(i8* %1)
%10 = and i32 %8, 1073741824
%11 = icmp eq i32 %10, 0
br i1 %11, label %14, label %12
12: ; preds = %2
%13 = tail call i32 (i8*, i8*, double, ...) @sprintf(i8* dereferenceable(1) %1, i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0), double poison, i32 %8)
br label %190
14: ; preds = %2
%15 = and i64 %7, 2147483648
%16 = icmp eq i64 %15, 0
br i1 %16, label %20, label %17
17: ; preds = %14
%18 = getelementptr inbounds i8, i8* %1, i64 1
store i8 45, i8* %1
%19 = fneg double %0
br label %20
20: ; preds = %17, %14
%21 = phi double [ %19, %17 ], [ %0, %14 ]
%22 = phi i8* [ %18, %17 ], [ %1, %14 ]
%23 = icmp eq i32 %8, 0
br i1 %23, label %24, label %30
24: ; preds = %20
%25 = getelementptr inbounds i8, i8* %22, i64 1
store i8 48, i8* %22
store i8 0, i8* %25
%26 = ptrtoint i8* %25 to i64
%27 = ptrtoint i8* %1 to i64
%28 = sub i64 %26, %27
%29 = trunc i64 %28 to i32
br label %190
30: ; preds = %20
%31 = call i32 @grisu3(double %21, i8* %22, i32* %4, i32* %3)
%32 = icmp eq i32 %31, 0
br i1 %32, label %33, label %40
33: ; preds = %30
%34 = call i32 (i8*, i8*, double, ...) @sprintf(i8* dereferenceable(1) %22, i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0), double %21)
%35 = ptrtoint i8* %22 to i64
%36 = ptrtoint i8* %1 to i64
%37 = sub i64 %35, %36
%38 = trunc i64 %37 to i32
%39 = add nsw i32 %34, %38
br label %190
40: ; preds = %30
%41 = load i32, i32* %3
%42 = icmp sgt i32 %41, -1
%43 = load i32, i32* %4
br i1 %42, label %44, label %64
44: ; preds = %40
%45 = sub nsw i32 15, %43
%46 = icmp sgt i32 %43, 12
%47 = select i1 %46, i32 2, i32 %45
%48 = icmp sgt i32 %41, %47
br i1 %48, label %64, label %49
49: ; preds = %44
%50 = icmp eq i32 %41, 0
br i1 %50, label %56, label %51
51: ; preds = %49
%52 = sext i32 %43 to i64
%53 = getelementptr i8, i8* %22, i64 %52
%54 = zext i32 %41 to i64
%55 = add i32 %43, %41
store i32 %55, i32* %4
br label %56
56: ; preds = %51, %49
%57 = phi i32 [ %55, %51 ], [ %43, %49 ]
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds i8, i8* %22, i64 %58
store i8 0, i8* %59
%60 = ptrtoint i8* %59 to i64
%61 = ptrtoint i8* %1 to i64
%62 = sub i64 %60, %61
%63 = trunc i64 %62 to i32
br label %190
64: ; preds = %40, %44
%65 = sub nsw i32 0, %41
%66 = add nsw i32 %43, -1
%67 = icmp slt i32 %43, 3
%68 = select i1 %67, i32 1, i32 %66
%69 = icmp slt i32 %68, %65
%70 = select i1 %69, i32 %68, i32 %65
%71 = icmp slt i32 %41, 0
br i1 %71, label %72, label %170
72: ; preds = %64
%73 = add nsw i32 %43, %41
%74 = icmp slt i32 %73, -2
%75 = icmp sgt i32 %43, %65
%76 = select i1 %74, i1 true, i1 %75
br i1 %76, label %98, label %77
77: ; preds = %72
%78 = getelementptr i8, i8* %22, i64 2
%79 = sext i32 %41 to i64
%80 = sub nsw i64 0, %79
%81 = getelementptr inbounds i8, i8* %78, i64 %80
%82 = sext i32 %43 to i64
%83 = sub nsw i64 0, %82
%84 = getelementptr inbounds i8, i8* %81, i64 %83
%85 = call i32 @memmove(i8* %84, i8* %22, i32 %43)
store i8 48, i8* %22
%86 = getelementptr inbounds i8, i8* %22, i64 1
store i8 46, i8* %86
%87 = load i32, i32* %3
%88 = load i32, i32* %4
%89 = add i32 %87, %88
%90 = icmp ugt i32 %89, -2147483646
br i1 %90, label %91, label %95
91: ; preds = %77
%92 = sub nsw i32 0, %89
%93 = zext i32 %92 to i64
%94 = sub nsw i32 2, %89
br label %95
95: ; preds = %91, %77
%96 = phi i32 [ 2, %77 ], [ %94, %91 ]
%97 = add nsw i32 %88, %96
store i32 %97, i32* %4
br label %182
98: ; preds = %72
%99 = icmp sgt i32 %43, 1
br i1 %99, label %100, label %172
100: ; preds = %98
%101 = icmp sgt i32 %70, 0
br i1 %101, label %102, label %153
102: ; preds = %100
%103 = zext i32 %43 to i64
%104 = zext i32 %70 to i64
%105 = add nsw i64 %104, -1
%106 = and i64 %104, 3
%107 = icmp ult i64 %105, 3
br i1 %107, label %139, label %108
108: ; preds = %102
%109 = and i64 %104, 4294967292
br label %110
110: ; preds = %110, %108
%111 = phi i64 [ 0, %108 ], [ %136, %110 ]
%112 = phi i64 [ 0, %108 ], [ %137, %110 ]
%113 = sub nsw i64 %103, %111
%114 = add nsw i64 %113, -1
%115 = getelementptr inbounds i8, i8* %22, i64 %114
%116 = load i8, i8* %115
%117 = getelementptr inbounds i8, i8* %22, i64 %113
store i8 %116, i8* %117
%118 = xor i64 %111, -1
%119 = add nsw i64 %118, %103
%120 = add nsw i64 %119, -1
%121 = getelementptr inbounds i8, i8* %22, i64 %120
%122 = load i8, i8* %121
%123 = getelementptr inbounds i8, i8* %22, i64 %119
store i8 %122, i8* %123
%124 = or i64 %111, 2
%125 = sub nsw i64 %103, %124
%126 = add nsw i64 %125, -1
%127 = getelementptr inbounds i8, i8* %22, i64 %126
%128 = load i8, i8* %127
%129 = getelementptr inbounds i8, i8* %22, i64 %125
store i8 %128, i8* %129
%130 = or i64 %111, 3
%131 = sub nsw i64 %103, %130
%132 = add nsw i64 %131, -1
%133 = getelementptr inbounds i8, i8* %22, i64 %132
%134 = load i8, i8* %133
%135 = getelementptr inbounds i8, i8* %22, i64 %131
store i8 %134, i8* %135
%136 = add nuw nsw i64 %111, 4
%137 = add i64 %112, 4
%138 = icmp eq i64 %137, %109
br i1 %138, label %139, label %110
139: ; preds = %110, %102
%140 = phi i64 [ 0, %102 ], [ %136, %110 ]
%141 = icmp eq i64 %106, 0
br i1 %141, label %153, label %142
142: ; preds = %139, %142
%143 = phi i64 [ %150, %142 ], [ %140, %139 ]
%144 = phi i64 [ %151, %142 ], [ 0, %139 ]
%145 = sub nsw i64 %103, %143
%146 = add nsw i64 %145, -1
%147 = getelementptr inbounds i8, i8* %22, i64 %146
%148 = load i8, i8* %147
%149 = getelementptr inbounds i8, i8* %22, i64 %145
store i8 %148, i8* %149
%150 = add nuw nsw i64 %143, 1
%151 = add i64 %144, 1
%152 = icmp eq i64 %151, %106
br i1 %152, label %153, label %142
153: ; preds = %139, %142, %100
%154 = add nsw i32 %43, 1
%155 = sub nsw i32 %43, %70
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds i8, i8* %22, i64 %156
store i8 46, i8* %157
%158 = add nsw i32 %70, %41
store i32 %158, i32* %3
%159 = icmp eq i32 %158, 0
br i1 %159, label %182, label %160
160: ; preds = %153
%161 = add nsw i32 %43, 2
store i32 %161, i32* %4
%162 = sext i32 %154 to i64
%163 = getelementptr inbounds i8, i8* %22, i64 %162
store i8 101, i8* %163
%164 = sext i32 %161 to i64
%165 = getelementptr inbounds i8, i8* %22, i64 %164
%166 = call i64 @i_to_str(i32 %158, i8* %165)
%167 = load i32, i32* %4
%168 = trunc i64 %166 to i32
%169 = add i32 %167, %168
store i32 %169, i32* %4
br label %182
170: ; preds = %64
%171 = icmp ugt i32 %41, 2
br i1 %171, label %172, label %182
172: ; preds = %98, %170
%173 = add nsw i32 %43, 1
store i32 %173, i32* %4
%174 = sext i32 %43 to i64
%175 = getelementptr inbounds i8, i8* %22, i64 %174
store i8 101, i8* %175
%176 = sext i32 %173 to i64
%177 = getelementptr inbounds i8, i8* %22, i64 %176
%178 = call i64 @i_to_str(i32 %41, i8* %177)
%179 = load i32, i32* %4
%180 = trunc i64 %178 to i32
%181 = add i32 %179, %180
store i32 %181, i32* %4
br label %182
182: ; preds = %160, %153, %170, %172, %95
%183 = phi i32 [ %169, %160 ], [ %154, %153 ], [ %43, %170 ], [ %181, %172 ], [ %97, %95 ]
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds i8, i8* %22, i64 %184
store i8 0, i8* %185
%186 = ptrtoint i8* %185 to i64
%187 = ptrtoint i8* %1 to i64
%188 = sub i64 %186, %187
%189 = trunc i64 %188 to i32
br label %190
190: ; preds = %182, %56, %33, %24, %12
%191 = phi i32 [ %13, %12 ], [ %63, %56 ], [ %189, %182 ], [ %39, %33 ], [ %29, %24 ]
ret i32 %191
}