#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 */
double modf(double, double *);
char *cvt(double arg, int ndigits, int *decpt, int *sign, char *buf,
          int eflag) {
  int r2;
  double fi, fj;
  char *p, *p1;
  if (ndigits < 0)
    ndigits = 0;
  if (ndigits >= (309 + 43) - 1)
    ndigits = (309 + 43) - 2;
  r2 = 0;
  *sign = 0;
  p = &buf[0];
  if (arg < 0) {
    *sign = 1;
    arg = -arg;
  }
  arg = modf(arg, &fi);
  p1 = &buf[(309 + 43)];
  if (fi != 0) {
    p1 = &buf[(309 + 43)];
    while (fi != 0) {
      fj = modf(fi / 10, &fi);
      *--p1 = (int)((fj + .03) * 10) + '0';
      r2++;
    }
    while (p1 < &buf[(309 + 43)])
      *p++ = *p1++;
  } else if (arg > 0) {
    while ((fj = arg * 10) < 1) {
      arg = fj;
      r2--;
    }
  }
  p1 = &buf[ndigits];
  if (eflag == 0)
    p1 += r2;
  *decpt = r2;
  if (p1 < &buf[0]) {
    buf[0] = '\0';
    return buf;
  }
  while (p <= p1 && p < &buf[(309 + 43)]) {
    arg *= 10;
    arg = modf(arg, &fj);
    *p++ = (int)fj + '0';
  }
  if (p1 >= &buf[(309 + 43)]) {
    buf[(309 + 43) - 1] = '\0';
    return buf;
  }
  p = p1;
  *p1 += 5;
  while (*p1 > '9') {
    *p1 = '0';
    if (p1 > buf) {
      ++*--p1;
    } else {
      *p1 = '1';
      (*decpt)++;
      if (eflag == 0) {
        if (p > buf)
          *p = '0';
        p++;
      }
    }
  }
  *p = '\0';
  return buf;
}


x86 assembly (clang, -O0):
<cvt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
movsd  %xmm0,-0x10(%rbp)
mov    %edi,-0x14(%rbp)
mov    %rsi,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %r8d,-0x34(%rbp)
cmpl   $0x0,-0x14(%rbp)
jge    1141 <cvt+0x31>
movl   $0x0,-0x14(%rbp)
cmpl   $0x15f,-0x14(%rbp)
jl     1155 <cvt+0x45>
movl   $0x15e,-0x14(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x30(%rbp),%rax
mov    %rax,-0x50(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x10(%rbp),%xmm0
jbe    11a7 <cvt+0x97>
mov    -0x28(%rbp),%rax
movl   $0x1,(%rax)
movsd  -0x10(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x10(%rbp)
movsd  -0x10(%rbp),%xmm0
lea    -0x40(%rbp),%rdi
call   1030 <modf@plt>
movsd  %xmm0,-0x10(%rbp)
mov    -0x30(%rbp),%rax
add    $0x160,%rax
mov    %rax,-0x58(%rbp)
movsd  -0x40(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11e5 <cvt+0xd5>
jp     11e5 <cvt+0xd5>
jmp    12ba <cvt+0x1aa>
mov    -0x30(%rbp),%rax
add    $0x160,%rax
mov    %rax,-0x58(%rbp)
movsd  -0x40(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1210 <cvt+0x100>
jp     1210 <cvt+0x100>
jmp    1271 <cvt+0x161>
movsd  -0x40(%rbp),%xmm0
movsd  0xdeb(%rip),%xmm1
divsd  %xmm1,%xmm0
lea    -0x40(%rbp),%rdi
call   1030 <modf@plt>
movsd  %xmm0,-0x48(%rbp)
movsd  0xdd9(%rip),%xmm0
addsd  -0x48(%rbp),%xmm0
movsd  0xdc4(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x58(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x58(%rbp)
mov    %cl,-0x1(%rax)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11f3 <cvt+0xe3>
jmp    1276 <cvt+0x166>
mov    -0x58(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    $0x160,%rcx
cmp    %rcx,%rax
jae    12b5 <cvt+0x1a5>
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x58(%rbp)
mov    (%rax),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
jmp    1276 <cvt+0x166>
jmp    1317 <cvt+0x207>
movsd  -0x10(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1312 <cvt+0x202>
jmp    12d1 <cvt+0x1c1>
movsd  0xd2f(%rip),%xmm1
mulsd  -0x10(%rbp),%xmm1
movsd  %xmm1,-0x48(%rbp)
movsd  0xd15(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    130d <cvt+0x1fd>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x10(%rbp)
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    12d1 <cvt+0x1c1>
jmp    1312 <cvt+0x202>
jmp    1317 <cvt+0x207>
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    1341 <cvt+0x231>
mov    -0x38(%rbp),%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x58(%rbp),%rax
mov    -0x30(%rbp),%rcx
cmp    %rcx,%rax
jae    136f <cvt+0x25f>
mov    -0x30(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x30(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    14d0 <cvt+0x3c0>
jmp    1374 <cvt+0x264>
mov    -0x50(%rbp),%rcx
xor    %eax,%eax
cmp    -0x58(%rbp),%rcx
mov    %al,-0x59(%rbp)
ja     139f <cvt+0x28f>
mov    -0x50(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    $0x160,%rcx
cmp    %rcx,%rax
setb   %al
mov    %al,-0x59(%rbp)
mov    -0x59(%rbp),%al
test   $0x1,%al
jne    13af <cvt+0x29f>
jmp    13f4 <cvt+0x2e4>
movsd  0xc51(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x10(%rbp)
movsd  -0x10(%rbp),%xmm0
lea    -0x48(%rbp),%rdi
call   1030 <modf@plt>
movsd  %xmm0,-0x10(%rbp)
cvttsd2si -0x48(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
jmp    1374 <cvt+0x264>
mov    -0x58(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    $0x160,%rcx
cmp    %rcx,%rax
jb     1424 <cvt+0x314>
mov    -0x30(%rbp),%rax
movb   $0x0,0x15f(%rax)
mov    -0x30(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    14d0 <cvt+0x3c0>
mov    -0x58(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rax
movsbl (%rax),%ecx
add    $0x5,%ecx
mov    %cl,(%rax)
mov    -0x58(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x39,%eax
jle    14c1 <cvt+0x3b1>
mov    -0x58(%rbp),%rax
movb   $0x30,(%rax)
mov    -0x58(%rbp),%rax
cmp    -0x30(%rbp),%rax
jbe    147a <cvt+0x36a>
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x58(%rbp)
mov    -0x1(%rax),%cl
add    $0x1,%cl
mov    %cl,-0x1(%rax)
jmp    14bc <cvt+0x3ac>
mov    -0x58(%rbp),%rax
movb   $0x31,(%rax)
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
cmpl   $0x0,-0x34(%rbp)
jne    14b7 <cvt+0x3a7>
mov    -0x50(%rbp),%rax
cmp    -0x30(%rbp),%rax
jbe    14ab <cvt+0x39b>
mov    -0x50(%rbp),%rax
movb   $0x30,(%rax)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    14bc <cvt+0x3ac>
jmp    1438 <cvt+0x328>
mov    -0x50(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x30(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cvt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r8d,%r15d
mov    %rcx,%rbx
mov    %rsi,%r12
xor    %eax,%eax
test   %edi,%edi
cmovns %edi,%eax
cmp    $0x15e,%eax
mov    $0x15e,%ebp
cmovb  %eax,%ebp
movl   $0x0,(%rdx)
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
jbe    1159 <cvt+0x49>
movl   $0x1,(%rdx)
xorpd  0xea7(%rip),%xmm0
lea    0x20(%rsp),%rdi
call   1030 <modf@plt>
movapd %xmm0,%xmm3
movsd  0x20(%rsp),%xmm0
ucomisd 0xeb3(%rip),%xmm0
jne    117d <cvt+0x6d>
jnp    1310 <cvt+0x200>
mov    %ebp,(%rsp)
movsd  %xmm3,0x10(%rsp)
mov    %r12,0x8(%rsp)
mov    %r15d,0x4(%rsp)
mov    $0x160,%edx
mov    $0x1,%ecx
xor    %eax,%eax
lea    0x20(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rdx,%r15
mov    %rax,%r14
mov    %rcx,%r12
movsd  0xe4f(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    %rbp,%rdi
call   1030 <modf@plt>
movapd %xmm0,%xmm1
addsd  0xe47(%rip),%xmm0
mulsd  0xe2f(%rip),%xmm0
cvttsd2si %xmm0,%eax
add    $0x30,%al
lea    -0x1(%r15),%rdx
mov    %al,-0x1(%rbx,%r15,1)
lea    0x1(%r14),%rax
movsd  0x20(%rsp),%xmm0
lea    0x1(%r12),%rcx
ucomisd 0xe21(%rip),%xmm0
jne    11b0 <cvt+0xa0>
jp     11b0 <cvt+0xa0>
movsd  %xmm1,0x18(%rsp)
cmp    $0x160,%r15
jg     1350 <cvt+0x240>
mov    $0x161,%r13d
sub    %r15,%r13
cmp    $0x8,%r13
jb     124e <cvt+0x13e>
lea    (%rbx,%rdx,1),%rsi
lea    0x160(%rbx),%rcx
cmp    %rbx,%rcx
jbe    1462 <cvt+0x352>
lea    (%rbx,%r13,1),%rcx
cmp    %rcx,%rsi
jae    1462 <cvt+0x352>
xor    %r9d,%r9d
mov    %rdx,%rsi
mov    0x8(%rsp),%r12
movsd  0x10(%rsp),%xmm3
mov    $0x1,%ecx
sub    %r15d,%ecx
lea    (%r9,%r15,1),%r8
test   $0x3,%cl
je     12ab <cvt+0x19b>
mov    $0x1,%cl
sub    %r15b,%cl
movzbl %cl,%edi
and    $0x3,%edi
neg    %rdi
xor    %ebp,%ebp
mov    %rbx,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rdx,%rsi,1),%ecx
mov    %cl,(%rdx,%r9,1)
add    $0xffffffffffffffff,%rbp
add    $0x1,%rdx
cmp    %rbp,%rdi
jne    1290 <cvt+0x180>
sub    %rbp,%rsi
sub    %rbp,%r9
mov    0x4(%rsp),%r15d
add    $0xfffffffffffffea2,%r8
cmp    $0x3,%r8
jb     1363 <cvt+0x253>
lea    (%rsi,%rbx,1),%rdx
add    $0x3,%rdx
sub    %r9,%r14
mov    %rbx,%rdi
lea    (%r9,%rbx,1),%rcx
add    $0x3,%rcx
mov    $0xffffffffffffffff,%rsi
xchg   %ax,%ax
movzbl -0x2(%rdx,%rsi,1),%ebx
mov    %bl,-0x2(%rcx,%rsi,1)
movzbl -0x1(%rdx,%rsi,1),%ebx
mov    %bl,-0x1(%rcx,%rsi,1)
movzbl (%rdx,%rsi,1),%ebx
mov    %bl,(%rcx,%rsi,1)
movzbl 0x1(%rdx,%rsi,1),%ebx
mov    %bl,0x1(%rcx,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%r14
jne    12e0 <cvt+0x1d0>
mov    %rdi,%rbx
jmp    1363 <cvt+0x253>
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm3
jbe    1368 <cvt+0x258>
mov    $0x1,%eax
movsd  0xce9(%rip),%xmm0
movsd  0xce9(%rip),%xmm2
nop
movapd %xmm3,%xmm1
mulsd  %xmm0,%xmm3
add    $0xffffffff,%eax
ucomisd %xmm3,%xmm2
ja     1330 <cvt+0x220>
movsd  %xmm3,0x18(%rsp)
xor    %r13d,%r13d
movapd %xmm1,%xmm3
jmp    136d <cvt+0x25d>
xor    %r13d,%r13d
mov    0x4(%rsp),%r15d
mov    0x8(%rsp),%r12
movsd  0x10(%rsp),%xmm3
mov    (%rsp),%ebp
jmp    136d <cvt+0x25d>
xor    %eax,%eax
xor    %r13d,%r13d
xor    %ecx,%ecx
test   %r15d,%r15d
cmove  %eax,%ecx
mov    %ebp,%edx
movslq %ecx,%rbp
add    %rdx,%rbp
mov    %eax,(%r12)
mov    %rbx,%rax
js     144d <cvt+0x33d>
cmp    %rbp,%r13
jg     13d9 <cvt+0x2c9>
cmp    $0x15f,%r13
ja     13d9 <cvt+0x2c9>
lea    0x18(%rsp),%r14
nopl   (%rax)
mulsd  0xc68(%rip),%xmm3
movapd %xmm3,%xmm0
mov    %r14,%rdi
call   1030 <modf@plt>
cvttsd2si 0x18(%rsp),%eax
add    $0x30,%al
mov    %al,(%rbx,%r13,1)
cmp    %rbp,%r13
jge    13d9 <cvt+0x2c9>
movapd %xmm0,%xmm3
lea    0x1(%r13),%rax
cmp    $0x15f,%r13
mov    %rax,%r13
jb     13a0 <cvt+0x290>
cmp    $0x160,%rbp
jge    1441 <cvt+0x331>
add    %rbx,%rbp
mov    0x0(%rbp),%al
add    $0x5,%al
mov    %al,0x0(%rbp)
cmp    $0x3a,%al
jl     144a <cvt+0x33a>
mov    %rbp,%rax
jmp    1413 <cvt+0x303>
cs nopw 0x0(%rax,%rax,1)
movzbl -0x1(%rbp),%ecx
add    $0x1,%cl
mov    %cl,-0x1(%rbp)
add    $0xffffffffffffffff,%rbp
cmp    $0x39,%cl
jle    144d <cvt+0x33d>
movb   $0x30,0x0(%rbp)
cmp    %rbx,%rbp
ja     1400 <cvt+0x2f0>
movb   $0x31,0x0(%rbp)
addl   $0x1,(%r12)
test   %r15d,%r15d
jne    1436 <cvt+0x326>
cmp    %rbx,%rax
jbe    1432 <cvt+0x322>
movb   $0x30,(%rax)
add    $0x1,%rax
movzbl 0x0(%rbp),%ecx
cmp    $0x39,%cl
jg     1413 <cvt+0x303>
jmp    144d <cvt+0x33d>
lea    0x15f(%rbx),%rax
jmp    144d <cvt+0x33d>
mov    %rbp,%rax
movb   $0x0,(%rax)
mov    %rbx,%rax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0x20,%r13
movsd  0x10(%rsp),%xmm3
jae    1476 <cvt+0x366>
xor    %r9d,%r9d
jmp    1589 <cvt+0x479>
mov    %r13,%r9
and    $0xffffffffffffffe0,%r9
lea    -0x20(%r9),%rdi
mov    %rdi,%r8
shr    $0x5,%r8
add    $0x1,%r8
cmp    $0x60,%rdi
jae    1496 <cvt+0x386>
xor    %ebp,%ebp
jmp    150c <cvt+0x3fc>
mov    %r12,%rdi
and    $0xffffffffffffffe0,%rdi
add    $0xffffffffffffffe0,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
and    $0xfffffffffffffffc,%rdi
xor    %ebp,%ebp
nop
movups (%rsi,%rbp,1),%xmm0
movups 0x10(%rsi,%rbp,1),%xmm1
movups %xmm0,(%rbx,%rbp,1)
movups %xmm1,0x10(%rbx,%rbp,1)
movups 0x20(%rsi,%rbp,1),%xmm0
movups 0x30(%rsi,%rbp,1),%xmm1
movups %xmm0,0x20(%rbx,%rbp,1)
movups %xmm1,0x30(%rbx,%rbp,1)
movups 0x40(%rsi,%rbp,1),%xmm0
movups 0x50(%rsi,%rbp,1),%xmm1
movups %xmm0,0x40(%rbx,%rbp,1)
movups %xmm1,0x50(%rbx,%rbp,1)
movupd 0x60(%rsi,%rbp,1),%xmm0
movupd 0x70(%rsi,%rbp,1),%xmm1
movupd %xmm0,0x60(%rbx,%rbp,1)
movupd %xmm1,0x70(%rbx,%rbp,1)
sub    $0xffffffffffffff80,%rbp
add    $0xfffffffffffffffc,%rdi
jne    14b0 <cvt+0x3a0>
test   $0x3,%r8b
je     156f <cvt+0x45f>
lea    (%rbx,%rbp,1),%rsi
add    $0x10,%rsi
mov    %rbx,%rdi
sub    %rax,%rdi
add    %rbp,%rdi
add    $0x170,%rdi
mov    %r12d,%ecx
and    $0x60,%cl
add    $0xe0,%cl
shr    $0x5,%cl
add    $0x1,%cl
movzbl %cl,%r8d
and    $0x3,%r8d
shl    $0x5,%r8
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rdi,%rbp,1),%xmm0
movupd (%rdi,%rbp,1),%xmm1
movupd %xmm0,-0x10(%rsi,%rbp,1)
movupd %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r8
jne    1550 <cvt+0x440>
cmp    %r9,%r13
jne    1583 <cvt+0x473>
mov    0x4(%rsp),%r15d
mov    0x8(%rsp),%r12
jmp    1363 <cvt+0x253>
test   $0x18,%r13b
je     15db <cvt+0x4cb>
mov    %r9,%rdi
mov    %r13,%r9
and    $0xfffffffffffffff8,%r9
lea    (%rdx,%r9,1),%rsi
lea    (%rbx,%rdi,1),%rbp
and    $0xfffffffffffffff8,%r12
sub    %r12,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x0(%rbp,%rdx,1),%rcx
mov    %rcx,0x0(%rbp)
add    $0x8,%rbp
add    $0x8,%rdi
jne    15b0 <cvt+0x4a0>
cmp    %r9,%r13
mov    0x8(%rsp),%r12
jne    125f <cvt+0x14f>
mov    0x4(%rsp),%r15d
jmp    1363 <cvt+0x253>
add    %r9,%rdx
mov    %rdx,%rsi
mov    0x8(%rsp),%r12
jmp    125f <cvt+0x14f>

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

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