#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*/ memcpy(char *, char *, int);
int /*<<< orphan*/ memset(char *, int /*<<< orphan*/, int);
int emit_digits(char *digits, int ndigits, char *dest, int K, bool neg,
                bool is_decimal) {
  int exp = ((K + ndigits - 1) < 0 ? -(K + ndigits - 1) : (K + ndigits - 1));
  if (K >= 0 && (exp < (ndigits + 7))) {
    memcpy(dest, digits, ndigits);
    memset(dest + ndigits, '0', K);
    return ndigits + K;
  }
  if (K < 0 && ((K > -7 || exp < 4) || is_decimal)) {
    int offset = ndigits - ((K) < 0 ? -(K) : (K));
    if (offset <= 0) {
      if (exp > (21 - (int)neg)) {
        memset(dest, '0', 1);
        return 1;
      }
      offset = -offset;
      dest[0] = '0';
      dest[1] = '.';
      memset(dest + 2, '0', offset);
      int n = ndigits;
      if ((offset + ndigits) > (21 - (int)neg)) {
        n = 21 - (int)neg - offset;
      }
      memcpy(dest + offset + 2, digits, n);
      return n + 2 + offset;
    } else {
      memcpy(dest, digits, offset);
      dest[offset] = '.';
      memcpy(dest + offset + 1, digits + offset, ndigits - offset);
      return ndigits + 1;
    }
  }
  if (is_decimal) {
    memcpy(dest, digits, ndigits);
    memset(dest + ndigits, '0', K);
    return ndigits + K;
  }
  ndigits = ((ndigits) < (18 - neg) ? (ndigits) : (18 - neg));
  int idx = 0;
  dest[idx++] = digits[0];
  if (ndigits > 1) {
    dest[idx++] = '.';
    memcpy(dest + idx, digits + 1, ndigits - 1);
    idx += ndigits - 1;
  }
  dest[idx++] = 'e';
  char sign = K + ndigits - 1 < 0 ? '-' : '+';
  dest[idx++] = sign;
  int cent = 0;
  if (exp > 99) {
    cent = exp / 100;
    dest[idx++] = cent + '0';
    exp -= cent * 100;
  }
  if (exp > 9) {
    int dec = exp / 10;
    dest[idx++] = dec + '0';
    exp -= dec * 10;
  } else if (cent) {
    dest[idx++] = '0';
  }
  dest[idx++] = exp % 10 + '0';
  return idx;
}


x86 assembly (clang, -O0):
<emit_digits>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8d,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    -0x14(%rbp),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jge    1165 <emit_digits+0x45>
mov    -0x24(%rbp),%ecx
add    -0x14(%rbp),%ecx
sub    $0x1,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
jmp    1171 <emit_digits+0x51>
mov    -0x24(%rbp),%eax
add    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x24(%rbp)
jl     11c8 <emit_digits+0xa8>
mov    -0x30(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x7,%ecx
cmp    %ecx,%eax
jge    11c8 <emit_digits+0xa8>
mov    -0x20(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x14(%rbp),%edx
call   1040 <memcpy@plt>
mov    -0x20(%rbp),%rdi
movslq -0x14(%rbp),%rax
add    %rax,%rdi
mov    -0x24(%rbp),%edx
mov    $0x30,%esi
call   1030 <memset@plt>
mov    -0x14(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    152c <emit_digits+0x40c>
cmpl   $0x0,-0x24(%rbp)
jge    132b <emit_digits+0x20b>
cmpl   $0xfffffff9,-0x24(%rbp)
jg     11f0 <emit_digits+0xd0>
cmpl   $0x4,-0x30(%rbp)
jl     11f0 <emit_digits+0xd0>
cmpl   $0x0,-0x2c(%rbp)
je     132b <emit_digits+0x20b>
mov    -0x14(%rbp),%eax
mov    %eax,-0x50(%rbp)
cmpl   $0x0,-0x24(%rbp)
jge    120d <emit_digits+0xed>
xor    %eax,%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    1213 <emit_digits+0xf3>
mov    -0x24(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x54(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jg     12dc <emit_digits+0x1bc>
mov    -0x30(%rbp),%eax
mov    $0x15,%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
jle    125a <emit_digits+0x13a>
mov    -0x20(%rbp),%rdi
mov    $0x30,%esi
mov    $0x1,%edx
call   1030 <memset@plt>
movl   $0x1,-0x4(%rbp)
jmp    152c <emit_digits+0x40c>
xor    %eax,%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x20(%rbp),%rax
movb   $0x30,(%rax)
mov    -0x20(%rbp),%rax
movb   $0x2e,0x1(%rax)
mov    -0x20(%rbp),%rdi
add    $0x2,%rdi
mov    -0x34(%rbp),%edx
mov    $0x30,%esi
call   1030 <memset@plt>
mov    -0x14(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
add    -0x14(%rbp),%eax
mov    $0x15,%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
jle    12b0 <emit_digits+0x190>
mov    $0x15,%eax
sub    -0x28(%rbp),%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x20(%rbp),%rdi
movslq -0x34(%rbp),%rax
add    %rax,%rdi
add    $0x2,%rdi
mov    -0x10(%rbp),%rsi
mov    -0x38(%rbp),%edx
call   1040 <memcpy@plt>
mov    -0x38(%rbp),%eax
add    $0x2,%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    152c <emit_digits+0x40c>
mov    -0x20(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x34(%rbp),%edx
call   1040 <memcpy@plt>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movb   $0x2e,(%rax,%rcx,1)
mov    -0x20(%rbp),%rdi
movslq -0x34(%rbp),%rax
add    %rax,%rdi
add    $0x1,%rdi
mov    -0x10(%rbp),%rsi
movslq -0x34(%rbp),%rax
add    %rax,%rsi
mov    -0x14(%rbp),%edx
sub    -0x34(%rbp),%edx
call   1040 <memcpy@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    152c <emit_digits+0x40c>
cmpl   $0x0,-0x2c(%rbp)
je     136b <emit_digits+0x24b>
mov    -0x20(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x14(%rbp),%edx
call   1040 <memcpy@plt>
mov    -0x20(%rbp),%rdi
movslq -0x14(%rbp),%rax
add    %rax,%rdi
mov    -0x24(%rbp),%edx
mov    $0x30,%esi
call   1030 <memset@plt>
mov    -0x14(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    152c <emit_digits+0x40c>
mov    -0x14(%rbp),%eax
mov    $0x12,%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    1389 <emit_digits+0x269>
mov    -0x14(%rbp),%eax
mov    %eax,-0x58(%rbp)
jmp    1394 <emit_digits+0x274>
mov    $0x12,%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x14(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%dl
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x3c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
cmpl   $0x1,-0x14(%rbp)
jle    1406 <emit_digits+0x2e6>
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x3c(%rbp)
movslq %ecx,%rcx
movb   $0x2e,(%rax,%rcx,1)
mov    -0x20(%rbp),%rdi
movslq -0x3c(%rbp),%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
add    $0x1,%rsi
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
call   1040 <memcpy@plt>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x3c(%rbp)
movslq %ecx,%rcx
movb   $0x65,(%rax,%rcx,1)
mov    -0x24(%rbp),%edx
add    -0x14(%rbp),%edx
sub    $0x1,%edx
mov    $0x2b,%eax
mov    $0x2d,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %al,-0x3d(%rbp)
mov    -0x3d(%rbp),%dl
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x3c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
movl   $0x0,-0x44(%rbp)
cmpl   $0x63,-0x30(%rbp)
jle    1498 <emit_digits+0x378>
mov    -0x30(%rbp),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
add    $0x30,%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x3c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
imul   $0x64,-0x44(%rbp),%ecx
mov    -0x30(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x9,-0x30(%rbp)
jle    14de <emit_digits+0x3be>
mov    -0x30(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    $0x30,%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x3c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
imul   $0xa,-0x48(%rbp),%ecx
mov    -0x30(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x30(%rbp)
jmp    1503 <emit_digits+0x3e3>
cmpl   $0x0,-0x44(%rbp)
je     14fe <emit_digits+0x3de>
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x3c(%rbp)
movslq %ecx,%rcx
movb   $0x30,(%rax,%rcx,1)
jmp    1503 <emit_digits+0x3e3>
mov    -0x30(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x3c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<emit_digits>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %ecx,%r12d
mov    %rdx,%r10
mov    %esi,%ebx
mov    %rdi,%r13
lea    (%r12,%rbx,1),%r15d
mov    $0x1,%eax
sub    %r15d,%eax
test   %r15d,%r15d
lea    -0x1(%r12,%rbx,1),%r14d
cmovle %eax,%r14d
test   %ecx,%ecx
js     115a <emit_digits+0x3a>
lea    0x7(%rbx),%eax
cmp    %eax,%r14d
jl     1164 <emit_digits+0x44>
test   %r12d,%r12d
js     118c <emit_digits+0x6c>
test   %r9d,%r9d
je     11a9 <emit_digits+0x89>
mov    %r10,%rdi
mov    %r13,%rsi
mov    %ebx,%edx
mov    %r10,%rbp
call   1040 <memcpy@plt>
movslq %ebx,%rdi
add    %rbp,%rdi
mov    $0x30,%esi
mov    %r12d,%edx
call   1030 <memset@plt>
jmp    134f <emit_digits+0x22f>
test   %r9d,%r9d
jne    129c <emit_digits+0x17c>
cmp    $0xfffffff9,%r12d
ja     129c <emit_digits+0x17c>
cmp    $0x3,%r14d
jle    129c <emit_digits+0x17c>
mov    $0x12,%ebp
sub    %r8d,%ebp
cmp    %ebx,%ebp
cmovg  %ebx,%ebp
mov    0x0(%r13),%al
mov    %al,(%r10)
mov    $0x1,%ecx
cmp    $0x2,%ebp
jl     11e8 <emit_digits+0xc8>
movb   $0x2e,0x1(%r10)
lea    0x2(%r10),%rdi
add    $0x1,%r13
lea    -0x1(%rbp),%edx
mov    %r13,%rsi
mov    %r10,%rbx
call   1040 <memcpy@plt>
mov    %rbx,%r10
lea    0x1(%rbp),%ecx
mov    %ecx,%eax
movb   $0x65,(%r10,%rax,1)
add    %r12d,%ebp
setle  %dl
add    %dl,%dl
add    $0x2b,%dl
mov    %dl,0x1(%r10,%rax,1)
lea    0x2(%rax),%r15
cmp    $0x64,%r14d
jl     123b <emit_digits+0x11b>
mov    %r14d,%edx
imul   $0x51eb851f,%rdx,%rdx
shr    $0x25,%rdx
imul   $0xffffff9c,%edx,%esi
add    $0x30,%dl
add    $0x3,%rax
mov    %dl,(%r10,%r15,1)
add    %esi,%r14d
cmp    $0x9,%r14d
jg     1244 <emit_digits+0x124>
add    $0x4,%ecx
movb   $0x30,(%r10,%rax,1)
mov    %ecx,%r15d
jmp    126c <emit_digits+0x14c>
mov    %r15d,%eax
cmp    $0xa,%r14d
jl     126c <emit_digits+0x14c>
mov    %r14d,%ecx
mov    $0xcccccccd,%edx
imul   %rcx,%rdx
shr    $0x23,%rdx
lea    (%rdx,%rdx,1),%ecx
add    $0x30,%dl
mov    %eax,%esi
add    $0x1,%eax
mov    %dl,(%r10,%rsi,1)
lea    (%rcx,%rcx,4),%ecx
sub    %ecx,%r14d
mov    %eax,%r15d
movslq %r14d,%rax
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
shr    $0x22,%rcx
add    %edx,%ecx
add    %ecx,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %ecx,%eax
add    $0x30,%al
mov    %r15d,%ecx
add    $0x1,%r15d
mov    %al,(%r10,%rcx,1)
jmp    134f <emit_digits+0x22f>
test   %r15d,%r15d
jle    12d8 <emit_digits+0x1b8>
neg    %r12d
mov    %r10,%rdi
mov    %r13,%rsi
mov    %r15d,%edx
mov    %r10,%rbp
call   1040 <memcpy@plt>
mov    %r15d,%eax
movb   $0x2e,0x0(%rbp,%rax,1)
lea    (%rax,%rbp,1),%rdi
add    $0x1,%rdi
add    %rax,%r13
mov    %r13,%rsi
mov    %r12d,%edx
call   1040 <memcpy@plt>
add    $0x1,%ebx
jmp    134c <emit_digits+0x22c>
mov    $0x15,%ebp
sub    %r8d,%ebp
cmp    %ebp,%r14d
jle    12ff <emit_digits+0x1df>
mov    $0x1,%r15d
mov    %r10,%rdi
mov    $0x30,%esi
mov    $0x1,%edx
call   1030 <memset@plt>
jmp    134f <emit_digits+0x22f>
mov    %r15d,%r14d
neg    %r14d
movw   $0x2e30,(%r10)
lea    0x2(%r10),%rdi
mov    $0x30,%esi
mov    %r14d,%edx
mov    %r10,(%rsp)
call   1030 <memset@plt>
neg    %r12d
lea    (%r15,%rbp,1),%eax
cmp    %r12d,%ebp
cmovl  %eax,%ebx
mov    %r14d,%eax
mov    (%rsp),%rcx
lea    (%rcx,%rax,1),%rdi
add    $0x2,%rdi
mov    %r13,%rsi
mov    %ebx,%edx
call   1040 <memcpy@plt>
sub    %r15d,%ebx
add    $0x2,%ebx
mov    %ebx,%r15d
mov    %r15d,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @emit_digits(i8* %0, i32 %1, i8* %2, i32 %3, i32 %4, i32 %5) {
%7 = add nsw i32 %3, %1
%8 = sub i32 0, %7
%9 = icmp slt i32 %7, 1
%10 = sub i32 1, %7
%11 = add nsw i32 %7, -1
%12 = select i1 %9, i32 %10, i32 %11
%13 = icmp sgt i32 %3, -1
%14 = add nsw i32 %1, 7
%15 = icmp slt i32 %12, %14
%16 = select i1 %13, i1 %15, i1 false
br i1 %16, label %17, label %22
17: ; preds = %6
%18 = tail call i32 @memcpy(i8* %2, i8* %0, i32 %1)
%19 = sext i32 %1 to i64
%20 = getelementptr inbounds i8, i8* %2, i64 %19
%21 = tail call i32 @memset(i8* %20, i32 48, i32 %3)
br label %127
22: ; preds = %6
%23 = icmp slt i32 %3, 0
br i1 %23, label %24, label %59
24: ; preds = %22
%25 = icmp ugt i32 %3, -7
%26 = icmp slt i32 %12, 4
%27 = select i1 %25, i1 true, i1 %26
%28 = icmp ne i32 %5, 0
%29 = or i1 %28, %27
br i1 %29, label %30, label %66
30: ; preds = %24
br i1 %9, label %31, label %50
31: ; preds = %30
%32 = sub nsw i32 21, %4
%33 = icmp sgt i32 %12, %32
br i1 %33, label %34, label %36
34: ; preds = %31
%35 = tail call i32 @memset(i8* %2, i32 48, i32 1)
br label %127
36: ; preds = %31
store i8 48, i8* %2
%37 = getelementptr inbounds i8, i8* %2, i64 1
store i8 46, i8* %37
%38 = getelementptr inbounds i8, i8* %2, i64 2
%39 = tail call i32 @memset(i8* %38, i32 48, i32 %8)
%40 = sub i32 0, %3
%41 = icmp slt i32 %32, %40
%42 = add nsw i32 %32, %7
%43 = select i1 %41, i32 %42, i32 %1
%44 = zext i32 %8 to i64
%45 = getelementptr inbounds i8, i8* %2, i64 %44
%46 = getelementptr inbounds i8, i8* %45, i64 2
%47 = tail call i32 @memcpy(i8* %46, i8* %0, i32 %43)
%48 = sub i32 2, %7
%49 = add i32 %48, %43
br label %127
50: ; preds = %30
%51 = sub nsw i32 0, %3
%52 = tail call i32 @memcpy(i8* %2, i8* %0, i32 %7)
%53 = zext i32 %7 to i64
%54 = getelementptr inbounds i8, i8* %2, i64 %53
store i8 46, i8* %54
%55 = getelementptr inbounds i8, i8* %54, i64 1
%56 = getelementptr inbounds i8, i8* %0, i64 %53
%57 = tail call i32 @memcpy(i8* %55, i8* %56, i32 %51)
%58 = add nsw i32 %1, 1
br label %127
59: ; preds = %22
%60 = icmp eq i32 %5, 0
br i1 %60, label %66, label %61
61: ; preds = %59
%62 = tail call i32 @memcpy(i8* %2, i8* %0, i32 %1)
%63 = sext i32 %1 to i64
%64 = getelementptr inbounds i8, i8* %2, i64 %63
%65 = tail call i32 @memset(i8* %64, i32 48, i32 %3)
br label %127
66: ; preds = %24, %59
%67 = sub nsw i32 18, %4
%68 = icmp sgt i32 %67, %1
%69 = select i1 %68, i32 %1, i32 %67
%70 = load i8, i8* %0
store i8 %70, i8* %2
%71 = icmp sgt i32 %69, 1
br i1 %71, label %72, label %79
72: ; preds = %66
%73 = getelementptr inbounds i8, i8* %2, i64 1
store i8 46, i8* %73
%74 = getelementptr inbounds i8, i8* %2, i64 2
%75 = getelementptr inbounds i8, i8* %0, i64 1
%76 = add nsw i32 %69, -1
%77 = tail call i32 @memcpy(i8* %74, i8* %75, i32 %76)
%78 = add nuw nsw i32 %69, 1
br label %79
79: ; preds = %72, %66
%80 = phi i32 [ %78, %72 ], [ 1, %66 ]
%81 = add nuw nsw i32 %80, 1
%82 = zext i32 %80 to i64
%83 = getelementptr inbounds i8, i8* %2, i64 %82
store i8 101, i8* %83
%84 = add nsw i32 %69, %3
%85 = icmp slt i32 %84, 1
%86 = select i1 %85, i8 45, i8 43
%87 = add nuw nsw i32 %80, 2
%88 = zext i32 %81 to i64
%89 = getelementptr inbounds i8, i8* %2, i64 %88
store i8 %86, i8* %89
%90 = icmp sgt i32 %12, 99
br i1 %90, label %91, label %101
91: ; preds = %79
%92 = udiv i32 %12, 100
%93 = trunc i32 %92 to i8
%94 = add i8 %93, 48
%95 = add nuw nsw i32 %80, 3
%96 = zext i32 %87 to i64
%97 = getelementptr inbounds i8, i8* %2, i64 %96
store i8 %94, i8* %97
%98 = mul nsw i32 %92, -100
%99 = add nsw i32 %98, %12
%100 = icmp sgt i32 %99, 9
br i1 %100, label %103, label %114
101: ; preds = %79
%102 = icmp sgt i32 %12, 9
br i1 %102, label %103, label %118
103: ; preds = %101, %91
%104 = phi i32 [ %87, %101 ], [ %95, %91 ]
%105 = phi i32 [ %12, %101 ], [ %99, %91 ]
%106 = udiv i32 %105, 10
%107 = trunc i32 %106 to i8
%108 = add i8 %107, 48
%109 = add nuw nsw i32 %104, 1
%110 = zext i32 %104 to i64
%111 = getelementptr inbounds i8, i8* %2, i64 %110
store i8 %108, i8* %111
%112 = mul nsw i32 %106, -10
%113 = add nsw i32 %112, %105
br label %118
114: ; preds = %91
%115 = add nuw nsw i32 %80, 4
%116 = zext i32 %95 to i64
%117 = getelementptr inbounds i8, i8* %2, i64 %116
store i8 48, i8* %117
br label %118
118: ; preds = %101, %114, %103
%119 = phi i32 [ %113, %103 ], [ %99, %114 ], [ %12, %101 ]
%120 = phi i32 [ %109, %103 ], [ %115, %114 ], [ %87, %101 ]
%121 = srem i32 %119, 10
%122 = trunc i32 %121 to i8
%123 = add nsw i8 %122, 48
%124 = add nuw nsw i32 %120, 1
%125 = zext i32 %120 to i64
%126 = getelementptr inbounds i8, i8* %2, i64 %125
store i8 %123, i8* %126
br label %127
127: ; preds = %34, %36, %50, %118, %61, %17
%128 = phi i32 [ %7, %17 ], [ %7, %61 ], [ %124, %118 ], [ 1, %34 ], [ %49, %36 ], [ %58, %50 ]
ret i32 %128
}