#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 */
scalar_t__ sprintf(char *, char *, ...);
void printAnswerToStream(double *ans) {
  extern char buffer[256];
  extern size_t size;
  double temp[2] = {ans[0], ans[1]}, ulimit = 999.99999945;
  short int pow10[2] = {0, 0};
  if (temp[0] || temp[0] == temp[1]) {
    if (temp[0] && !(((temp[0]) >= 0 ? (temp[0]) : (-(temp[0]))) > 1.7e+308)) {
      if (((temp[0]) >= 0 ? (temp[0]) : (-(temp[0]))) > 999.99999945)
        ulimit = 9.99999945;
      else
        ulimit = 999.99999945;
      while (((temp[0]) >= 0 ? (temp[0]) : (-(temp[0]))) < 0.9999995) {
        temp[0] *= 10;
        pow10[0]--;
      }
      while (((temp[0]) >= 0 ? (temp[0]) : (-(temp[0]))) > ulimit) {
        temp[0] /= 10;
        pow10[0]++;
      }
    }
    size += sprintf(&buffer[size], "%.6g", temp[0]);
    if (pow10[0]) {
      size += sprintf(&buffer[size], " * 10 ^ ");
      if (pow10[0] < 0) {
        size += sprintf(&buffer[size], "(%hd)", pow10[0]);
      } else {
        size += sprintf(&buffer[size], "%hd", pow10[0]);
      }
    }
  }
  if (temp[1]) {
    if (!(((temp[1]) >= 0 ? (temp[1]) : (-(temp[1]))) > 1.7e+308)) {
      if (((temp[1]) >= 0 ? (temp[1]) : (-(temp[1]))) > 999.99999945)
        ulimit = 9.99999945;
      else
        ulimit = 999.99999945;
      while (((temp[1]) >= 0 ? (temp[1]) : (-(temp[1]))) < 0.9999995) {
        temp[1] *= 10;
        pow10[1]--;
      }
      while (((temp[1]) >= 0 ? (temp[1]) : (-(temp[1]))) > ulimit) {
        temp[1] /= 10;
        pow10[1]++;
      }
    }
    if (temp[0]) {
      if (temp[1] < 0) {
        size += sprintf(&buffer[size], " - ");
        temp[1] = -temp[1];
      } else {
        size += sprintf(&buffer[size], " + ");
      }
    }
    size += sprintf(&buffer[size], "%.6g i", temp[1]);
    if (pow10[1]) {
      size += sprintf(&buffer[size], " * 10 ^ ");
      if (pow10[1] < 0) {
        size += sprintf(&buffer[size], "(%hd)", pow10[1]);
      } else {
        size += sprintf(&buffer[size], "%hd", pow10[1]);
      }
    }
  }
}


x86 assembly (clang, -O0):
<printAnswerToStream>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  0xeb1(%rip),%xmm0
movsd  %xmm0,-0x28(%rbp)
lea    -0x2c(%rbp),%rdi
xor    %esi,%esi
mov    $0x4,%edx
call   1030 <memset@plt>
movsd  -0x20(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1192 <printAnswerToStream+0x72>
jp     1192 <printAnswerToStream+0x72>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x18(%rbp),%xmm0
jne    1490 <printAnswerToStream+0x370>
jp     1490 <printAnswerToStream+0x370>
movsd  -0x20(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11af <printAnswerToStream+0x8f>
jp     11af <printAnswerToStream+0x8f>
jmp    1384 <printAnswerToStream+0x264>
movsd  -0x20(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     11d0 <printAnswerToStream+0xb0>
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
jmp    11f1 <printAnswerToStream+0xd1>
movsd  -0x20(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  0xe0a(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     1384 <printAnswerToStream+0x264>
movsd  -0x20(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1229 <printAnswerToStream+0x109>
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    124a <printAnswerToStream+0x12a>
movsd  -0x20(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  0xda9(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1273 <printAnswerToStream+0x153>
movsd  0xda7(%rip),%xmm0
movsd  %xmm0,-0x28(%rbp)
jmp    1280 <printAnswerToStream+0x160>
movsd  0xd85(%rip),%xmm0
movsd  %xmm0,-0x28(%rbp)
jmp    1285 <printAnswerToStream+0x165>
movsd  -0x20(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     12a6 <printAnswerToStream+0x186>
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    12c7 <printAnswerToStream+0x1a7>
movsd  -0x20(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm1
movsd  0xd44(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1301 <printAnswerToStream+0x1e1>
movsd  0xd3a(%rip),%xmm0
mulsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x2c(%rbp),%ax
add    $0xffff,%ax
mov    %ax,-0x2c(%rbp)
jmp    1285 <printAnswerToStream+0x165>
jmp    1306 <printAnswerToStream+0x1e6>
movsd  -0x20(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1327 <printAnswerToStream+0x207>
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    1348 <printAnswerToStream+0x228>
movsd  -0x20(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
ucomisd -0x28(%rbp),%xmm0
jbe    137f <printAnswerToStream+0x25f>
movsd  -0x20(%rbp),%xmm0
movsd  0xcbb(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x2c(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x2c(%rbp)
jmp    1306 <printAnswerToStream+0x1e6>
jmp    1384 <printAnswerToStream+0x264>
mov    0x2c55(%rip),%rdi
mov    0x2c46(%rip),%rax
add    (%rax),%rdi
movsd  -0x20(%rbp),%xmm0
lea    0xc87(%rip),%rsi
mov    $0x1,%al
call   1040 <sprintf@plt>
mov    %rax,%rcx
mov    0x2c26(%rip),%rax
add    (%rax),%rcx
mov    0x2c1c(%rip),%rax
mov    %rcx,(%rax)
cmpw   $0x0,-0x2c(%rbp)
je     148b <printAnswerToStream+0x36b>
mov    0x2c0f(%rip),%rdi
mov    0x2c00(%rip),%rax
add    (%rax),%rdi
lea    0xc4b(%rip),%rsi
mov    $0x0,%al
call   1040 <sprintf@plt>
mov    %rax,%rcx
mov    0x2be5(%rip),%rax
add    (%rax),%rcx
mov    0x2bdb(%rip),%rax
mov    %rcx,(%rax)
movswl -0x2c(%rbp),%eax
cmp    $0x0,%eax
jge    144c <printAnswerToStream+0x32c>
mov    0x2bcc(%rip),%rdi
mov    0x2bbd(%rip),%rax
add    (%rax),%rdi
movswl -0x2c(%rbp),%edx
lea    0xc0d(%rip),%rsi
mov    $0x0,%al
call   1040 <sprintf@plt>
mov    %rax,%rcx
mov    0x2b9e(%rip),%rax
add    (%rax),%rcx
mov    0x2b94(%rip),%rax
mov    %rcx,(%rax)
jmp    1486 <printAnswerToStream+0x366>
mov    0x2b8d(%rip),%rdi
mov    0x2b7e(%rip),%rax
add    (%rax),%rdi
movswl -0x2c(%rbp),%edx
lea    0xbd4(%rip),%rsi
mov    $0x0,%al
call   1040 <sprintf@plt>
mov    %rax,%rcx
mov    0x2b5f(%rip),%rax
add    (%rax),%rcx
mov    0x2b55(%rip),%rax
mov    %rcx,(%rax)
jmp    148b <printAnswerToStream+0x36b>
jmp    1490 <printAnswerToStream+0x370>
movsd  -0x18(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14ad <printAnswerToStream+0x38d>
jp     14ad <printAnswerToStream+0x38d>
jmp    1850 <printAnswerToStream+0x730>
movsd  -0x18(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     14ce <printAnswerToStream+0x3ae>
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    14ef <printAnswerToStream+0x3cf>
movsd  -0x18(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  0xb0c(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     1682 <printAnswerToStream+0x562>
movsd  -0x18(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1527 <printAnswerToStream+0x407>
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    1548 <printAnswerToStream+0x428>
movsd  -0x18(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  0xaab(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1571 <printAnswerToStream+0x451>
movsd  0xaa9(%rip),%xmm0
movsd  %xmm0,-0x28(%rbp)
jmp    157e <printAnswerToStream+0x45e>
movsd  0xa87(%rip),%xmm0
movsd  %xmm0,-0x28(%rbp)
jmp    1583 <printAnswerToStream+0x463>
movsd  -0x18(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     15a4 <printAnswerToStream+0x484>
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    15c5 <printAnswerToStream+0x4a5>
movsd  -0x18(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  0xa46(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    15ff <printAnswerToStream+0x4df>
movsd  0xa3c(%rip),%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x2a(%rbp),%ax
add    $0xffff,%ax
mov    %ax,-0x2a(%rbp)
jmp    1583 <printAnswerToStream+0x463>
jmp    1604 <printAnswerToStream+0x4e4>
movsd  -0x18(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1625 <printAnswerToStream+0x505>
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    1646 <printAnswerToStream+0x526>
movsd  -0x18(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
ucomisd -0x28(%rbp),%xmm0
jbe    167d <printAnswerToStream+0x55d>
movsd  -0x18(%rbp),%xmm0
movsd  0x9bd(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x2a(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x2a(%rbp)
jmp    1604 <printAnswerToStream+0x4e4>
jmp    1682 <printAnswerToStream+0x562>
movsd  -0x20(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    169f <printAnswerToStream+0x57f>
jp     169f <printAnswerToStream+0x57f>
jmp    1744 <printAnswerToStream+0x624>
xorps  %xmm0,%xmm0
ucomisd -0x18(%rbp),%xmm0
jbe    1709 <printAnswerToStream+0x5e9>
mov    0x292c(%rip),%rdi
mov    0x291d(%rip),%rax
add    (%rax),%rdi
lea    0x97b(%rip),%rsi
mov    $0x0,%al
call   1040 <sprintf@plt>
mov    %rax,%rcx
mov    0x2902(%rip),%rax
add    (%rax),%rcx
mov    0x28f8(%rip),%rax
mov    %rcx,(%rax)
movsd  -0x18(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x18(%rbp)
jmp    173f <printAnswerToStream+0x61f>
mov    0x28d0(%rip),%rdi
mov    0x28c1(%rip),%rax
add    (%rax),%rdi
lea    0x923(%rip),%rsi
mov    $0x0,%al
call   1040 <sprintf@plt>
mov    %rax,%rcx
mov    0x28a6(%rip),%rax
add    (%rax),%rcx
mov    0x289c(%rip),%rax
mov    %rcx,(%rax)
jmp    1744 <printAnswerToStream+0x624>
mov    0x2895(%rip),%rdi
mov    0x2886(%rip),%rax
add    (%rax),%rdi
movsd  -0x18(%rbp),%xmm0
lea    0x8e7(%rip),%rsi
mov    $0x1,%al
call   1040 <sprintf@plt>
mov    %rax,%rcx
mov    0x2866(%rip),%rax
add    (%rax),%rcx
mov    0x285c(%rip),%rax
mov    %rcx,(%rax)
cmpw   $0x0,-0x2a(%rbp)
je     184b <printAnswerToStream+0x72b>
mov    0x284f(%rip),%rdi
mov    0x2840(%rip),%rax
add    (%rax),%rdi
lea    0x88b(%rip),%rsi
mov    $0x0,%al
call   1040 <sprintf@plt>
mov    %rax,%rcx
mov    0x2825(%rip),%rax
add    (%rax),%rcx
mov    0x281b(%rip),%rax
mov    %rcx,(%rax)
movswl -0x2a(%rbp),%eax
cmp    $0x0,%eax
jge    180c <printAnswerToStream+0x6ec>
mov    0x280c(%rip),%rdi
mov    0x27fd(%rip),%rax
add    (%rax),%rdi
movswl -0x2a(%rbp),%edx
lea    0x84d(%rip),%rsi
mov    $0x0,%al
call   1040 <sprintf@plt>
mov    %rax,%rcx
mov    0x27de(%rip),%rax
add    (%rax),%rcx
mov    0x27d4(%rip),%rax
mov    %rcx,(%rax)
jmp    1846 <printAnswerToStream+0x726>
mov    0x27cd(%rip),%rdi
mov    0x27be(%rip),%rax
add    (%rax),%rdi
movswl -0x2a(%rbp),%edx
lea    0x814(%rip),%rsi
mov    $0x0,%al
call   1040 <sprintf@plt>
mov    %rax,%rcx
mov    0x279f(%rip),%rax
add    (%rax),%rcx
mov    0x2795(%rip),%rax
mov    %rcx,(%rax)
jmp    184b <printAnswerToStream+0x72b>
jmp    1850 <printAnswerToStream+0x730>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<printAnswerToStream>:
push   %rbp
push   %r14
push   %rbx
sub    $0x20,%rsp
movsd  (%rdi),%xmm7
movsd  0x8(%rdi),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm7
jne    113d <printAnswerToStream+0x2d>
jp     113d <printAnswerToStream+0x2d>
ucomisd %xmm0,%xmm7
jne    1203 <printAnswerToStream+0xf3>
jp     1203 <printAnswerToStream+0xf3>
ucomisd %xmm1,%xmm7
movapd %xmm0,(%rsp)
jne    114a <printAnswerToStream+0x3a>
jnp    117d <printAnswerToStream+0x6d>
movapd 0xeae(%rip),%xmm3
xorpd  %xmm7,%xmm3
xorpd  %xmm1,%xmm1
cmplesd %xmm7,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm7,%xmm2
andnpd %xmm3,%xmm1
orpd   %xmm2,%xmm1
ucomisd 0xea9(%rip),%xmm1
jbe    13ed <printAnswerToStream+0x2dd>
xor    %ebp,%ebp
mov    0x2e52(%rip),%r14
mov    0x2e53(%rip),%rbx
mov    (%r14),%rdi
add    %rbx,%rdi
lea    0xea6(%rip),%rsi
movapd %xmm7,0x10(%rsp)
movapd %xmm7,%xmm0
mov    $0x1,%al
call   1030 <sprintf@plt>
add    (%r14),%rax
mov    %rax,(%r14)
test   %bp,%bp
je     11f8 <printAnswerToStream+0xe8>
add    %rbx,%rax
lea    0xe85(%rip),%rsi
mov    %rax,%rdi
xor    %eax,%eax
call   1030 <sprintf@plt>
add    (%r14),%rax
mov    %rax,(%r14)
movswl %bp,%edx
add    %rax,%rbx
test   %bp,%bp
lea    0xe6e(%rip),%rax
lea    0xe6d(%rip),%rsi
cmovs  %rax,%rsi
mov    %rbx,%rdi
xor    %eax,%eax
call   1030 <sprintf@plt>
add    %rax,(%r14)
movapd (%rsp),%xmm0
movapd 0x10(%rsp),%xmm7
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1213 <printAnswerToStream+0x103>
jnp    13e4 <printAnswerToStream+0x2d4>
movapd 0xde5(%rip),%xmm3
xorpd  %xmm0,%xmm3
cmplesd %xmm0,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm0,%xmm2
andnpd %xmm3,%xmm1
orpd   %xmm2,%xmm1
ucomisd 0xde4(%rip),%xmm1
jbe    1245 <printAnswerToStream+0x135>
xor    %ebp,%ebp
jmp    12fe <printAnswerToStream+0x1ee>
xor    %eax,%eax
ucomisd 0xdd9(%rip),%xmm1
seta   %al
lea    0xdb7(%rip),%rcx
movsd  (%rcx,%rax,8),%xmm2
movsd  0xdc9(%rip),%xmm8
xor    %ebp,%ebp
ucomisd %xmm1,%xmm8
jbe    12af <printAnswerToStream+0x19f>
movsd  0xdc0(%rip),%xmm3
movapd 0xd80(%rip),%xmm4
mulsd  %xmm3,%xmm0
add    $0xffffffff,%ebp
movapd %xmm0,%xmm5
xorpd  %xmm4,%xmm5
xorpd  %xmm1,%xmm1
cmplesd %xmm0,%xmm1
movapd %xmm1,%xmm6
andpd  %xmm0,%xmm6
andnpd %xmm5,%xmm1
orpd   %xmm6,%xmm1
ucomisd %xmm1,%xmm8
ja     1280 <printAnswerToStream+0x170>
ucomisd %xmm2,%xmm1
jbe    12fe <printAnswerToStream+0x1ee>
movsd  0xd7b(%rip),%xmm1
movapd 0xd3b(%rip),%xmm6
cs nopw 0x0(%rax,%rax,1)
nop
divsd  %xmm1,%xmm0
add    $0x1,%ebp
movapd %xmm0,%xmm3
xorpd  %xmm6,%xmm3
xorpd  %xmm4,%xmm4
cmplesd %xmm0,%xmm4
movapd %xmm4,%xmm5
andpd  %xmm0,%xmm5
andnpd %xmm3,%xmm4
orpd   %xmm5,%xmm4
ucomisd %xmm2,%xmm4
ja     12d0 <printAnswerToStream+0x1c0>
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm7
jne    130a <printAnswerToStream+0x1fa>
jnp    134c <printAnswerToStream+0x23c>
mov    0x2cc7(%rip),%rbx
mov    0x2cc8(%rip),%rdi
add    (%rbx),%rdi
ucomisd %xmm0,%xmm1
movapd %xmm0,(%rsp)
jbe    1358 <printAnswerToStream+0x248>
lea    0xd2b(%rip),%rsi
xor    %eax,%eax
call   1030 <sprintf@plt>
movapd (%rsp),%xmm0
mov    %rax,%rdi
add    (%rbx),%rdi
mov    %rdi,(%rbx)
xorpd  0xcb6(%rip),%xmm0
jmp    1374 <printAnswerToStream+0x264>
mov    0x2c85(%rip),%rax
mov    (%rax),%rdi
jmp    1374 <printAnswerToStream+0x264>
lea    0xcfd(%rip),%rsi
xor    %eax,%eax
call   1030 <sprintf@plt>
movapd (%rsp),%xmm0
mov    %rax,%rdi
add    (%rbx),%rdi
mov    %rdi,(%rbx)
add    0x2c65(%rip),%rdi
lea    0xcde(%rip),%rsi
mov    $0x1,%al
call   1030 <sprintf@plt>
mov    0x2c48(%rip),%r14
add    (%r14),%rax
mov    %rax,(%r14)
test   %bp,%bp
je     13e4 <printAnswerToStream+0x2d4>
mov    0x2c3e(%rip),%rbx
add    %rbx,%rax
lea    0xc99(%rip),%rsi
mov    %rax,%rdi
xor    %eax,%eax
call   1030 <sprintf@plt>
add    (%r14),%rax
mov    %rax,(%r14)
movswl %bp,%edx
add    %rax,%rbx
test   %bp,%bp
lea    0xc82(%rip),%rax
lea    0xc81(%rip),%rsi
cmovs  %rax,%rsi
mov    %rbx,%rdi
xor    %eax,%eax
call   1030 <sprintf@plt>
add    %rax,(%r14)
add    $0x20,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret
xor    %eax,%eax
ucomisd 0xc31(%rip),%xmm1
seta   %al
lea    0xc0f(%rip),%rcx
movsd  (%rcx,%rax,8),%xmm2
movsd  0xc21(%rip),%xmm8
xor    %ebp,%ebp
ucomisd %xmm1,%xmm8
jbe    145f <printAnswerToStream+0x34f>
movsd  0xc18(%rip),%xmm3
movapd 0xbd8(%rip),%xmm4
nopl   0x0(%rax,%rax,1)
mulsd  %xmm3,%xmm7
add    $0xffffffff,%ebp
movapd %xmm7,%xmm5
xorpd  %xmm4,%xmm5
xorpd  %xmm1,%xmm1
cmplesd %xmm7,%xmm1
movapd %xmm1,%xmm6
andpd  %xmm7,%xmm6
andnpd %xmm5,%xmm1
orpd   %xmm6,%xmm1
ucomisd %xmm1,%xmm8
ja     1430 <printAnswerToStream+0x320>
ucomisd %xmm2,%xmm1
jbe    117f <printAnswerToStream+0x6f>
movsd  0xbc7(%rip),%xmm1
movapd 0xb87(%rip),%xmm0
nopl   0x0(%rax)
divsd  %xmm1,%xmm7
add    $0x1,%ebp
movapd %xmm7,%xmm3
xorpd  %xmm0,%xmm3
xorpd  %xmm4,%xmm4
cmplesd %xmm7,%xmm4
movapd %xmm4,%xmm5
andpd  %xmm7,%xmm5
andnpd %xmm3,%xmm4
orpd   %xmm5,%xmm4
ucomisd %xmm2,%xmm4
ja     1480 <printAnswerToStream+0x370>
jmp    117f <printAnswerToStream+0x6f>

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

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