#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 */
int /*<<< orphan*/ dd_abs(double const *, double *);
int /*<<< orphan*/ dd_floor(double *, double *);
int dd_is_negative(double const *);
int dd_is_zero(double const *);
int /*<<< orphan*/ dd_log10(double *, double *);
int /*<<< orphan*/ dd_to_digits(double const *, char *, int *, int);
int dd_to_int(double *);
void dd_to_string(const double *a, char *s, int precision, int width, int fixed,
                  int showpos, int uppercase, char fill, int *endstring) {
  int sgn = 1;
  int i, e = 0;
  char *p = s;
  int cnt = 0;
  int off, d;
  double acc[2];
  if (dd_is_negative(a) == 1) {
    *(p++) = '-';
    cnt++;
  } else if (showpos == 1) {
    *(p++) = '+';
    cnt++;
  } else
    sgn = 0;
  if (dd_is_zero(a) == 1) {
    *(p++) = '0';
    cnt++;
    if (precision > 0) {
      *(p++) = '.';
      cnt++;
      for (i = 0; i < precision; i++, cnt++)
        *(p++) = '0';
    }
  } else {
    if (fixed != 1)
      off = 1;
    else {
      dd_abs(a, acc);
      dd_log10(acc, acc);
      dd_floor(acc, acc);
      off = dd_to_int(acc) + 1;
    }
    d = precision + off;
    if ((fixed == 1) && (d <= 0)) {
      *(p++) = '0';
      cnt++;
      if (precision > 0) {
        *(p++) = '.';
        cnt++;
        for (i = 0; i < precision; i++, cnt++)
          *(p++) = '0';
      }
    } else {
      char t[d + 1];
      int j;
      dd_to_digits(a, t, &e, d);
      if (fixed == 1) {
        if (off > 0) {
          for (i = 0; i < off; i++, cnt++)
            *(p++) = t[i];
          if (precision > 0) {
            *(p++) = '.';
            cnt++;
            for (j = 0; j < precision; j++, i++, cnt++)
              *(p++) = t[i];
          }
        } else {
          *(p++) = '0';
          cnt++;
          *(p++) = '.';
          cnt++;
          if (off < 0)
            for (i = 0; i < (-off); i++, cnt++)
              *(p++) = '0';
          for (i = 0; i < d; i++, cnt++)
            *(p++) = t[i];
        }
      } else {
        *(p++) = t[0];
        cnt++;
        if (precision > 0) {
          *(p++) = '.';
          cnt++;
        }
        for (i = 1; i <= precision; i++, cnt++)
          *(p++) = t[i];
      }
    }
  }
  if (fixed == 0) {
    *(p++) = (uppercase == 1) ? 'E' : 'e';
    cnt++;
    *(p++) = (e < 0 ? '-' : '+');
    cnt++;
    if (e < 0)
      e = -e;
    if (e >= 100) {
      i = e / 100;
      *(p++) = '0' + i;
      cnt++;
      e -= 100 * i;
    }
    i = e / 10;
    *(p++) = '0' + i;
    cnt++;
    e -= 10 * i;
    *(p++) = '0' + e;
    cnt++;
  }
  if (cnt >= width) {
    *(p++) = '\0';
    *endstring = cnt + 1;
  } else {
    d = width - cnt;
    for (i = 0; i < cnt; i++)
      s[i + d] = s[i];
    for (i = 0; i < d; i++)
      s[i] = fill;
    s[width] = '\0';
    *endstring = width;
  }
}


x86 assembly (clang, -O0):
<dd_to_string>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%al
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
movl   $0x1,-0x24(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <dd_is_negative@plt>
cmp    $0x1,%eax
jne    11ea <dd_to_string+0x7a>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x2d,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1220 <dd_to_string+0xb0>
cmpl   $0x1,-0x20(%rbp)
jne    1214 <dd_to_string+0xa4>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x2b,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    121b <dd_to_string+0xab>
movl   $0x0,-0x24(%rbp)
jmp    1220 <dd_to_string+0xb0>
mov    -0x8(%rbp),%rdi
call   1050 <dd_is_zero@plt>
cmp    $0x1,%eax
jne    12b8 <dd_to_string+0x148>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x30,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x14(%rbp)
jle    12b3 <dd_to_string+0x143>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x2e,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12ae <dd_to_string+0x13e>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x30,(%rax)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1279 <dd_to_string+0x109>
jmp    12b3 <dd_to_string+0x143>
jmp    1629 <dd_to_string+0x4b9>
cmpl   $0x1,-0x1c(%rbp)
je     12ce <dd_to_string+0x15e>
movl   $0x1,-0x40(%rbp)
jmp    1304 <dd_to_string+0x194>
mov    -0x8(%rbp),%rdi
lea    -0x60(%rbp),%rsi
call   1070 <dd_abs@plt>
lea    -0x60(%rbp),%rdi
lea    -0x60(%rbp),%rsi
call   1080 <dd_log10@plt>
lea    -0x60(%rbp),%rdi
lea    -0x60(%rbp),%rsi
call   1060 <dd_floor@plt>
lea    -0x60(%rbp),%rdi
call   1040 <dd_to_int@plt>
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x14(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x1,-0x1c(%rbp)
jne    13a7 <dd_to_string+0x237>
cmpl   $0x0,-0x44(%rbp)
jg     13a7 <dd_to_string+0x237>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x30,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x14(%rbp)
jle    13a2 <dd_to_string+0x232>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x2e,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    139d <dd_to_string+0x22d>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x30,(%rax)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1368 <dd_to_string+0x1f8>
jmp    13a2 <dd_to_string+0x232>
jmp    1624 <dd_to_string+0x4b4>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %rsp,%rcx
mov    %rcx,-0x68(%rbp)
mov    %rax,%rcx
add    $0xf,%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rsi
sub    %rcx,%rsi
mov    %rsi,-0x80(%rbp)
mov    %rsi,%rsp
mov    %rax,-0x70(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x44(%rbp),%ecx
lea    -0x2c(%rbp),%rdx
call   1090 <dd_to_digits@plt>
cmpl   $0x1,-0x1c(%rbp)
jne    158d <dd_to_string+0x41d>
cmpl   $0x0,-0x40(%rbp)
jle    14b8 <dd_to_string+0x348>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    143a <dd_to_string+0x2ca>
mov    -0x80(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13fb <dd_to_string+0x28b>
cmpl   $0x0,-0x14(%rbp)
jle    14b3 <dd_to_string+0x343>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x2e,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14ae <dd_to_string+0x33e>
mov    -0x80(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1466 <dd_to_string+0x2f6>
jmp    14b3 <dd_to_string+0x343>
jmp    1588 <dd_to_string+0x418>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x30,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x2e,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x40(%rbp)
jge    153d <dd_to_string+0x3cd>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
xor    %ecx,%ecx
sub    -0x40(%rbp),%ecx
cmp    %ecx,%eax
jge    1538 <dd_to_string+0x3c8>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x30,(%rax)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14ff <dd_to_string+0x38f>
jmp    153d <dd_to_string+0x3cd>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1583 <dd_to_string+0x413>
mov    -0x80(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1544 <dd_to_string+0x3d4>
jmp    1588 <dd_to_string+0x418>
jmp    161d <dd_to_string+0x4ad>
mov    -0x80(%rbp),%rax
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x14(%rbp)
jle    15d2 <dd_to_string+0x462>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x2e,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1618 <dd_to_string+0x4a8>
mov    -0x80(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    15d9 <dd_to_string+0x469>
jmp    161d <dd_to_string+0x4ad>
mov    -0x68(%rbp),%rax
mov    %rax,%rsp
jmp    1629 <dd_to_string+0x4b9>
cmpl   $0x0,-0x1c(%rbp)
jne    1747 <dd_to_string+0x5d7>
mov    0x10(%rbp),%edx
mov    $0x65,%eax
mov    $0x45,%ecx
cmp    $0x1,%edx
cmove  %ecx,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x2c(%rbp),%edx
mov    $0x2b,%eax
mov    $0x2d,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jge    16a3 <dd_to_string+0x533>
xor    %eax,%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x64,-0x2c(%rbp)
jl     16e9 <dd_to_string+0x579>
mov    -0x2c(%rbp),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
imul   $0x64,-0x28(%rbp),%ecx
mov    -0x2c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
imul   $0xa,-0x28(%rbp),%ecx
mov    -0x2c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jl     1776 <dd_to_string+0x606>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x0,(%rax)
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
mov    0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    17ff <dd_to_string+0x68f>
mov    -0x18(%rbp),%eax
sub    -0x3c(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    17bb <dd_to_string+0x64b>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1786 <dd_to_string+0x616>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    17ea <dd_to_string+0x67a>
mov    0x18(%rbp),%dl
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    17c2 <dd_to_string+0x652>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%ecx
mov    0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dd_to_string>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9d,%r14d
mov    %r8d,-0x3c(%rbp)
mov    %ecx,%r15d
mov    %rdx,-0x50(%rbp)
mov    %rsi,%r13
mov    %rdi,%r12
movl   $0x0,-0x2c(%rbp)
call   1030 <dd_is_negative@plt>
mov    $0x2d,%cl
cmp    $0x1,%eax
je     11d5 <dd_to_string+0x45>
xor    %eax,%eax
mov    $0x2b,%cl
mov    %r13,%rbx
cmp    $0x1,%r14d
jne    11e2 <dd_to_string+0x52>
lea    0x1(%r13),%rbx
mov    %cl,0x0(%r13)
mov    $0x1,%eax
mov    %rax,-0x38(%rbp)
mov    %r12,%rdi
call   1050 <dd_is_zero@plt>
cmp    $0x1,%eax
jne    1240 <dd_to_string+0xb0>
movb   $0x30,(%rbx)
mov    %rbx,%r12
mov    -0x50(%rbp),%rbx
test   %ebx,%ebx
jle    13da <dd_to_string+0x24a>
lea    0x2(%r12),%rdi
movb   $0x2e,0x1(%r12)
mov    %ebx,%edx
mov    $0x30,%esi
call   1070 <memset@plt>
lea    -0x1(%rbx),%eax
add    %rax,%r12
add    $0x3,%r12
mov    -0x38(%rbp),%r10
add    %ebx,%r10d
add    $0x2,%r10d
cmpl   $0x0,-0x3c(%rbp)
jne    1528 <dd_to_string+0x398>
jmp    148c <dd_to_string+0x2fc>
mov    %rbx,-0x60(%rbp)
cmpl   $0x1,-0x3c(%rbp)
jne    12d0 <dd_to_string+0x140>
lea    -0x70(%rbp),%r14
mov    %r12,%rdi
mov    %r14,%rsi
call   1090 <dd_abs@plt>
mov    %r14,%rdi
mov    %r14,%rsi
call   10a0 <dd_log10@plt>
mov    %r14,%rdi
mov    %r14,%rsi
call   1060 <dd_floor@plt>
mov    %r14,%rdi
call   1040 <dd_to_int@plt>
mov    %eax,%r14d
add    $0x1,%r14d
mov    %r14d,%ebx
add    -0x50(%rbp),%ebx
jg     12dd <dd_to_string+0x14d>
mov    -0x60(%rbp),%r12
movb   $0x30,(%r12)
mov    -0x50(%rbp),%rbx
test   %ebx,%ebx
jle    1681 <dd_to_string+0x4f1>
lea    0x2(%r12),%rdi
movb   $0x2e,0x1(%r12)
mov    %ebx,%edx
mov    $0x30,%esi
call   1070 <memset@plt>
lea    -0x1(%rbx),%eax
add    %rax,%r12
add    $0x3,%r12
mov    -0x38(%rbp),%r10
add    %ebx,%r10d
add    $0x2,%r10d
jmp    1528 <dd_to_string+0x398>
mov    -0x50(%rbp),%rax
lea    0x1(%rax),%ebx
mov    $0x1,%r14d
mov    %r15d,-0x30(%rbp)
mov    %rsp,-0x48(%rbp)
lea    0x1(%rbx),%eax
mov    %rsp,%r15
add    $0xf,%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r15
mov    %r15,%rsp
lea    -0x2c(%rbp),%rdx
mov    %r12,%rdi
mov    %r15,%rsi
mov    %ebx,%ecx
call   10b0 <dd_to_digits@plt>
cmpl   $0x1,-0x3c(%rbp)
jne    138d <dd_to_string+0x1fd>
mov    %rbx,-0x58(%rbp)
test   %r14d,%r14d
jle    13f5 <dd_to_string+0x265>
mov    %r14d,%edx
mov    -0x60(%rbp),%rbx
mov    %rbx,%rdi
mov    %r15,%rsi
mov    %rdx,-0x58(%rbp)
call   1080 <memcpy@plt>
lea    -0x1(%r14),%r12d
mov    -0x38(%rbp),%r10
add    %r14d,%r10d
mov    -0x50(%rbp),%rax
test   %eax,%eax
jle    1470 <dd_to_string+0x2e0>
movb   $0x2e,0x1(%rbx,%r12,1)
lea    (%rbx,%r12,1),%rdi
add    $0x2,%rdi
add    -0x58(%rbp),%r15
mov    %eax,%edx
mov    %r15,%rsi
mov    %rbx,%r15
mov    %rax,%rbx
mov    %r10,%r14
call   1080 <memcpy@plt>
mov    %r14,%r10
lea    -0x1(%rbx),%eax
add    %r12,%rax
lea    (%r15,%rax,1),%r12
add    $0x3,%r12
lea    (%r14,%rbx,1),%r10d
add    $0x1,%r10d
jmp    1477 <dd_to_string+0x2e7>
mov    (%r15),%al
mov    -0x60(%rbp),%r12
mov    %al,(%r12)
mov    -0x50(%rbp),%r14
test   %r14d,%r14d
jle    1462 <dd_to_string+0x2d2>
lea    0x2(%r12),%rdi
movb   $0x2e,0x1(%r12)
add    $0x1,%r15
mov    %r14d,%edx
mov    %r15,%rsi
call   1080 <memcpy@plt>
lea    -0x1(%r14),%eax
add    %rax,%r12
add    $0x3,%r12
mov    -0x38(%rbp),%r10
add    %r14d,%r10d
add    $0x2,%r10d
jmp    1477 <dd_to_string+0x2e7>
add    $0x1,%r12
mov    -0x38(%rbp),%r10
add    $0x1,%r10d
cmpl   $0x0,-0x3c(%rbp)
jne    1528 <dd_to_string+0x398>
jmp    148c <dd_to_string+0x2fc>
mov    -0x60(%rbp),%rbx
movw   $0x2e30,(%rbx)
lea    0x2(%rbx),%r12
mov    -0x38(%rbp),%r10
or     $0x2,%r10d
test   %r14d,%r14d
jns    1435 <dd_to_string+0x2a5>
mov    %r14d,%edx
neg    %edx
mov    %r12,%rdi
mov    $0x30,%esi
mov    %r10,%r12
call   1070 <memset@plt>
mov    %r12,%r10
sub    %r14d,%r10d
not    %r14d
lea    (%r14,%rbx,1),%r12
add    $0x3,%r12
mov    -0x58(%rbp),%rax
test   %eax,%eax
jle    1477 <dd_to_string+0x2e7>
mov    %eax,%edx
mov    %r12,%rdi
mov    %r15,%rsi
mov    %r10,%r14
mov    %rax,%rbx
call   1080 <memcpy@plt>
mov    %r14,%r10
lea    -0x1(%rbx),%eax
add    %rax,%r12
add    $0x1,%r12
add    %ebx,%r10d
jmp    1477 <dd_to_string+0x2e7>
add    $0x1,%r12
mov    -0x38(%rbp),%r10
add    $0x1,%r10d
jmp    1477 <dd_to_string+0x2e7>
add    %rbx,%r12
add    $0x1,%r12
mov    -0x30(%rbp),%r15d
mov    -0x48(%rbp),%rax
mov    %rax,%rsp
cmpl   $0x0,-0x3c(%rbp)
jne    1528 <dd_to_string+0x398>
cmpl   $0x1,0x10(%rbp)
setne  %al
shl    $0x5,%al
or     $0x45,%al
mov    %al,(%r12)
mov    -0x2c(%rbp),%eax
shr    $0x1f,%eax
add    %al,%al
add    $0x2b,%al
mov    %al,0x1(%r12)
mov    -0x2c(%rbp),%eax
test   %eax,%eax
js     14df <dd_to_string+0x34f>
cmp    $0x64,%eax
jb     14e9 <dd_to_string+0x359>
mov    %eax,%eax
imul   $0x51eb851f,%rax,%rcx
shr    $0x25,%rcx
imul   $0xffffff9c,%ecx,%eax
add    $0x30,%cl
mov    %cl,0x2(%r12)
add    $0x3,%r12
add    $0x3,%r10d
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    14f1 <dd_to_string+0x361>
neg    %eax
mov    %eax,-0x2c(%rbp)
cmp    $0x64,%eax
jae    14b7 <dd_to_string+0x327>
add    $0x2,%r12
add    $0x2,%r10d
cltq
imul   $0x66666667,%rax,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x22,%rax
add    %ecx,%eax
lea    0x30(%rax),%ecx
mov    %cl,(%r12)
add    %eax,%eax
lea    (%rax,%rax,4),%eax
mov    -0x2c(%rbp),%ecx
sub    %eax,%ecx
add    $0x30,%cl
mov    %cl,0x1(%r12)
add    $0x2,%r12
add    $0x2,%r10d
mov    0x20(%rbp),%r14
cmp    %r15d,%r10d
jge    161a <dd_to_string+0x48a>
mov    %r15d,%r9d
sub    %r10d,%r9d
test   %r10d,%r10d
jle    15f1 <dd_to_string+0x461>
mov    %r10d,%r11d
cmp    $0x8,%r10d
jae    1638 <dd_to_string+0x4a8>
xor    %edx,%edx
mov    %rdx,%r8
not    %r8
add    %r11,%r8
mov    %r11,%rax
and    $0x3,%rax
je     158b <dd_to_string+0x3fb>
mov    %r9d,%edi
nopl   0x0(%rax,%rax,1)
movzbl 0x0(%r13,%rdx,1),%ebx
lea    (%rdi,%rdx,1),%esi
movslq %esi,%rsi
mov    %bl,0x0(%r13,%rsi,1)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rax
jne    1570 <dd_to_string+0x3e0>
cmp    $0x3,%r8
jb     15f1 <dd_to_string+0x461>
lea    0x3(%r13),%rsi
mov    %r9d,%edi
nopl   0x0(%rax,%rax,1)
movzbl -0x3(%rsi,%rdx,1),%eax
lea    (%rdx,%rdi,1),%rbx
movslq %ebx,%rbx
mov    %al,0x0(%r13,%rbx,1)
movzbl -0x2(%rsi,%rdx,1),%eax
lea    0x1(%rbx),%ecx
movslq %ecx,%rcx
mov    %al,0x0(%r13,%rcx,1)
movzbl -0x1(%rsi,%rdx,1),%eax
lea    0x2(%rbx),%ecx
movslq %ecx,%rcx
mov    %al,0x0(%r13,%rcx,1)
movzbl (%rsi,%rdx,1),%eax
add    $0x3,%ebx
movslq %ebx,%rcx
mov    %al,0x0(%r13,%rcx,1)
add    $0xfffffffffffffffc,%r11
add    $0x4,%rsi
add    $0x4,%rdi
cmp    %r11,%rdx
jne    15a0 <dd_to_string+0x410>
test   %r9d,%r9d
jle    160f <dd_to_string+0x47f>
not    %r10d
add    %r15d,%r10d
add    $0x1,%r10
movzbl 0x18(%rbp),%esi
mov    %r13,%rdi
mov    %r10,%rdx
call   1070 <memset@plt>
movslq %r15d,%rax
movb   $0x0,0x0(%r13,%rax,1)
jmp    1626 <dd_to_string+0x496>
movb   $0x0,(%r12)
add    $0x1,%r10d
mov    %r10d,%r15d
mov    %r15d,(%r14)
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x1(%r11),%rax
lea    (%r9,%rax,1),%esi
xor    %edx,%edx
cmp    %r9d,%esi
jl     1553 <dd_to_string+0x3c3>
shr    $0x20,%rax
jne    1553 <dd_to_string+0x3c3>
movslq %r9d,%rax
lea    (%rax,%r13,1),%rdx
lea    (%r11,%r13,1),%rsi
cmp    %rsi,%rdx
jae    1674 <dd_to_string+0x4e4>
add    %r11,%rax
add    %r13,%rax
cmp    %r13,%rax
ja     1551 <dd_to_string+0x3c1>
cmp    $0x20,%r10d
jae    1692 <dd_to_string+0x502>
xor    %edx,%edx
jmp    1743 <dd_to_string+0x5b3>
add    $0x1,%r12
mov    -0x38(%rbp),%r10
add    $0x1,%r10d
jmp    1528 <dd_to_string+0x398>
mov    %r10,%rcx
mov    %r11d,%edx
and    $0xffffffe0,%edx
lea    -0x20(%rdx),%rax
mov    %rax,%r8
shr    $0x5,%r8
add    $0x1,%r8
test   %rax,%rax
je     1707 <dd_to_string+0x577>
mov    %r8,%r10
and    $0xfffffffffffffffe,%r10
xor    %edi,%edi
mov    %r9d,%eax
nopl   0x0(%rax,%rax,1)
movups 0x0(%r13,%rdi,1),%xmm0
movups 0x10(%r13,%rdi,1),%xmm1
cltq
movups %xmm0,0x0(%r13,%rax,1)
movups %xmm1,0x10(%r13,%rax,1)
movups 0x20(%r13,%rdi,1),%xmm0
movups 0x30(%r13,%rdi,1),%xmm1
lea    0x20(%rax),%esi
movslq %esi,%rsi
movups %xmm0,0x0(%r13,%rsi,1)
movups %xmm1,0x10(%r13,%rsi,1)
add    $0x40,%rdi
add    $0x40,%eax
add    $0xfffffffffffffffe,%r10
jne    16c0 <dd_to_string+0x530>
jmp    1709 <dd_to_string+0x579>
xor    %edi,%edi
test   $0x1,%r8b
mov    %rcx,%r10
je     1730 <dd_to_string+0x5a0>
movups 0x0(%r13,%rdi,1),%xmm0
movups 0x10(%r13,%rdi,1),%xmm1
lea    (%r9,%rdi,1),%eax
cltq
movups %xmm0,0x0(%r13,%rax,1)
movups %xmm1,0x10(%r13,%rax,1)
cmp    %r11,%rdx
je     15f1 <dd_to_string+0x461>
test   $0x18,%r11b
je     1553 <dd_to_string+0x3c3>
mov    %rdx,%rax
mov    %r11d,%edx
and    $0xfffffff8,%edx
mov    %r9d,%r8d
nop
mov    0x0(%r13,%rax,1),%rdi
lea    (%r8,%rax,1),%esi
movslq %esi,%rsi
mov    %rdi,0x0(%r13,%rsi,1)
add    $0x8,%rax
cmp    %rax,%rdx
jne    1750 <dd_to_string+0x5c0>
cmp    %r11,%rdx
jne    1553 <dd_to_string+0x3c3>
jmp    15f1 <dd_to_string+0x461>

LLVM IR (-O0):
define void @dd_to_string(double* %0, i8* %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6, i8 signext %7, i32* %8) {
%10 = alloca double*
%11 = alloca i8*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i8
%18 = alloca i32*
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i8*
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca [2 x double]
%27 = alloca i8*
%28 = alloca i64
%29 = alloca i32
store double* %0, double** %10
store i8* %1, i8** %11
store i32 %2, i32* %12
store i32 %3, i32* %13
store i32 %4, i32* %14
store i32 %5, i32* %15
store i32 %6, i32* %16
store i8 %7, i8* %17
store i32* %8, i32** %18
store i32 1, i32* %19
store i32 0, i32* %21
%30 = load i8*, i8** %11
store i8* %30, i8** %22
store i32 0, i32* %23
%31 = load double*, double** %10
%32 = call i32 @dd_is_negative(double* %31)
%33 = icmp eq i32 %32, 1
br i1 %33, label %34, label %39
34: ; preds = %9
%35 = load i8*, i8** %22
%36 = getelementptr inbounds i8, i8* %35, i32 1
store i8* %36, i8** %22
store i8 45, i8* %35
%37 = load i32, i32* %23
%38 = add nsw i32 %37, 1
store i32 %38, i32* %23
br label %49
39: ; preds = %9
%40 = load i32, i32* %15
%41 = icmp eq i32 %40, 1
br i1 %41, label %42, label %47
42: ; preds = %39
%43 = load i8*, i8** %22
%44 = getelementptr inbounds i8, i8* %43, i32 1
store i8* %44, i8** %22
store i8 43, i8* %43
%45 = load i32, i32* %23
%46 = add nsw i32 %45, 1
store i32 %46, i32* %23
br label %48
47: ; preds = %39
store i32 0, i32* %19
br label %48
48: ; preds = %47, %42
br label %49
49: ; preds = %48, %34
%50 = load double*, double** %10
%51 = call i32 @dd_is_zero(double* %50)
%52 = icmp eq i32 %51, 1
br i1 %52, label %53, label %79
53: ; preds = %49
%54 = load i8*, i8** %22
%55 = getelementptr inbounds i8, i8* %54, i32 1
store i8* %55, i8** %22
store i8 48, i8* %54
%56 = load i32, i32* %23
%57 = add nsw i32 %56, 1
store i32 %57, i32* %23
%58 = load i32, i32* %12
%59 = icmp sgt i32 %58, 0
br i1 %59, label %60, label %78
60: ; preds = %53
%61 = load i8*, i8** %22
%62 = getelementptr inbounds i8, i8* %61, i32 1
store i8* %62, i8** %22
store i8 46, i8* %61
%63 = load i32, i32* %23
%64 = add nsw i32 %63, 1
store i32 %64, i32* %23
store i32 0, i32* %20
br label %65
65: ; preds = %72, %60
%66 = load i32, i32* %20
%67 = load i32, i32* %12
%68 = icmp slt i32 %66, %67
br i1 %68, label %69, label %77
69: ; preds = %65
%70 = load i8*, i8** %22
%71 = getelementptr inbounds i8, i8* %70, i32 1
store i8* %71, i8** %22
store i8 48, i8* %70
br label %72
72: ; preds = %69
%73 = load i32, i32* %20
%74 = add nsw i32 %73, 1
store i32 %74, i32* %20
%75 = load i32, i32* %23
%76 = add nsw i32 %75, 1
store i32 %76, i32* %23
br label %65
77: ; preds = %65
br label %78
78: ; preds = %77, %53
br label %270
79: ; preds = %49
%80 = load i32, i32* %14
%81 = icmp ne i32 %80, 1
br i1 %81, label %82, label %83
82: ; preds = %79
store i32 1, i32* %24
br label %96
83: ; preds = %79
%84 = load double*, double** %10
%85 = getelementptr inbounds [2 x double], [2 x double]* %26, i64 0, i64 0
%86 = call i32 @dd_abs(double* %84, double* %85)
%87 = getelementptr inbounds [2 x double], [2 x double]* %26, i64 0, i64 0
%88 = getelementptr inbounds [2 x double], [2 x double]* %26, i64 0, i64 0
%89 = call i32 @dd_log10(double* %87, double* %88)
%90 = getelementptr inbounds [2 x double], [2 x double]* %26, i64 0, i64 0
%91 = getelementptr inbounds [2 x double], [2 x double]* %26, i64 0, i64 0
%92 = call i32 @dd_floor(double* %90, double* %91)
%93 = getelementptr inbounds [2 x double], [2 x double]* %26, i64 0, i64 0
%94 = call i32 @dd_to_int(double* %93)
%95 = add nsw i32 %94, 1
store i32 %95, i32* %24
br label %96
96: ; preds = %83, %82
%97 = load i32, i32* %12
%98 = load i32, i32* %24
%99 = add nsw i32 %97, %98
store i32 %99, i32* %25
%100 = load i32, i32* %14
%101 = icmp eq i32 %100, 1
br i1 %101, label %102, label %131
102: ; preds = %96
%103 = load i32, i32* %25
%104 = icmp sle i32 %103, 0
br i1 %104, label %105, label %131
105: ; preds = %102
%106 = load i8*, i8** %22
%107 = getelementptr inbounds i8, i8* %106, i32 1
store i8* %107, i8** %22
store i8 48, i8* %106
%108 = load i32, i32* %23
%109 = add nsw i32 %108, 1
store i32 %109, i32* %23
%110 = load i32, i32* %12
%111 = icmp sgt i32 %110, 0
br i1 %111, label %112, label %130
112: ; preds = %105
%113 = load i8*, i8** %22
%114 = getelementptr inbounds i8, i8* %113, i32 1
store i8* %114, i8** %22
store i8 46, i8* %113
%115 = load i32, i32* %23
%116 = add nsw i32 %115, 1
store i32 %116, i32* %23
store i32 0, i32* %20
br label %117
117: ; preds = %124, %112
%118 = load i32, i32* %20
%119 = load i32, i32* %12
%120 = icmp slt i32 %118, %119
br i1 %120, label %121, label %129
121: ; preds = %117
%122 = load i8*, i8** %22
%123 = getelementptr inbounds i8, i8* %122, i32 1
store i8* %123, i8** %22
store i8 48, i8* %122
br label %124
124: ; preds = %121
%125 = load i32, i32* %20
%126 = add nsw i32 %125, 1
store i32 %126, i32* %20
%127 = load i32, i32* %23
%128 = add nsw i32 %127, 1
store i32 %128, i32* %23
br label %117
129: ; preds = %117
br label %130
130: ; preds = %129, %105
br label %269
131: ; preds = %102, %96
%132 = load i32, i32* %25
%133 = add nsw i32 %132, 1
%134 = zext i32 %133 to i64
%135 = call i8* @llvm.stacksave()
store i8* %135, i8** %27
%136 = alloca i8, i64 %134
store i64 %134, i64* %28
%137 = load double*, double** %10
%138 = load i32, i32* %25
%139 = call i32 @dd_to_digits(double* %137, i8* %136, i32* %21, i32 %138)
%140 = load i32, i32* %14
%141 = icmp eq i32 %140, 1
br i1 %141, label %142, label %235
142: ; preds = %131
%143 = load i32, i32* %24
%144 = icmp sgt i32 %143, 0
br i1 %144, label %145, label %190
145: ; preds = %142
store i32 0, i32* %20
br label %146
146: ; preds = %157, %145
%147 = load i32, i32* %20
%148 = load i32, i32* %24
%149 = icmp slt i32 %147, %148
br i1 %149, label %150, label %162
150: ; preds = %146
%151 = load i32, i32* %20
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds i8, i8* %136, i64 %152
%154 = load i8, i8* %153
%155 = load i8*, i8** %22
%156 = getelementptr inbounds i8, i8* %155, i32 1
store i8* %156, i8** %22
store i8 %154, i8* %155
br label %157
157: ; preds = %150
%158 = load i32, i32* %20
%159 = add nsw i32 %158, 1
store i32 %159, i32* %20
%160 = load i32, i32* %23
%161 = add nsw i32 %160, 1
store i32 %161, i32* %23
br label %146
162: ; preds = %146
%163 = load i32, i32* %12
%164 = icmp sgt i32 %163, 0
br i1 %164, label %165, label %189
165: ; preds = %162
%166 = load i8*, i8** %22
%167 = getelementptr inbounds i8, i8* %166, i32 1
store i8* %167, i8** %22
store i8 46, i8* %166
%168 = load i32, i32* %23
%169 = add nsw i32 %168, 1
store i32 %169, i32* %23
store i32 0, i32* %29
br label %170
170: ; preds = %181, %165
%171 = load i32, i32* %29
%172 = load i32, i32* %12
%173 = icmp slt i32 %171, %172
br i1 %173, label %174, label %188
174: ; preds = %170
%175 = load i32, i32* %20
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds i8, i8* %136, i64 %176
%178 = load i8, i8* %177
%179 = load i8*, i8** %22
%180 = getelementptr inbounds i8, i8* %179, i32 1
store i8* %180, i8** %22
store i8 %178, i8* %179
br label %181
181: ; preds = %174
%182 = load i32, i32* %29
%183 = add nsw i32 %182, 1
store i32 %183, i32* %29
%184 = load i32, i32* %20
%185 = add nsw i32 %184, 1
store i32 %185, i32* %20
%186 = load i32, i32* %23
%187 = add nsw i32 %186, 1
store i32 %187, i32* %23
br label %170
188: ; preds = %170
br label %189
189: ; preds = %188, %162
br label %234
190: ; preds = %142
%191 = load i8*, i8** %22
%192 = getelementptr inbounds i8, i8* %191, i32 1
store i8* %192, i8** %22
store i8 48, i8* %191
%193 = load i32, i32* %23
%194 = add nsw i32 %193, 1
store i32 %194, i32* %23
%195 = load i8*, i8** %22
%196 = getelementptr inbounds i8, i8* %195, i32 1
store i8* %196, i8** %22
store i8 46, i8* %195
%197 = load i32, i32* %23
%198 = add nsw i32 %197, 1
store i32 %198, i32* %23
%199 = load i32, i32* %24
%200 = icmp slt i32 %199, 0
br i1 %200, label %201, label %216
201: ; preds = %190
store i32 0, i32* %20
br label %202
202: ; preds = %210, %201
%203 = load i32, i32* %20
%204 = load i32, i32* %24
%205 = sub nsw i32 0, %204
%206 = icmp slt i32 %203, %205
br i1 %206, label %207, label %215
207: ; preds = %202
%208 = load i8*, i8** %22
%209 = getelementptr inbounds i8, i8* %208, i32 1
store i8* %209, i8** %22
store i8 48, i8* %208
br label %210
210: ; preds = %207
%211 = load i32, i32* %20
%212 = add nsw i32 %211, 1
store i32 %212, i32* %20
%213 = load i32, i32* %23
%214 = add nsw i32 %213, 1
store i32 %214, i32* %23
br label %202
215: ; preds = %202
br label %216
216: ; preds = %215, %190
store i32 0, i32* %20
br label %217
217: ; preds = %228, %216
%218 = load i32, i32* %20
%219 = load i32, i32* %25
%220 = icmp slt i32 %218, %219
br i1 %220, label %221, label %233
221: ; preds = %217
%222 = load i32, i32* %20
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds i8, i8* %136, i64 %223
%225 = load i8, i8* %224
%226 = load i8*, i8** %22
%227 = getelementptr inbounds i8, i8* %226, i32 1
store i8* %227, i8** %22
store i8 %225, i8* %226
br label %228
228: ; preds = %221
%229 = load i32, i32* %20
%230 = add nsw i32 %229, 1
store i32 %230, i32* %20
%231 = load i32, i32* %23
%232 = add nsw i32 %231, 1
store i32 %232, i32* %23
br label %217
233: ; preds = %217
br label %234
234: ; preds = %233, %189
br label %267
235: ; preds = %131
%236 = getelementptr inbounds i8, i8* %136, i64 0
%237 = load i8, i8* %236
%238 = load i8*, i8** %22
%239 = getelementptr inbounds i8, i8* %238, i32 1
store i8* %239, i8** %22
store i8 %237, i8* %238
%240 = load i32, i32* %23
%241 = add nsw i32 %240, 1
store i32 %241, i32* %23
%242 = load i32, i32* %12
%243 = icmp sgt i32 %242, 0
br i1 %243, label %244, label %249
244: ; preds = %235
%245 = load i8*, i8** %22
%246 = getelementptr inbounds i8, i8* %245, i32 1
store i8* %246, i8** %22
store i8 46, i8* %245
%247 = load i32, i32* %23
%248 = add nsw i32 %247, 1
store i32 %248, i32* %23
br label %249
249: ; preds = %244, %235
store i32 1, i32* %20
br label %250
250: ; preds = %261, %249
%251 = load i32, i32* %20
%252 = load i32, i32* %12
%253 = icmp sle i32 %251, %252
br i1 %253, label %254, label %266
254: ; preds = %250
%255 = load i32, i32* %20
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds i8, i8* %136, i64 %256
%258 = load i8, i8* %257
%259 = load i8*, i8** %22
%260 = getelementptr inbounds i8, i8* %259, i32 1
store i8* %260, i8** %22
store i8 %258, i8* %259
br label %261
261: ; preds = %254
%262 = load i32, i32* %20
%263 = add nsw i32 %262, 1
store i32 %263, i32* %20
%264 = load i32, i32* %23
%265 = add nsw i32 %264, 1
store i32 %265, i32* %23
br label %250
266: ; preds = %250
br label %267
267: ; preds = %266, %234
%268 = load i8*, i8** %27
br label %269
269: ; preds = %267, %130
br label %270
270: ; preds = %269, %78
%271 = load i32, i32* %14
%272 = icmp eq i32 %271, 0
br i1 %272, label %273, label %335
273: ; preds = %270
%274 = load i32, i32* %16
%275 = icmp eq i32 %274, 1
%276 = zext i1 %275 to i64
%277 = select i1 %275, i32 69, i32 101
%278 = trunc i32 %277 to i8
%279 = load i8*, i8** %22
%280 = getelementptr inbounds i8, i8* %279, i32 1
store i8* %280, i8** %22
store i8 %278, i8* %279
%281 = load i32, i32* %23
%282 = add nsw i32 %281, 1
store i32 %282, i32* %23
%283 = load i32, i32* %21
%284 = icmp slt i32 %283, 0
%285 = zext i1 %284 to i64
%286 = select i1 %284, i32 45, i32 43
%287 = trunc i32 %286 to i8
%288 = load i8*, i8** %22
%289 = getelementptr inbounds i8, i8* %288, i32 1
store i8* %289, i8** %22
store i8 %287, i8* %288
%290 = load i32, i32* %23
%291 = add nsw i32 %290, 1
store i32 %291, i32* %23
%292 = load i32, i32* %21
%293 = icmp slt i32 %292, 0
br i1 %293, label %294, label %297
294: ; preds = %273
%295 = load i32, i32* %21
%296 = sub nsw i32 0, %295
store i32 %296, i32* %21
br label %297
297: ; preds = %294, %273
%298 = load i32, i32* %21
%299 = icmp sge i32 %298, 100
br i1 %299, label %300, label %314
300: ; preds = %297
%301 = load i32, i32* %21
%302 = sdiv i32 %301, 100
store i32 %302, i32* %20
%303 = load i32, i32* %20
%304 = add nsw i32 48, %303
%305 = trunc i32 %304 to i8
%306 = load i8*, i8** %22
%307 = getelementptr inbounds i8, i8* %306, i32 1
store i8* %307, i8** %22
store i8 %305, i8* %306
%308 = load i32, i32* %23
%309 = add nsw i32 %308, 1
store i32 %309, i32* %23
%310 = load i32, i32* %20
%311 = mul nsw i32 100, %310
%312 = load i32, i32* %21
%313 = sub nsw i32 %312, %311
store i32 %313, i32* %21
br label %314
314: ; preds = %300, %297
%315 = load i32, i32* %21
%316 = sdiv i32 %315, 10
store i32 %316, i32* %20
%317 = load i32, i32* %20
%318 = add nsw i32 48, %317
%319 = trunc i32 %318 to i8
%320 = load i8*, i8** %22
%321 = getelementptr inbounds i8, i8* %320, i32 1
store i8* %321, i8** %22
store i8 %319, i8* %320
%322 = load i32, i32* %23
%323 = add nsw i32 %322, 1
store i32 %323, i32* %23
%324 = load i32, i32* %20
%325 = mul nsw i32 10, %324
%326 = load i32, i32* %21
%327 = sub nsw i32 %326, %325
store i32 %327, i32* %21
%328 = load i32, i32* %21
%329 = add nsw i32 48, %328
%330 = trunc i32 %329 to i8
%331 = load i8*, i8** %22
%332 = getelementptr inbounds i8, i8* %331, i32 1
store i8* %332, i8** %22
store i8 %330, i8* %331
%333 = load i32, i32* %23
%334 = add nsw i32 %333, 1
store i32 %334, i32* %23
br label %335
335: ; preds = %314, %270
%336 = load i32, i32* %23
%337 = load i32, i32* %13
%338 = icmp sge i32 %336, %337
br i1 %338, label %339, label %345
339: ; preds = %335
%340 = load i8*, i8** %22
%341 = getelementptr inbounds i8, i8* %340, i32 1
store i8* %341, i8** %22
store i8 0, i8* %340
%342 = load i32, i32* %23
%343 = add nsw i32 %342, 1
%344 = load i32*, i32** %18
store i32 %343, i32* %344
br label %389
345: ; preds = %335
%346 = load i32, i32* %13
%347 = load i32, i32* %23
%348 = sub nsw i32 %346, %347
store i32 %348, i32* %25
store i32 0, i32* %20
br label %349
349: ; preds = %365, %345
%350 = load i32, i32* %20
%351 = load i32, i32* %23
%352 = icmp slt i32 %350, %351
br i1 %352, label %353, label %368
353: ; preds = %349
%354 = load i8*, i8** %11
%355 = load i32, i32* %20
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds i8, i8* %354, i64 %356
%358 = load i8, i8* %357
%359 = load i8*, i8** %11
%360 = load i32, i32* %20
%361 = load i32, i32* %25
%362 = add nsw i32 %360, %361
%363 = sext i32 %362 to i64
%364 = getelementptr inbounds i8, i8* %359, i64 %363
store i8 %358, i8* %364
br label %365
365: ; preds = %353
%366 = load i32, i32* %20
%367 = add nsw i32 %366, 1
store i32 %367, i32* %20
br label %349
368: ; preds = %349
store i32 0, i32* %20
br label %369
369: ; preds = %379, %368
%370 = load i32, i32* %20
%371 = load i32, i32* %25
%372 = icmp slt i32 %370, %371
br i1 %372, label %373, label %382
373: ; preds = %369
%374 = load i8, i8* %17
%375 = load i8*, i8** %11
%376 = load i32, i32* %20
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds i8, i8* %375, i64 %377
store i8 %374, i8* %378
br label %379
379: ; preds = %373
%380 = load i32, i32* %20
%381 = add nsw i32 %380, 1
store i32 %381, i32* %20
br label %369
382: ; preds = %369
%383 = load i8*, i8** %11
%384 = load i32, i32* %13
%385 = sext i32 %384 to i64
%386 = getelementptr inbounds i8, i8* %383, i64 %385
store i8 0, i8* %386
%387 = load i32, i32* %13
%388 = load i32*, i32** %18
store i32 %387, i32* %388
br label %389
389: ; preds = %382, %339
ret void
}

LLVM IR (-O2):
define void @dd_to_string(double* %0, i8* nocapture %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6, i8 signext %7, i32* nocapture writeonly %8) {
%10 = alloca i32
%11 = alloca [2 x double]
%12 = bitcast i32* %10 to i8*
store i32 0, i32* %10
%13 = bitcast [2 x double]* %11 to i8*
%14 = tail call i32 @dd_is_negative(double* %0)
%15 = icmp eq i32 %14, 1
br i1 %15, label %18, label %16
16: ; preds = %9
%17 = icmp eq i32 %5, 1
br i1 %17, label %18, label %21
18: ; preds = %16, %9
%19 = phi i8 [ 45, %9 ], [ 43, %16 ]
%20 = getelementptr inbounds i8, i8* %1, i64 1
store i8 %19, i8* %1
br label %21
21: ; preds = %18, %16
%22 = phi i8* [ %1, %16 ], [ %20, %18 ]
%23 = phi i32 [ 0, %16 ], [ 1, %18 ]
%24 = tail call i32 @dd_is_zero(double* %0)
%25 = icmp eq i32 %24, 1
br i1 %25, label %26, label %39
26: ; preds = %21
%27 = getelementptr inbounds i8, i8* %22, i64 1
store i8 48, i8* %22
%28 = add nuw nsw i32 %23, 1
%29 = icmp sgt i32 %2, 0
br i1 %29, label %30, label %137
30: ; preds = %26
%31 = getelementptr i8, i8* %22, i64 2
store i8 46, i8* %27
%32 = or i32 %23, 2
%33 = zext i32 %2 to i64
%34 = add nsw i32 %2, -1
%35 = zext i32 %34 to i64
%36 = add nuw nsw i64 %35, 3
%37 = getelementptr i8, i8* %22, i64 %36
%38 = add i32 %32, %2
br label %137
39: ; preds = %21
%40 = icmp eq i32 %4, 1
br i1 %40, label %43, label %41
41: ; preds = %39
%42 = add nsw i32 %2, 1
br label %65
43: ; preds = %39
%44 = getelementptr inbounds [2 x double], [2 x double]* %11, i64 0, i64 0
%45 = call i32 @dd_abs(double* %0, double* %44)
%46 = call i32 @dd_log10(double* %44, double* %44)
%47 = call i32 @dd_floor(double* %44, double* %44)
%48 = call i32 @dd_to_int(double* %44)
%49 = add nsw i32 %48, 1
%50 = add nsw i32 %49, %2
%51 = icmp slt i32 %50, 1
br i1 %51, label %52, label %65
52: ; preds = %43
%53 = getelementptr inbounds i8, i8* %22, i64 1
store i8 48, i8* %22
%54 = add nuw nsw i32 %23, 1
%55 = icmp sgt i32 %2, 0
br i1 %55, label %56, label %181
56: ; preds = %52
%57 = getelementptr i8, i8* %22, i64 2
store i8 46, i8* %53
%58 = or i32 %23, 2
%59 = zext i32 %2 to i64
%60 = add nsw i32 %2, -1
%61 = zext i32 %60 to i64
%62 = add nuw nsw i64 %61, 3
%63 = getelementptr i8, i8* %22, i64 %62
%64 = add i32 %58, %2
br label %181
65: ; preds = %41, %43
%66 = phi i32 [ %42, %41 ], [ %50, %43 ]
%67 = phi i32 [ 1, %41 ], [ %49, %43 ]
%68 = add nsw i32 %66, 1
%69 = zext i32 %68 to i64
%70 = call i8* @llvm.stacksave()
%71 = alloca i8, i64 %69
%72 = call i32 @dd_to_digits(double* %0, i8* %71, i32* %10, i32 %66)
br i1 %40, label %73, label %119
73: ; preds = %65
%74 = icmp sgt i32 %67, 0
br i1 %74, label %75, label %95
75: ; preds = %73
%76 = zext i32 %67 to i64
%77 = add nsw i32 %67, -1
%78 = zext i32 %77 to i64
%79 = add nuw nsw i64 %78, 1
%80 = getelementptr i8, i8* %22, i64 %79
%81 = add nuw i32 %23, %67
%82 = icmp sgt i32 %2, 0
br i1 %82, label %83, label %134
83: ; preds = %75
%84 = getelementptr i8, i8* %22, i64 %78
store i8 46, i8* %80
%85 = getelementptr i8, i8* %84, i64 2
%86 = getelementptr i8, i8* %71, i64 %76
%87 = zext i32 %2 to i64
%88 = add nsw i32 %2, -1
%89 = zext i32 %88 to i64
%90 = add nuw nsw i64 %89, %78
%91 = add nuw nsw i64 %90, 3
%92 = add nuw i32 %81, %2
%93 = getelementptr i8, i8* %22, i64 %91
%94 = add i32 %92, 1
br label %134
95: ; preds = %73
%96 = getelementptr inbounds i8, i8* %22, i64 1
store i8 48, i8* %22
%97 = getelementptr i8, i8* %22, i64 2
store i8 46, i8* %96
%98 = or i32 %23, 2
%99 = icmp slt i32 %67, 0
br i1 %99, label %100, label %108
100: ; preds = %95
%101 = sub nsw i32 0, %67
%102 = zext i32 %101 to i64
%103 = xor i32 %67, -1
%104 = zext i32 %103 to i64
%105 = add nuw nsw i64 %104, 3
%106 = getelementptr i8, i8* %22, i64 %105
%107 = sub i32 %98, %67
br label %108
108: ; preds = %100, %95
%109 = phi i8* [ %97, %95 ], [ %106, %100 ]
%110 = phi i32 [ %98, %95 ], [ %107, %100 ]
%111 = icmp sgt i32 %66, 0
br i1 %111, label %112, label %134
112: ; preds = %108
%113 = zext i32 %66 to i64
%114 = add nsw i32 %66, -1
%115 = zext i32 %114 to i64
%116 = add nuw nsw i64 %115, 1
%117 = getelementptr i8, i8* %109, i64 %116
%118 = add i32 %110, %66
br label %134
119: ; preds = %65
%120 = load i8, i8* %71
%121 = getelementptr inbounds i8, i8* %22, i64 1
store i8 %120, i8* %22
%122 = add nuw nsw i32 %23, 1
%123 = icmp sgt i32 %2, 0
br i1 %123, label %124, label %134
124: ; preds = %119
%125 = getelementptr inbounds i8, i8* %22, i64 2
store i8 46, i8* %121
%126 = or i32 %23, 2
%127 = getelementptr inbounds i8, i8* %71, i64 1
%128 = zext i32 %2 to i64
%129 = add nsw i32 %2, -1
%130 = zext i32 %129 to i64
%131 = add nuw nsw i64 %130, 1
%132 = getelementptr i8, i8* %125, i64 %131
%133 = add i32 %126, %2
br label %134
134: ; preds = %119, %124, %112, %83, %108, %75
%135 = phi i8* [ %80, %75 ], [ %109, %108 ], [ %93, %83 ], [ %117, %112 ], [ %132, %124 ], [ %121, %119 ]
%136 = phi i32 [ %81, %75 ], [ %110, %108 ], [ %94, %83 ], [ %118, %112 ], [ %133, %124 ], [ %122, %119 ]
br label %137
137: ; preds = %30, %134, %26
%138 = phi i8* [ %27, %26 ], [ %135, %134 ], [ %37, %30 ]
%139 = phi i32 [ %28, %26 ], [ %136, %134 ], [ %38, %30 ]
%140 = icmp eq i32 %4, 0
br i1 %140, label %141, label %181
141: ; preds = %137
%142 = icmp eq i32 %6, 1
%143 = select i1 %142, i8 69, i8 101
%144 = getelementptr inbounds i8, i8* %138, i64 1
store i8 %143, i8* %138
%145 = load i32, i32* %10
%146 = icmp slt i32 %145, 0
%147 = select i1 %146, i8 45, i8 43
%148 = getelementptr inbounds i8, i8* %138, i64 2
store i8 %147, i8* %144
%149 = add nsw i32 %139, 2
%150 = load i32, i32* %10
%151 = icmp slt i32 %150, 0
br i1 %151, label %152, label %154
152: ; preds = %141
%153 = sub nsw i32 0, %150
store i32 %153, i32* %10
br label %154
154: ; preds = %152, %141
%155 = phi i32 [ %153, %152 ], [ %150, %141 ]
%156 = icmp ugt i32 %155, 99
br i1 %156, label %157, label %166
157: ; preds = %154
%158 = udiv i32 %155, 100
%159 = trunc i32 %158 to i8
%160 = add i8 %159, 48
%161 = getelementptr inbounds i8, i8* %138, i64 3
store i8 %160, i8* %148
%162 = add nsw i32 %139, 3
%163 = mul nsw i32 %158, -100
%164 = load i32, i32* %10
%165 = add i32 %164, %163
store i32 %165, i32* %10
br label %166
166: ; preds = %157, %154
%167 = phi i32 [ %165, %157 ], [ %155, %154 ]
%168 = phi i8* [ %161, %157 ], [ %148, %154 ]
%169 = phi i32 [ %162, %157 ], [ %149, %154 ]
%170 = sdiv i32 %167, 10
%171 = trunc i32 %170 to i8
%172 = add i8 %171, 48
%173 = getelementptr inbounds i8, i8* %168, i64 1
store i8 %172, i8* %168
%174 = mul nsw i32 %170, -10
%175 = load i32, i32* %10
%176 = add i32 %174, %175
%177 = trunc i32 %176 to i8
%178 = add i8 %177, 48
%179 = getelementptr inbounds i8, i8* %168, i64 2
store i8 %178, i8* %173
%180 = add nsw i32 %169, 2
br label %181
181: ; preds = %56, %52, %166, %137
%182 = phi i8* [ %179, %166 ], [ %138, %137 ], [ %53, %52 ], [ %63, %56 ]
%183 = phi i32 [ %180, %166 ], [ %139, %137 ], [ %54, %52 ], [ %64, %56 ]
%184 = icmp slt i32 %183, %3
br i1 %184, label %187, label %185
185: ; preds = %181
store i8 0, i8* %182
%186 = add nsw i32 %183, 1
br label %354
187: ; preds = %181
%188 = sub i32 %3, %183
%189 = icmp sgt i32 %183, 0
br i1 %189, label %190, label %313
190: ; preds = %187
%191 = zext i32 %183 to i64
%192 = icmp ult i32 %183, 8
br i1 %192, label %292, label %193
193: ; preds = %190
%194 = add nsw i64 %191, -1
%195 = trunc i64 %194 to i32
%196 = add i32 %188, %195
%197 = icmp slt i32 %196, %188
%198 = icmp ugt i64 %194, 4294967295
%199 = or i1 %197, %198
br i1 %199, label %292, label %200
200: ; preds = %193
%201 = sext i32 %188 to i64
%202 = getelementptr i8, i8* %1, i64 %201
%203 = add nsw i64 %201, %191
%204 = getelementptr i8, i8* %1, i64 %203
%205 = getelementptr i8, i8* %1, i64 %191
%206 = icmp ult i8* %202, %205
%207 = icmp ugt i8* %204, %1
%208 = and i1 %206, %207
br i1 %208, label %292, label %209
209: ; preds = %200
%210 = icmp ult i32 %183, 32
br i1 %210, label %275, label %211
211: ; preds = %209
%212 = and i64 %191, 4294967264
%213 = add nsw i64 %212, -32
%214 = lshr exact i64 %213, 5
%215 = add nuw nsw i64 %214, 1
%216 = and i64 %215, 1
%217 = icmp eq i64 %213, 0
br i1 %217, label %253, label %218
218: ; preds = %211
%219 = and i64 %215, 1152921504606846974
br label %220
220: ; preds = %220, %218
%221 = phi i64 [ 0, %218 ], [ %250, %220 ]
%222 = phi i64 [ 0, %218 ], [ %251, %220 ]
%223 = trunc i64 %221 to i32
%224 = getelementptr inbounds i8, i8* %1, i64 %221
%225 = bitcast i8* %224 to <16 x i8>*
%226 = load <16 x i8>, <16 x i8>* %225
%227 = getelementptr inbounds i8, i8* %224, i64 16
%228 = bitcast i8* %227 to <16 x i8>*
%229 = load <16 x i8>, <16 x i8>* %228
%230 = add nsw i32 %188, %223
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds i8, i8* %1, i64 %231
%233 = bitcast i8* %232 to <16 x i8>*
store <16 x i8> %226, <16 x i8>* %233
%234 = getelementptr inbounds i8, i8* %232, i64 16
%235 = bitcast i8* %234 to <16 x i8>*
store <16 x i8> %229, <16 x i8>* %235
%236 = or i64 %221, 32
%237 = trunc i64 %236 to i32
%238 = getelementptr inbounds i8, i8* %1, i64 %236
%239 = bitcast i8* %238 to <16 x i8>*
%240 = load <16 x i8>, <16 x i8>* %239
%241 = getelementptr inbounds i8, i8* %238, i64 16
%242 = bitcast i8* %241 to <16 x i8>*
%243 = load <16 x i8>, <16 x i8>* %242
%244 = add nsw i32 %188, %237
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds i8, i8* %1, i64 %245
%247 = bitcast i8* %246 to <16 x i8>*
store <16 x i8> %240, <16 x i8>* %247
%248 = getelementptr inbounds i8, i8* %246, i64 16
%249 = bitcast i8* %248 to <16 x i8>*
store <16 x i8> %243, <16 x i8>* %249
%250 = add nuw i64 %221, 64
%251 = add i64 %222, 2
%252 = icmp eq i64 %251, %219
br i1 %252, label %253, label %220
253: ; preds = %220, %211
%254 = phi i64 [ 0, %211 ], [ %250, %220 ]
%255 = icmp eq i64 %216, 0
br i1 %255, label %270, label %256
256: ; preds = %253
%257 = trunc i64 %254 to i32
%258 = getelementptr inbounds i8, i8* %1, i64 %254
%259 = bitcast i8* %258 to <16 x i8>*
%260 = load <16 x i8>, <16 x i8>* %259
%261 = getelementptr inbounds i8, i8* %258, i64 16
%262 = bitcast i8* %261 to <16 x i8>*
%263 = load <16 x i8>, <16 x i8>* %262
%264 = add nsw i32 %188, %257
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds i8, i8* %1, i64 %265
%267 = bitcast i8* %266 to <16 x i8>*
store <16 x i8> %260, <16 x i8>* %267
%268 = getelementptr inbounds i8, i8* %266, i64 16
%269 = bitcast i8* %268 to <16 x i8>*
store <16 x i8> %263, <16 x i8>* %269
br label %270
270: ; preds = %253, %256
%271 = icmp eq i64 %212, %191
br i1 %271, label %313, label %272
272: ; preds = %270
%273 = and i64 %191, 24
%274 = icmp eq i64 %273, 0
br i1 %274, label %292, label %275
275: ; preds = %209, %272
%276 = phi i64 [ %212, %272 ], [ 0, %209 ]
%277 = and i64 %191, 4294967288
br label %278
278: ; preds = %278, %275
%279 = phi i64 [ %276, %275 ], [ %288, %278 ]
%280 = trunc i64 %279 to i32
%281 = getelementptr inbounds i8, i8* %1, i64 %279
%282 = bitcast i8* %281 to <8 x i8>*
%283 = load <8 x i8>, <8 x i8>* %282
%284 = add nsw i32 %188, %280
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds i8, i8* %1, i64 %285
%287 = bitcast i8* %286 to <8 x i8>*
store <8 x i8> %283, <8 x i8>* %287
%288 = add nuw i64 %279, 8
%289 = icmp eq i64 %288, %277
br i1 %289, label %290, label %278
290: ; preds = %278
%291 = icmp eq i64 %277, %191
br i1 %291, label %313, label %292
292: ; preds = %200, %193, %190, %272, %290
%293 = phi i64 [ 0, %190 ], [ 0, %200 ], [ 0, %193 ], [ %212, %272 ], [ %277, %290 ]
%294 = xor i64 %293, -1
%295 = add nsw i64 %294, %191
%296 = and i64 %191, 3
%297 = icmp eq i64 %296, 0
br i1 %297, label %310, label %298
298: ; preds = %292, %298
%299 = phi i64 [ %307, %298 ], [ %293, %292 ]
%300 = phi i64 [ %308, %298 ], [ 0, %292 ]
%301 = trunc i64 %299 to i32
%302 = getelementptr inbounds i8, i8* %1, i64 %299
%303 = load i8, i8* %302
%304 = add nsw i32 %188, %301
%305 = sext i32 %304 to i64
%306 = getelementptr inbounds i8, i8* %1, i64 %305
store i8 %303, i8* %306
%307 = add nuw nsw i64 %299, 1
%308 = add i64 %300, 1
%309 = icmp eq i64 %308, %296
br i1 %309, label %310, label %298
310: ; preds = %298, %292
%311 = phi i64 [ %293, %292 ], [ %307, %298 ]
%312 = icmp ult i64 %295, 3
br i1 %312, label %313, label %320
313: ; preds = %310, %320, %270, %290, %187
%314 = icmp sgt i32 %188, 0
br i1 %314, label %315, label %351
315: ; preds = %313
%316 = xor i32 %183, -1
%317 = add i32 %316, %3
%318 = zext i32 %317 to i64
%319 = add nuw nsw i64 %318, 1
br label %351
320: ; preds = %310, %320
%321 = phi i64 [ %349, %320 ], [ %311, %310 ]
%322 = trunc i64 %321 to i32
%323 = getelementptr inbounds i8, i8* %1, i64 %321
%324 = load i8, i8* %323
%325 = add nsw i32 %188, %322
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds i8, i8* %1, i64 %326
store i8 %324, i8* %327
%328 = add nuw nsw i64 %321, 1
%329 = trunc i64 %328 to i32
%330 = getelementptr inbounds i8, i8* %1, i64 %328
%331 = load i8, i8* %330
%332 = add nsw i32 %188, %329
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds i8, i8* %1, i64 %333
store i8 %331, i8* %334
%335 = add nuw nsw i64 %321, 2
%336 = trunc i64 %335 to i32
%337 = getelementptr inbounds i8, i8* %1, i64 %335
%338 = load i8, i8* %337
%339 = add nsw i32 %188, %336
%340 = sext i32 %339 to i64
%341 = getelementptr inbounds i8, i8* %1, i64 %340
store i8 %338, i8* %341
%342 = add nuw nsw i64 %321, 3
%343 = trunc i64 %342 to i32
%344 = getelementptr inbounds i8, i8* %1, i64 %342
%345 = load i8, i8* %344
%346 = add nsw i32 %188, %343
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds i8, i8* %1, i64 %347
store i8 %345, i8* %348
%349 = add nuw nsw i64 %321, 4
%350 = icmp eq i64 %349, %191
br i1 %350, label %313, label %320
351: ; preds = %315, %313
%352 = sext i32 %3 to i64
%353 = getelementptr inbounds i8, i8* %1, i64 %352
store i8 0, i8* %353
br label %354
354: ; preds = %351, %185
%355 = phi i32 [ %3, %351 ], [ %186, %185 ]
store i32 %355, i32* %8
ret void
}