#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int uint32_t;

/* Variables and functions */
unsigned char *append_uint32(unsigned char *cp, uint32_t i) {
  uint32_t j;
  if (i == 0) {
    *cp++ = '0';
    return cp;
  }
  if (i < 100)
    goto b1;
  if (i < 10000)
    goto b3;
  if (i < 1000000)
    goto b5;
  if (i < 100000000)
    goto b7;
  if ((j = i / 1000000000)) {
    *cp++ = j + '0';
    i -= j * 1000000000;
    goto x8;
  }
  if ((j = i / 100000000)) {
    *cp++ = j + '0';
    i -= j * 100000000;
    goto x7;
  }
b7:
  if ((j = i / 10000000)) {
    *cp++ = j + '0';
    i -= j * 10000000;
    goto x6;
  }
  if ((j = i / 1000000)) {
    *cp++ = j + '0', i -= j * 1000000;
    goto x5;
  }
b5:
  if ((j = i / 100000)) {
    *cp++ = j + '0', i -= j * 100000;
    goto x4;
  }
  if ((j = i / 10000)) {
    *cp++ = j + '0', i -= j * 10000;
    goto x3;
  }
b3:
  if ((j = i / 1000)) {
    *cp++ = j + '0', i -= j * 1000;
    goto x2;
  }
  if ((j = i / 100)) {
    *cp++ = j + '0', i -= j * 100;
    goto x1;
  }
b1:
  if ((j = i / 10)) {
    *cp++ = j + '0', i -= j * 10;
    goto x0;
  }
  if (i)
    *cp++ = i + '0';
  return cp;
x8:
  *cp++ = i / 100000000 + '0', i %= 100000000;
x7:
  *cp++ = i / 10000000 + '0', i %= 10000000;
x6:
  *cp++ = i / 1000000 + '0', i %= 1000000;
x5:
  *cp++ = i / 100000 + '0', i %= 100000;
x4:
  *cp++ = i / 10000 + '0', i %= 10000;
x3:
  *cp++ = i / 1000 + '0', i %= 1000;
x2:
  *cp++ = i / 100 + '0', i %= 100;
x1:
  *cp++ = i / 10 + '0', i %= 10;
x0:
  *cp++ = i + '0';
  return cp;
}


x86 assembly (clang, -O0):
<append_uint32>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jne    1134 <append_uint32+0x34>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x30,(%rax)
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    15b4 <append_uint32+0x4b4>
cmpl   $0x64,-0x14(%rbp)
jge    1143 <append_uint32+0x43>
jmp    13aa <append_uint32+0x2aa>
cmpl   $0x2710,-0x14(%rbp)
jge    1155 <append_uint32+0x55>
jmp    1320 <append_uint32+0x220>
cmpl   $0xf4240,-0x14(%rbp)
jge    1167 <append_uint32+0x67>
jmp    1293 <append_uint32+0x193>
cmpl   $0x5f5e100,-0x14(%rbp)
jge    1179 <append_uint32+0x79>
jmp    1206 <append_uint32+0x106>
mov    -0x14(%rbp),%eax
mov    $0x3b9aca00,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
cmp    $0x0,%eax
je     11bd <append_uint32+0xbd>
mov    -0x18(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
imul   $0x3b9aca00,-0x18(%rbp),%ecx
mov    -0x14(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x14(%rbp)
jmp    141b <append_uint32+0x31b>
mov    -0x14(%rbp),%eax
mov    $0x5f5e100,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
cmp    $0x0,%eax
je     1201 <append_uint32+0x101>
mov    -0x18(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
imul   $0x5f5e100,-0x18(%rbp),%ecx
mov    -0x14(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x14(%rbp)
jmp    144a <append_uint32+0x34a>
jmp    1206 <append_uint32+0x106>
mov    -0x14(%rbp),%eax
mov    $0x989680,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
cmp    $0x0,%eax
je     124a <append_uint32+0x14a>
mov    -0x18(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
imul   $0x989680,-0x18(%rbp),%ecx
mov    -0x14(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x14(%rbp)
jmp    1479 <append_uint32+0x379>
mov    -0x14(%rbp),%eax
mov    $0xf4240,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
cmp    $0x0,%eax
je     128e <append_uint32+0x18e>
mov    -0x18(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
imul   $0xf4240,-0x18(%rbp),%ecx
mov    -0x14(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x14(%rbp)
jmp    14a8 <append_uint32+0x3a8>
jmp    1293 <append_uint32+0x193>
mov    -0x14(%rbp),%eax
mov    $0x186a0,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
cmp    $0x0,%eax
je     12d7 <append_uint32+0x1d7>
mov    -0x18(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
imul   $0x186a0,-0x18(%rbp),%ecx
mov    -0x14(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x14(%rbp)
jmp    14d7 <append_uint32+0x3d7>
mov    -0x14(%rbp),%eax
mov    $0x2710,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
cmp    $0x0,%eax
je     131b <append_uint32+0x21b>
mov    -0x18(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
imul   $0x2710,-0x18(%rbp),%ecx
mov    -0x14(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x14(%rbp)
jmp    1506 <append_uint32+0x406>
jmp    1320 <append_uint32+0x220>
mov    -0x14(%rbp),%eax
mov    $0x3e8,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
cmp    $0x0,%eax
je     1364 <append_uint32+0x264>
mov    -0x18(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
imul   $0x3e8,-0x18(%rbp),%ecx
mov    -0x14(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x14(%rbp)
jmp    1535 <append_uint32+0x435>
mov    -0x14(%rbp),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
cmp    $0x0,%eax
je     13a5 <append_uint32+0x2a5>
mov    -0x18(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
imul   $0x64,-0x18(%rbp),%ecx
mov    -0x14(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x14(%rbp)
jmp    1564 <append_uint32+0x464>
jmp    13aa <append_uint32+0x2aa>
mov    -0x14(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
cmp    $0x0,%eax
je     13eb <append_uint32+0x2eb>
mov    -0x18(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
imul   $0xa,-0x18(%rbp),%ecx
mov    -0x14(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x14(%rbp)
jmp    1593 <append_uint32+0x493>
cmpl   $0x0,-0x14(%rbp)
je     140e <append_uint32+0x30e>
mov    -0x14(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    15b4 <append_uint32+0x4b4>
mov    -0x14(%rbp),%eax
mov    $0x5f5e100,%ecx
cltd
idiv   %ecx
add    $0x30,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%eax
mov    $0x5f5e100,%ecx
cltd
idiv   %ecx
mov    %edx,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x989680,%ecx
cltd
idiv   %ecx
add    $0x30,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%eax
mov    $0x989680,%ecx
cltd
idiv   %ecx
mov    %edx,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    $0xf4240,%ecx
cltd
idiv   %ecx
add    $0x30,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%eax
mov    $0xf4240,%ecx
cltd
idiv   %ecx
mov    %edx,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x186a0,%ecx
cltd
idiv   %ecx
add    $0x30,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%eax
mov    $0x186a0,%ecx
cltd
idiv   %ecx
mov    %edx,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2710,%ecx
cltd
idiv   %ecx
add    $0x30,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%eax
mov    $0x2710,%ecx
cltd
idiv   %ecx
mov    %edx,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x3e8,%ecx
cltd
idiv   %ecx
add    $0x30,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%eax
mov    $0x3e8,%ecx
cltd
idiv   %ecx
mov    %edx,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
add    $0x30,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
mov    %edx,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %edx,-0x14(%rbp)
mov    -0x14(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<append_uint32>:
mov    %rdi,%rax
test   %esi,%esi
je     1144 <append_uint32+0x44>
cmp    $0x64,%esi
jge    114c <append_uint32+0x4c>
lea    0x9(%rsi),%ecx
cmp    $0x13,%ecx
jb     13bf <append_uint32+0x2bf>
movslq %esi,%rcx
imul   $0x66666667,%rcx,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x22,%rcx
add    %edx,%ecx
lea    0x30(%rcx),%edx
mov    %dl,(%rax)
add    $0x1,%rax
add    %ecx,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %ecx,%esi
jmp    13bf <append_uint32+0x2bf>
movb   $0x30,(%rax)
add    $0x1,%rax
ret
cmp    $0x2710,%esi
jae    117a <append_uint32+0x7a>
movzwl %si,%ecx
cmp    $0x3e8,%esi
jae    11ab <append_uint32+0xab>
shr    $0x2,%ecx
imul   $0x147b,%ecx,%ecx
shr    $0x11,%ecx
lea    0x30(%rcx),%edx
mov    %dl,(%rax)
imul   $0xffffff9c,%ecx,%ecx
add    %esi,%ecx
jmp    1397 <append_uint32+0x297>
cmp    $0xf4240,%esi
jae    11d0 <append_uint32+0xd0>
cmp    $0x186a0,%esi
jae    11ff <append_uint32+0xff>
mov    %esi,%ecx
mov    $0xd1b71759,%edx
imul   %rcx,%rdx
shr    $0x2d,%rdx
imul   $0xffffd8f0,%edx,%ecx
add    $0x30,%dl
mov    %dl,(%rax)
add    %esi,%ecx
jmp    134c <append_uint32+0x24c>
shr    $0x3,%ecx
imul   $0x20c5,%ecx,%ecx
shr    $0x14,%ecx
movzwl %cx,%ecx
lea    0x30(%rcx),%edx
mov    %dl,(%rax)
add    $0x1,%rax
imul   $0xfffffc18,%ecx,%ecx
add    %esi,%ecx
jmp    1376 <append_uint32+0x276>
cmp    $0x5f5e100,%esi
jae    1225 <append_uint32+0x125>
mov    %esi,%ecx
cmp    $0x989680,%esi
jae    124d <append_uint32+0x14d>
imul   $0x431bde83,%rcx,%rdx
shr    $0x32,%rdx
imul   $0xfff0bdc0,%edx,%ecx
add    $0x30,%dl
mov    %dl,(%rax)
add    %esi,%ecx
jmp    12fd <append_uint32+0x1fd>
mov    %esi,%ecx
shr    $0x5,%ecx
imul   $0xa7c5ac5,%rcx,%rcx
shr    $0x27,%rcx
lea    0x30(%rcx),%edx
mov    %dl,(%rax)
add    $0x1,%rax
imul   $0xfffe7960,%ecx,%ecx
add    %esi,%ecx
jmp    1327 <append_uint32+0x227>
cmp    $0x3b9aca00,%esi
jae    1267 <append_uint32+0x167>
mov    %esi,%ecx
imul   $0x55e63b89,%rcx,%rdx
shr    $0x39,%rdx
imul   $0xfa0a1f00,%edx,%ecx
add    $0x30,%dl
mov    %dl,(%rax)
add    $0x1,%rax
add    %esi,%ecx
jmp    12ae <append_uint32+0x1ae>
imul   $0x6b5fca6b,%rcx,%rcx
shr    $0x36,%rcx
lea    0x30(%rcx),%edx
mov    %dl,(%rax)
imul   $0xff676980,%ecx,%ecx
add    %esi,%ecx
jmp    12d3 <append_uint32+0x1d3>
mov    %esi,%ecx
shr    $0x9,%ecx
imul   $0x44b83,%rcx,%rcx
shr    $0x27,%rcx
lea    0x30(%rcx),%edx
mov    %dl,(%rax)
imul   $0xc4653600,%ecx,%ecx
add    %esi,%ecx
movslq %ecx,%rcx
imul   $0x55e63b89,%rcx,%rdx
mov    %rdx,%rsi
shr    $0x3f,%rsi
sar    $0x39,%rdx
add    %esi,%edx
lea    0x30(%rdx),%esi
mov    %sil,0x1(%rax)
add    $0x2,%rax
imul   $0x5f5e100,%edx,%edx
sub    %edx,%ecx
movslq %ecx,%rcx
imul   $0x6b5fca6b,%rcx,%rdx
mov    %rdx,%rsi
shr    $0x3f,%rsi
sar    $0x36,%rdx
add    %esi,%edx
lea    0x30(%rdx),%esi
mov    %sil,(%rax)
imul   $0x989680,%edx,%edx
sub    %edx,%ecx
movslq %ecx,%rcx
imul   $0x431bde83,%rcx,%rdx
mov    %rdx,%rsi
shr    $0x3f,%rsi
sar    $0x32,%rdx
add    %esi,%edx
lea    0x30(%rdx),%esi
mov    %sil,0x1(%rax)
add    $0x1,%rax
imul   $0xf4240,%edx,%edx
sub    %edx,%ecx
movslq %ecx,%rcx
imul   $0x14f8b589,%rcx,%rdx
mov    %rdx,%rsi
shr    $0x3f,%rsi
sar    $0x2d,%rdx
add    %esi,%edx
lea    0x30(%rdx),%esi
mov    %sil,0x1(%rax)
add    $0x2,%rax
imul   $0x186a0,%edx,%edx
sub    %edx,%ecx
movslq %ecx,%rcx
imul   $0x68db8bad,%rcx,%rdx
mov    %rdx,%rsi
shr    $0x3f,%rsi
sar    $0x2c,%rdx
add    %esi,%edx
lea    0x30(%rdx),%esi
mov    %sil,(%rax)
imul   $0x2710,%edx,%edx
sub    %edx,%ecx
movslq %ecx,%rcx
imul   $0x10624dd3,%rcx,%rdx
mov    %rdx,%rsi
shr    $0x3f,%rsi
sar    $0x26,%rdx
add    %esi,%edx
lea    0x30(%rdx),%esi
mov    %sil,0x1(%rax)
add    $0x2,%rax
imul   $0x3e8,%edx,%edx
sub    %edx,%ecx
movswl %cx,%edx
imul   $0x147b,%edx,%edx
mov    %edx,%esi
shr    $0x1f,%esi
sar    $0x13,%edx
add    %esi,%edx
lea    0x30(%rdx),%esi
mov    %sil,(%rax)
imul   $0x64,%edx,%edx
sub    %edx,%ecx
movzwl %cx,%ecx
movswl %cx,%edx
imul   $0x6667,%edx,%edx
mov    %edx,%esi
shr    $0x1f,%esi
sar    $0x12,%edx
add    %esi,%edx
lea    0x30(%rdx),%esi
mov    %sil,0x1(%rax)
add    $0x2,%rax
add    %edx,%edx
lea    (%rdx,%rdx,4),%edx
sub    %edx,%ecx
movzwl %cx,%esi
add    $0x30,%sil
mov    %sil,(%rax)
add    $0x1,%rax
ret

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

LLVM IR (-O2):
define i8* @append_uint32(i8* writeonly %0, i32 %1) {
%3 = icmp eq i32 %1, 0
br i1 %3, label %4, label %5
4: ; preds = %2
store i8 48, i8* %0
br label %159
5: ; preds = %2
%6 = icmp slt i32 %1, 100
br i1 %6, label %81, label %7
7: ; preds = %5
%8 = icmp ult i32 %1, 10000
br i1 %8, label %63, label %9
9: ; preds = %7
%10 = icmp ult i32 %1, 1000000
br i1 %10, label %48, label %11
11: ; preds = %9
%12 = icmp ult i32 %1, 100000000
br i1 %12, label %34, label %13
13: ; preds = %11
%14 = udiv i32 %1, 1000000000
%15 = icmp ult i32 %1, 1000000000
br i1 %15, label %27, label %16
16: ; preds = %13
%17 = trunc i32 %14 to i8
%18 = or i8 %17, 48
%19 = getelementptr inbounds i8, i8* %0, i64 1
store i8 %18, i8* %0
%20 = mul nsw i32 %14, -1000000000
%21 = add nsw i32 %20, %1
%22 = sdiv i32 %21, 100000000
%23 = trunc i32 %22 to i8
%24 = add nsw i8 %23, 48
%25 = getelementptr inbounds i8, i8* %0, i64 2
store i8 %24, i8* %19
%26 = srem i32 %21, 100000000
br label %94
27: ; preds = %13
%28 = udiv i32 %1, 100000000
%29 = trunc i32 %28 to i8
%30 = add nuw nsw i8 %29, 48
%31 = getelementptr inbounds i8, i8* %0, i64 1
store i8 %30, i8* %0
%32 = mul nsw i32 %28, -100000000
%33 = add nsw i32 %32, %1
br label %94
34: ; preds = %11
%35 = udiv i32 %1, 10000000
%36 = icmp ult i32 %1, 10000000
br i1 %36, label %42, label %37
37: ; preds = %34
%38 = trunc i32 %35 to i8
%39 = add nuw nsw i8 %38, 48
store i8 %39, i8* %0
%40 = mul nsw i32 %35, -10000000
%41 = add nsw i32 %40, %1
br label %101
42: ; preds = %34
%43 = udiv i32 %1, 1000000
%44 = trunc i32 %43 to i8
%45 = add nuw nsw i8 %44, 48
store i8 %45, i8* %0
%46 = mul nsw i32 %43, -1000000
%47 = add nsw i32 %46, %1
br label %109
48: ; preds = %9
%49 = udiv i32 %1, 100000
%50 = icmp ult i32 %1, 100000
br i1 %50, label %57, label %51
51: ; preds = %48
%52 = trunc i32 %49 to i8
%53 = add nuw nsw i8 %52, 48
%54 = getelementptr inbounds i8, i8* %0, i64 1
store i8 %53, i8* %0
%55 = mul nsw i32 %49, -100000
%56 = add nsw i32 %55, %1
br label %118
57: ; preds = %48
%58 = udiv i32 %1, 10000
%59 = trunc i32 %58 to i8
%60 = add nuw nsw i8 %59, 48
store i8 %60, i8* %0
%61 = mul nsw i32 %58, -10000
%62 = add nsw i32 %61, %1
br label %125
63: ; preds = %7
%64 = trunc i32 %1 to i16
%65 = udiv i16 %64, 1000
%66 = icmp ult i32 %1, 1000
br i1 %66, label %74, label %67
67: ; preds = %63
%68 = zext i16 %65 to i32
%69 = trunc i16 %65 to i8
%70 = add nuw nsw i8 %69, 48
%71 = getelementptr inbounds i8, i8* %0, i64 1
store i8 %70, i8* %0
%72 = mul nsw i32 %68, -1000
%73 = add nsw i32 %72, %1
br label %134
74: ; preds = %63
%75 = udiv i16 %64, 100
%76 = zext i16 %75 to i32
%77 = trunc i16 %75 to i8
%78 = add nuw nsw i8 %77, 48
store i8 %78, i8* %0
%79 = mul nsw i32 %76, -100
%80 = add nsw i32 %79, %1
br label %143
81: ; preds = %5
%82 = sdiv i32 %1, 10
%83 = add nsw i32 %1, 9
%84 = icmp ult i32 %83, 19
br i1 %84, label %91, label %85
85: ; preds = %81
%86 = trunc i32 %82 to i8
%87 = add i8 %86, 48
%88 = getelementptr inbounds i8, i8* %0, i64 1
store i8 %87, i8* %0
%89 = mul nsw i32 %82, -10
%90 = add i32 %89, %1
br label %154
91: ; preds = %81
%92 = trunc i32 %1 to i8
%93 = add nsw i8 %92, 48
store i8 %93, i8* %0
br label %159
94: ; preds = %16, %27
%95 = phi i8* [ %25, %16 ], [ %31, %27 ]
%96 = phi i32 [ %26, %16 ], [ %33, %27 ]
%97 = sdiv i32 %96, 10000000
%98 = trunc i32 %97 to i8
%99 = add i8 %98, 48
store i8 %99, i8* %95
%100 = srem i32 %96, 10000000
br label %101
101: ; preds = %94, %37
%102 = phi i8* [ %0, %37 ], [ %95, %94 ]
%103 = phi i32 [ %41, %37 ], [ %100, %94 ]
%104 = getelementptr inbounds i8, i8* %102, i64 1
%105 = sdiv i32 %103, 1000000
%106 = trunc i32 %105 to i8
%107 = add i8 %106, 48
store i8 %107, i8* %104
%108 = srem i32 %103, 1000000
br label %109
109: ; preds = %101, %42
%110 = phi i8* [ %104, %101 ], [ %0, %42 ]
%111 = phi i32 [ %108, %101 ], [ %47, %42 ]
%112 = getelementptr inbounds i8, i8* %110, i64 1
%113 = sdiv i32 %111, 100000
%114 = trunc i32 %113 to i8
%115 = add i8 %114, 48
%116 = getelementptr inbounds i8, i8* %110, i64 2
store i8 %115, i8* %112
%117 = srem i32 %111, 100000
br label %118
118: ; preds = %109, %51
%119 = phi i8* [ %54, %51 ], [ %116, %109 ]
%120 = phi i32 [ %56, %51 ], [ %117, %109 ]
%121 = sdiv i32 %120, 10000
%122 = trunc i32 %121 to i8
%123 = add i8 %122, 48
store i8 %123, i8* %119
%124 = srem i32 %120, 10000
br label %125
125: ; preds = %118, %57
%126 = phi i8* [ %119, %118 ], [ %0, %57 ]
%127 = phi i32 [ %124, %118 ], [ %62, %57 ]
%128 = getelementptr inbounds i8, i8* %126, i64 1
%129 = sdiv i32 %127, 1000
%130 = trunc i32 %129 to i8
%131 = add i8 %130, 48
%132 = getelementptr inbounds i8, i8* %126, i64 2
store i8 %131, i8* %128
%133 = srem i32 %127, 1000
br label %134
134: ; preds = %125, %67
%135 = phi i8* [ %71, %67 ], [ %132, %125 ]
%136 = phi i32 [ %73, %67 ], [ %133, %125 ]
%137 = trunc i32 %136 to i16
%138 = sdiv i16 %137, 100
%139 = trunc i16 %138 to i8
%140 = add i8 %139, 48
store i8 %140, i8* %135
%141 = srem i16 %137, 100
%142 = zext i16 %141 to i32
br label %143
143: ; preds = %134, %74
%144 = phi i8* [ %135, %134 ], [ %0, %74 ]
%145 = phi i32 [ %142, %134 ], [ %80, %74 ]
%146 = getelementptr inbounds i8, i8* %144, i64 1
%147 = trunc i32 %145 to i16
%148 = sdiv i16 %147, 10
%149 = trunc i16 %148 to i8
%150 = add i8 %149, 48
%151 = getelementptr inbounds i8, i8* %144, i64 2
store i8 %150, i8* %146
%152 = srem i16 %147, 10
%153 = zext i16 %152 to i32
br label %154
154: ; preds = %143, %85
%155 = phi i8* [ %88, %85 ], [ %151, %143 ]
%156 = phi i32 [ %90, %85 ], [ %153, %143 ]
%157 = trunc i32 %156 to i8
%158 = add i8 %157, 48
store i8 %158, i8* %155
br label %159
159: ; preds = %154, %91, %4
%160 = phi i8* [ %0, %4 ], [ %155, %154 ], [ %0, %91 ]
%161 = getelementptr inbounds i8, i8* %160, i64 1
ret i8* %161
}