#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(long int x) {
  int i = 0, j;
  int neg = (x < 0);
  char out[12] = {0};
  char final[12] = {0};
  x = (-2 * neg + 1) * x;
  if (x == 0) {
    puts("0");
  } else {
    while (x > 0) {
      out[i++] = x % 10;
      x /= 10;
    }
    j = i - 1;
    i = 0;
    if (neg)
      final[i++] = '-';
    while (j >= 0) {
      final[i++] = '0' + out[j--];
    }
    puts(final);
  }
}


x86 assembly (clang, -O0):
<puti>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
cmpq   $0x0,-0x8(%rbp)
setl   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x14(%rbp)
lea    -0x20(%rbp),%rdi
xor    %esi,%esi
mov    $0xc,%edx
call   1040 <memset@plt>
lea    -0x2c(%rbp),%rdi
xor    %esi,%esi
mov    $0xc,%edx
call   1040 <memset@plt>
imul   $0xfffffffe,-0x14(%rbp),%eax
add    $0x1,%eax
cltq
imul   -0x8(%rbp),%rax
mov    %rax,-0x8(%rbp)
cmpq   $0x0,-0x8(%rbp)
jne    1194 <puti+0x74>
lea    0xe76(%rip),%rdi
call   1030 <puts@plt>
jmp    124d <puti+0x12d>
jmp    1199 <puti+0x79>
cmpq   $0x0,-0x8(%rbp)
jle    11dc <puti+0xbc>
mov    -0x8(%rbp),%rax
mov    $0xa,%ecx
cqto
idiv   %rcx
mov    %dl,%cl
mov    -0xc(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0xc(%rbp)
cltq
mov    %cl,-0x20(%rbp,%rax,1)
mov    -0x8(%rbp),%rax
mov    $0xa,%ecx
cqto
idiv   %rcx
mov    %rax,-0x8(%rbp)
jmp    1199 <puti+0x79>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x10(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x0,-0x14(%rbp)
je     1208 <puti+0xe8>
mov    -0xc(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0xc(%rbp)
cltq
movb   $0x2d,-0x2c(%rbp,%rax,1)
jmp    120d <puti+0xed>
cmpl   $0x0,-0x10(%rbp)
jl     1244 <puti+0x124>
mov    -0x10(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x10(%rbp)
cltq
movsbl -0x20(%rbp,%rax,1),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0xc(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0xc(%rbp)
cltq
mov    %cl,-0x2c(%rbp,%rax,1)
jmp    120d <puti+0xed>
lea    -0x2c(%rbp),%rdi
call   1030 <puts@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<puti>:
push   %rbx
sub    $0x20,%rsp
movl   $0x0,0x18(%rsp)
movq   $0x0,0x10(%rsp)
movl   $0x0,0x8(%rsp)
movq   $0x0,(%rsp)
mov    %rdi,%rcx
sar    $0x3e,%rcx
or     $0x1,%rcx
imul   %rdi,%rcx
test   %rcx,%rcx
je     1246 <puti+0x136>
xor    %r9d,%r9d
mov    $0x0,%esi
test   %rcx,%rcx
jle    1197 <puti+0x87>
xor    %esi,%esi
movabs $0xcccccccccccccccd,%r8
cc cc cc
nopw   0x0(%rax,%rax,1)
mov    %rcx,%rax
mul    %r8
shr    $0x3,%rdx
lea    (%rdx,%rdx,1),%eax
lea    (%rax,%rax,4),%r10d
mov    %ecx,%eax
sub    %r10d,%eax
mov    %al,0x10(%rsp,%rsi,1)
add    $0x1,%rsi
cmp    $0x9,%rcx
mov    %rdx,%rcx
ja     1170 <puti+0x60>
test   %rdi,%rdi
jns    11a6 <puti+0x96>
movb   $0x2d,(%rsp)
mov    $0x1,%r9d
test   %esi,%esi
jle    1238 <puti+0x128>
mov    %esi,%r8d
mov    %r9d,%r11d
add    %esi,%r9d
mov    %r9,%r10
sub    %r11,%r10
cmp    $0x8,%r10
jae    1257 <puti+0x147>
mov    %r11,%rdi
mov    %r9d,%ecx
sub    %edi,%ecx
mov    %rdi,%rax
not    %rax
test   $0x1,%cl
je     11ef <puti+0xdf>
add    $0xffffffffffffffff,%r8
mov    %r8d,%ecx
mov    0x10(%rsp,%rcx,1),%cl
add    $0x30,%cl
mov    %cl,(%rsp,%rdi,1)
add    $0x1,%rdi
add    %r9,%rax
je     1238 <puti+0x128>
mov    %rsp,%rax
add    %rdi,%rax
add    $0x1,%rax
sub    %r9,%rdi
lea    -0x2(%r8),%rcx
mov    $0xffffffff,%edx
add    %r8,%rdx
xor    %esi,%esi
nop
lea    (%rdx,%rsi,1),%ebx
movzbl 0x10(%rsp,%rbx,1),%ebx
add    $0x30,%bl
mov    %bl,-0x1(%rax)
lea    (%rcx,%rsi,1),%ebx
movzbl 0x10(%rsp,%rbx,1),%ebx
add    $0x30,%bl
mov    %bl,(%rax)
add    $0xfffffffffffffffe,%rsi
add    $0x2,%rax
cmp    %rsi,%rdi
jne    1210 <puti+0x100>
mov    %rsp,%rdi
call   1030 <puts@plt>
add    $0x20,%rsp
pop    %rbx
ret
lea    0xdd3(%rip),%rdi
add    $0x20,%rsp
pop    %rbx
jmp    1030 <puts@plt>
mov    %r11,%rax
not    %rax
add    %r9,%rax
add    $0xffffffff,%esi
cmp    %eax,%esi
jb     11c7 <puti+0xb7>
shr    $0x20,%rax
jne    11c7 <puti+0xb7>
cmp    $0x20,%r10
jae    1282 <puti+0x172>
xor    %eax,%eax
jmp    1343 <puti+0x233>
mov    %r10,%rax
and    $0xffffffffffffffe0,%rax
lea    -0x1(%r8),%rsi
xor    %edi,%edi
movdqa 0xd69(%rip),%xmm0
pxor   %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
mov    %rdi,%rdx
or     %r11,%rdx
mov    %esi,%ecx
movdqu -0xf(%rsp,%rcx,1),%xmm2
movdqu 0x1(%rsp,%rcx,1),%xmm3
paddb  %xmm0,%xmm3
movdqa %xmm3,%xmm4
punpcklbw %xmm1,%xmm4
pshufd $0x4e,%xmm4,%xmm4
pshuflw $0x1b,%xmm4,%xmm4
pshufhw $0x1b,%xmm4,%xmm4
punpckhbw %xmm1,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
packuswb %xmm4,%xmm3
paddb  %xmm0,%xmm2
movdqa %xmm2,%xmm4
punpcklbw %xmm1,%xmm4
pshufd $0x4e,%xmm4,%xmm4
pshuflw $0x1b,%xmm4,%xmm4
pshufhw $0x1b,%xmm4,%xmm4
punpckhbw %xmm1,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm4,%xmm2
movdqu %xmm3,(%rsp,%rdx,1)
movdqu %xmm2,0x10(%rsp,%rdx,1)
add    $0x20,%rdi
add    $0xffffffffffffffe0,%rsi
cmp    %rdi,%rax
jne    12a0 <puti+0x190>
cmp    %rax,%r10
je     1238 <puti+0x128>
test   $0x18,%r10b
je     13b9 <puti+0x2a9>
mov    %r10,%rsi
and    $0xfffffffffffffff8,%rsi
lea    (%rsi,%r11,1),%rdi
mov    %rax,%rdx
not    %rdx
add    %r8,%rdx
sub    %rsi,%r8
movdqa 0xcae(%rip),%xmm0
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
mov    %rax,%rcx
or     %r11,%rcx
mov    %edx,%ebx
movq   0x9(%rsp,%rbx,1),%xmm2
paddb  %xmm0,%xmm2
punpcklbw %xmm1,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm2,%xmm2
movq   %xmm2,(%rsp,%rcx,1)
add    $0x8,%rax
add    $0xfffffffffffffff8,%rdx
cmp    %rax,%rsi
jne    1370 <puti+0x260>
cmp    %rsi,%r10
jne    11ca <puti+0xba>
jmp    1238 <puti+0x128>
sub    %rax,%r8
or     %rax,%r11
jmp    11c7 <puti+0xb7>

LLVM IR (-O0):
@.str = [2 x i8] c"0\00"
define void @puti(i64 %0) {
%2 = alloca i64
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca [12 x i8]
%7 = alloca [12 x i8]
store i64 %0, i64* %2
store i32 0, i32* %3
%8 = load i64, i64* %2
%9 = icmp slt i64 %8, 0
%10 = zext i1 %9 to i32
store i32 %10, i32* %5
%11 = bitcast [12 x i8]* %6 to i8*
%12 = bitcast [12 x i8]* %7 to i8*
%13 = load i32, i32* %5
%14 = mul nsw i32 -2, %13
%15 = add nsw i32 %14, 1
%16 = sext i32 %15 to i64
%17 = load i64, i64* %2
%18 = mul nsw i64 %16, %17
store i64 %18, i64* %2
%19 = load i64, i64* %2
%20 = icmp eq i64 %19, 0
br i1 %20, label %21, label %23
21: ; preds = %1
%22 = call i32 @puts(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
br label %67
23: ; preds = %1
br label %24
24: ; preds = %27, %23
%25 = load i64, i64* %2
%26 = icmp sgt i64 %25, 0
br i1 %26, label %27, label %37
27: ; preds = %24
%28 = load i64, i64* %2
%29 = srem i64 %28, 10
%30 = trunc i64 %29 to i8
%31 = load i32, i32* %3
%32 = add nsw i32 %31, 1
store i32 %32, i32* %3
%33 = sext i32 %31 to i64
%34 = getelementptr inbounds [12 x i8], [12 x i8]* %6, i64 0, i64 %33
store i8 %30, i8* %34
%35 = load i64, i64* %2
%36 = sdiv i64 %35, 10
store i64 %36, i64* %2
br label %24
37: ; preds = %24
%38 = load i32, i32* %3
%39 = sub nsw i32 %38, 1
store i32 %39, i32* %4
store i32 0, i32* %3
%40 = load i32, i32* %5
%41 = icmp ne i32 %40, 0
br i1 %41, label %42, label %47
42: ; preds = %37
%43 = load i32, i32* %3
%44 = add nsw i32 %43, 1
store i32 %44, i32* %3
%45 = sext i32 %43 to i64
%46 = getelementptr inbounds [12 x i8], [12 x i8]* %7, i64 0, i64 %45
store i8 45, i8* %46
br label %47
47: ; preds = %42, %37
br label %48
48: ; preds = %51, %47
%49 = load i32, i32* %4
%50 = icmp sge i32 %49, 0
br i1 %50, label %51, label %64
51: ; preds = %48
%52 = load i32, i32* %4
%53 = add nsw i32 %52, -1
store i32 %53, i32* %4
%54 = sext i32 %52 to i64
%55 = getelementptr inbounds [12 x i8], [12 x i8]* %6, i64 0, i64 %54
%56 = load i8, i8* %55
%57 = sext i8 %56 to i32
%58 = add nsw i32 48, %57
%59 = trunc i32 %58 to i8
%60 = load i32, i32* %3
%61 = add nsw i32 %60, 1
store i32 %61, i32* %3
%62 = sext i32 %60 to i64
%63 = getelementptr inbounds [12 x i8], [12 x i8]* %7, i64 0, i64 %62
store i8 %59, i8* %63
br label %48
64: ; preds = %48
%65 = getelementptr inbounds [12 x i8], [12 x i8]* %7, i64 0, i64 0
%66 = call i32 @puts(i8* %65)
br label %67
67: ; preds = %64, %21
ret void
}

LLVM IR (-O2):
@.str = [2 x i8] c"0\00"
define void @puti(i64 %0) {
%2 = alloca [12 x i8]
%3 = alloca [12 x i8]
%4 = icmp slt i64 %0, 0
%5 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 0
%6 = getelementptr inbounds [12 x i8], [12 x i8]* %3, i64 0, i64 0
%7 = ashr i64 %0, 62
%8 = or i64 %7, 1
%9 = mul nsw i64 %8, %0
%10 = icmp eq i64 %9, 0
br i1 %10, label %13, label %11
11: ; preds = %1
%12 = icmp sgt i64 %9, 0
br i1 %12, label %15, label %26
13: ; preds = %1
%14 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
br label %145
15: ; preds = %11, %15
%16 = phi i64 [ %20, %15 ], [ 0, %11 ]
%17 = phi i64 [ %22, %15 ], [ %9, %11 ]
%18 = urem i64 %17, 10
%19 = trunc i64 %18 to i8
%20 = add nuw i64 %16, 1
%21 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %16
store i8 %19, i8* %21
%22 = udiv i64 %17, 10
%23 = icmp ult i64 %17, 10
br i1 %23, label %24, label %15
24: ; preds = %15
%25 = trunc i64 %20 to i32
br label %26
26: ; preds = %24, %11
%27 = phi i32 [ 0, %11 ], [ %25, %24 ]
br i1 %4, label %28, label %29
28: ; preds = %26
store i8 45, i8* %6
br label %29
29: ; preds = %28, %26
%30 = phi i32 [ 1, %28 ], [ 0, %26 ]
%31 = icmp sgt i32 %27, 0
br i1 %31, label %32, label %143
32: ; preds = %29
%33 = zext i32 %27 to i64
%34 = zext i32 %30 to i64
%35 = add nuw i32 %27, %30
%36 = zext i32 %35 to i64
%37 = sub nsw i64 %36, %34
%38 = icmp ult i64 %37, 8
br i1 %38, label %105, label %39
39: ; preds = %32
%40 = xor i64 %34, -1
%41 = add nsw i64 %40, %36
%42 = add i32 %27, -1
%43 = trunc i64 %41 to i32
%44 = icmp ult i32 %42, %43
%45 = icmp ugt i64 %41, 4294967295
%46 = or i1 %44, %45
br i1 %46, label %105, label %47
47: ; preds = %39
%48 = icmp ult i64 %37, 32
br i1 %48, label %81, label %49
49: ; preds = %47
%50 = and i64 %37, -32
br label %51
51: ; preds = %51, %49
%52 = phi i64 [ 0, %49 ], [ %72, %51 ]
%53 = or i64 %52, %34
%54 = xor i64 %52, -1
%55 = add i64 %54, %33
%56 = and i64 %55, 4294967295
%57 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %56
%58 = getelementptr inbounds i8, i8* %57, i64 -15
%59 = bitcast i8* %58 to <16 x i8>*
%60 = load <16 x i8>, <16 x i8>* %59
%61 = getelementptr inbounds i8, i8* %57, i64 -31
%62 = bitcast i8* %61 to <16 x i8>*
%63 = load <16 x i8>, <16 x i8>* %62
%64 = add <16 x i8> %60, <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>
%65 = shufflevector <16 x i8> %64, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%66 = add <16 x i8> %63, <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>
%67 = shufflevector <16 x i8> %66, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%68 = getelementptr inbounds [12 x i8], [12 x i8]* %3, i64 0, i64 %53
%69 = bitcast i8* %68 to <16 x i8>*
store <16 x i8> %65, <16 x i8>* %69
%70 = getelementptr inbounds i8, i8* %68, i64 16
%71 = bitcast i8* %70 to <16 x i8>*
store <16 x i8> %67, <16 x i8>* %71
%72 = add nuw i64 %52, 32
%73 = icmp eq i64 %72, %50
br i1 %73, label %74, label %51
74: ; preds = %51
%75 = icmp eq i64 %37, %50
br i1 %75, label %143, label %76
76: ; preds = %74
%77 = sub nsw i64 %33, %50
%78 = or i64 %50, %34
%79 = and i64 %37, 24
%80 = icmp eq i64 %79, 0
br i1 %80, label %105, label %81
81: ; preds = %47, %76
%82 = phi i64 [ %50, %76 ], [ 0, %47 ]
%83 = sub nsw i64 %36, %34
%84 = and i64 %83, -8
%85 = or i64 %84, %34
%86 = sub nsw i64 %33, %84
br label %87
87: ; preds = %87, %81
%88 = phi i64 [ %82, %81 ], [ %101, %87 ]
%89 = or i64 %88, %34
%90 = xor i64 %88, -1
%91 = add i64 %90, %33
%92 = and i64 %91, 4294967295
%93 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %92
%94 = getelementptr inbounds i8, i8* %93, i64 -7
%95 = bitcast i8* %94 to <8 x i8>*
%96 = load <8 x i8>, <8 x i8>* %95
%97 = add <8 x i8> %96, <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>
%98 = shufflevector <8 x i8> %97, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%99 = getelementptr inbounds [12 x i8], [12 x i8]* %3, i64 0, i64 %89
%100 = bitcast i8* %99 to <8 x i8>*
store <8 x i8> %98, <8 x i8>* %100
%101 = add nuw i64 %88, 8
%102 = icmp eq i64 %101, %84
br i1 %102, label %103, label %87
103: ; preds = %87
%104 = icmp eq i64 %83, %84
br i1 %104, label %143, label %105
105: ; preds = %39, %32, %76, %103
%106 = phi i64 [ %34, %32 ], [ %34, %39 ], [ %78, %76 ], [ %85, %103 ]
%107 = phi i64 [ %33, %32 ], [ %33, %39 ], [ %77, %76 ], [ %86, %103 ]
%108 = sub nsw i64 %36, %106
%109 = xor i64 %106, -1
%110 = and i64 %108, 1
%111 = icmp eq i64 %110, 0
br i1 %111, label %120, label %112
112: ; preds = %105
%113 = add nsw i64 %107, -1
%114 = and i64 %113, 4294967295
%115 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %114
%116 = load i8, i8* %115
%117 = add i8 %116, 48
%118 = add nuw nsw i64 %106, 1
%119 = getelementptr inbounds [12 x i8], [12 x i8]* %3, i64 0, i64 %106
store i8 %117, i8* %119
br label %120
120: ; preds = %112, %105
%121 = phi i64 [ %106, %105 ], [ %118, %112 ]
%122 = phi i64 [ %107, %105 ], [ %113, %112 ]
%123 = sub nsw i64 0, %36
%124 = icmp eq i64 %109, %123
br i1 %124, label %143, label %125
125: ; preds = %120, %125
%126 = phi i64 [ %140, %125 ], [ %121, %120 ]
%127 = phi i64 [ %135, %125 ], [ %122, %120 ]
%128 = add i64 %127, 4294967295
%129 = and i64 %128, 4294967295
%130 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %129
%131 = load i8, i8* %130
%132 = add i8 %131, 48
%133 = add nuw nsw i64 %126, 1
%134 = getelementptr inbounds [12 x i8], [12 x i8]* %3, i64 0, i64 %126
store i8 %132, i8* %134
%135 = add nsw i64 %127, -2
%136 = and i64 %135, 4294967295
%137 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %136
%138 = load i8, i8* %137
%139 = add i8 %138, 48
%140 = add nuw nsw i64 %126, 2
%141 = getelementptr inbounds [12 x i8], [12 x i8]* %3, i64 0, i64 %133
store i8 %139, i8* %141
%142 = icmp eq i64 %140, %36
br i1 %142, label %143, label %125
143: ; preds = %120, %125, %74, %103, %29
%144 = call i32 @puts(i8* %6)
br label %145
145: ; preds = %143, %13
ret void
}