#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*/ puts(char *);
void puti(int x) {
  int i = 0, j = 0;
  char buf[12];
  if (x < 0) {
    x = -x;
    buf[i++] = '-';
  }
  buf[i] = '0' + ((x / 1000000000) % 10);
  if (j || buf[i] != '0')
    j = i += 1;
  buf[i] = '0' + ((x / 100000000) % 10);
  if (j || buf[i] != '0')
    j = i += 1;
  buf[i] = '0' + ((x / 10000000) % 10);
  if (j || buf[i] != '0')
    j = i += 1;
  buf[i] = '0' + ((x / 1000000) % 10);
  if (j || buf[i] != '0')
    j = i += 1;
  buf[i] = '0' + ((x / 100000) % 10);
  if (j || buf[i] != '0')
    j = i += 1;
  buf[i] = '0' + ((x / 10000) % 10);
  if (j || buf[i] != '0')
    j = i += 1;
  buf[i] = '0' + ((x / 1000) % 10);
  if (j || buf[i] != '0')
    j = i += 1;
  buf[i] = '0' + ((x / 100) % 10);
  if (j || buf[i] != '0')
    j = i += 1;
  buf[i] = '0' + ((x / 10) % 10);
  if (j || buf[i] != '0')
    j = i += 1;
  buf[i] = '0' + ((x) % 10);
  j = i + 1;
  buf[j] = 0;
  puts(buf);
}


x86 assembly (clang, -O0):
<puti>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %edi,-0x4(%rbp)
movl   $0x0,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x0,-0x4(%rbp)
jge    114d <puti+0x3d>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x8(%rbp)
cltq
movb   $0x2d,-0x18(%rbp,%rax,1)
mov    -0x4(%rbp),%eax
mov    $0x3b9aca00,%ecx
cltd
idiv   %ecx
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
movslq -0x8(%rbp),%rax
mov    %cl,-0x18(%rbp,%rax,1)
cmpl   $0x0,-0xc(%rbp)
jne    1189 <puti+0x79>
movslq -0x8(%rbp),%rax
movsbl -0x18(%rbp,%rax,1),%eax
cmp    $0x30,%eax
je     1195 <puti+0x85>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0xc(%rbp)
mov    -0x4(%rbp),%eax
mov    $0x5f5e100,%ecx
cltd
idiv   %ecx
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
movslq -0x8(%rbp),%rax
mov    %cl,-0x18(%rbp,%rax,1)
cmpl   $0x0,-0xc(%rbp)
jne    11d1 <puti+0xc1>
movslq -0x8(%rbp),%rax
movsbl -0x18(%rbp,%rax,1),%eax
cmp    $0x30,%eax
je     11dd <puti+0xcd>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0xc(%rbp)
mov    -0x4(%rbp),%eax
mov    $0x989680,%ecx
cltd
idiv   %ecx
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
movslq -0x8(%rbp),%rax
mov    %cl,-0x18(%rbp,%rax,1)
cmpl   $0x0,-0xc(%rbp)
jne    1219 <puti+0x109>
movslq -0x8(%rbp),%rax
movsbl -0x18(%rbp,%rax,1),%eax
cmp    $0x30,%eax
je     1225 <puti+0x115>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0xc(%rbp)
mov    -0x4(%rbp),%eax
mov    $0xf4240,%ecx
cltd
idiv   %ecx
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
movslq -0x8(%rbp),%rax
mov    %cl,-0x18(%rbp,%rax,1)
cmpl   $0x0,-0xc(%rbp)
jne    1261 <puti+0x151>
movslq -0x8(%rbp),%rax
movsbl -0x18(%rbp,%rax,1),%eax
cmp    $0x30,%eax
je     126d <puti+0x15d>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0xc(%rbp)
mov    -0x4(%rbp),%eax
mov    $0x186a0,%ecx
cltd
idiv   %ecx
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
movslq -0x8(%rbp),%rax
mov    %cl,-0x18(%rbp,%rax,1)
cmpl   $0x0,-0xc(%rbp)
jne    12a9 <puti+0x199>
movslq -0x8(%rbp),%rax
movsbl -0x18(%rbp,%rax,1),%eax
cmp    $0x30,%eax
je     12b5 <puti+0x1a5>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0xc(%rbp)
mov    -0x4(%rbp),%eax
mov    $0x2710,%ecx
cltd
idiv   %ecx
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
movslq -0x8(%rbp),%rax
mov    %cl,-0x18(%rbp,%rax,1)
cmpl   $0x0,-0xc(%rbp)
jne    12f1 <puti+0x1e1>
movslq -0x8(%rbp),%rax
movsbl -0x18(%rbp,%rax,1),%eax
cmp    $0x30,%eax
je     12fd <puti+0x1ed>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0xc(%rbp)
mov    -0x4(%rbp),%eax
mov    $0x3e8,%ecx
cltd
idiv   %ecx
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
movslq -0x8(%rbp),%rax
mov    %cl,-0x18(%rbp,%rax,1)
cmpl   $0x0,-0xc(%rbp)
jne    1339 <puti+0x229>
movslq -0x8(%rbp),%rax
movsbl -0x18(%rbp,%rax,1),%eax
cmp    $0x30,%eax
je     1345 <puti+0x235>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0xc(%rbp)
mov    -0x4(%rbp),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
movslq -0x8(%rbp),%rax
mov    %cl,-0x18(%rbp,%rax,1)
cmpl   $0x0,-0xc(%rbp)
jne    1381 <puti+0x271>
movslq -0x8(%rbp),%rax
movsbl -0x18(%rbp,%rax,1),%eax
cmp    $0x30,%eax
je     138d <puti+0x27d>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0xc(%rbp)
mov    -0x4(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
movslq -0x8(%rbp),%rax
mov    %cl,-0x18(%rbp,%rax,1)
cmpl   $0x0,-0xc(%rbp)
jne    13c9 <puti+0x2b9>
movslq -0x8(%rbp),%rax
movsbl -0x18(%rbp,%rax,1),%eax
cmp    $0x30,%eax
je     13d5 <puti+0x2c5>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0xc(%rbp)
mov    -0x4(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
movslq -0x8(%rbp),%rax
mov    %cl,-0x18(%rbp,%rax,1)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
movslq -0xc(%rbp),%rax
movb   $0x0,-0x18(%rbp,%rax,1)
lea    -0x18(%rbp),%rdi
call   1030 <puts@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<puti>:
sub    $0x18,%rsp
xor    %eax,%eax
test   %edi,%edi
jns    1126 <puti+0x16>
neg    %edi
movb   $0x2d,0xc(%rsp)
mov    $0x1,%eax
mov    %edi,%ecx
shr    $0x9,%ecx
imul   $0x44b83,%rcx,%rdx
shr    $0x27,%rdx
lea    0x30(%rdx),%esi
mov    %eax,%r10d
mov    %sil,0xc(%rsp,%r10,1)
mov    %edi,%r8d
imul   $0x55e63b89,%r8,%rax
shr    $0x39,%rax
imul   $0xcd,%eax,%esi
shr    $0xa,%esi
and    $0xfffffffe,%esi
lea    (%rsi,%rsi,4),%esi
sub    %sil,%al
mov    %edx,%esi
or     %al,%sil
cmp    $0x1,%rdx
sbb    $0xffffffffffffffff,%r10
or     $0x30,%al
mov    %al,0xc(%rsp,%r10,1)
imul   $0x6b5fca6b,%r8,%rax
shr    $0x36,%rax
movzbl %al,%edx
imul   $0xcd,%edx,%edx
shr    $0xa,%edx
and    $0xfffffffe,%edx
lea    (%rdx,%rdx,4),%edx
sub    %dl,%al
mov    %esi,%edx
or     %al,%dl
cmp    $0x1,%sil
sbb    $0xffffffffffffffff,%r10
or     $0x30,%al
mov    %al,0xc(%rsp,%r10,1)
imul   $0x431bde83,%r8,%rax
shr    $0x32,%rax
imul   $0xcccd,%eax,%esi
shr    $0x12,%esi
and    $0xfffffffe,%esi
lea    (%rsi,%rsi,4),%esi
sub    %esi,%eax
mov    %edx,%r9d
or     %al,%r9b
cmp    $0x1,%dl
sbb    $0xffffffffffffffff,%r10
or     $0x30,%al
mov    %al,0xc(%rsp,%r10,1)
mov    %edi,%eax
shr    $0x5,%eax
imul   $0xa7c5ac5,%rax,%rax
shr    $0x27,%rax
imul   $0xcccd,%eax,%edx
shr    $0x12,%edx
and    $0xfffffffe,%edx
lea    (%rdx,%rdx,4),%edx
sub    %edx,%eax
mov    %r9d,%esi
or     %al,%sil
cmp    $0x1,%r9b
sbb    $0xffffffffffffffff,%r10
or     $0x30,%al
mov    $0xd1b71759,%edx
imul   %r8,%rdx
shr    $0x2d,%rdx
mov    $0xcccccccd,%r9d
mov    %rdx,%rcx
imul   %r9,%rcx
shr    $0x23,%rcx
add    %ecx,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %ecx,%edx
mov    %esi,%ecx
or     %dl,%cl
cmp    $0x1,%sil
movzbl %r10b,%esi
sbb    $0xffffffffffffffff,%rsi
mov    %al,0xc(%rsp,%r10,1)
or     $0x30,%dl
mov    %dl,0xc(%rsp,%rsi,1)
imul   $0x10624dd3,%r8,%rax
shr    $0x26,%rax
mov    %rax,%rdx
imul   %r9,%rdx
shr    $0x23,%rdx
add    %edx,%edx
lea    (%rdx,%rdx,4),%edx
sub    %edx,%eax
mov    %ecx,%edx
or     %al,%dl
cmp    $0x1,%cl
sbb    $0xffffffffffffffff,%rsi
or     $0x30,%al
mov    %al,0xc(%rsp,%rsi,1)
imul   $0x51eb851f,%r8,%rcx
shr    $0x25,%rcx
mov    %rcx,%rax
imul   %r9,%rax
shr    $0x23,%rax
add    %eax,%eax
lea    (%rax,%rax,4),%eax
sub    %eax,%ecx
mov    %edx,%eax
or     %cl,%al
cmp    $0x1,%dl
sbb    $0xffffffffffffffff,%rsi
or     $0x30,%cl
mov    %cl,0xc(%rsp,%rsi,1)
cmp    $0x1,%al
sbb    $0xffffffffffffffff,%rsi
imul   %r9,%r8
shr    $0x23,%r8
imul   %r8,%r9
shr    $0x23,%r9
add    %r9d,%r9d
lea    (%r9,%r9,4),%ecx
mov    %r8d,%edx
sub    %ecx,%edx
mov    %edx,%ecx
or     $0x30,%cl
mov    %cl,0xc(%rsp,%rsi,1)
xor    %ecx,%ecx
or     %dl,%al
setne  %cl
add    %rsi,%rcx
add    %r8d,%r8d
lea    (%r8,%r8,4),%eax
sub    %eax,%edi
or     $0x30,%dil
mov    %dil,0xc(%rsp,%rcx,1)
movb   $0x0,0xd(%rsp,%rcx,1)
lea    0xc(%rsp),%rdi
call   1030 <puts@plt>
add    $0x18,%rsp
ret

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

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