#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*/ write(int, char *, int);
void writeint(int num) {
  char buf[20];
  char result[20] = "0\n";
  char *pos = buf;
  char *writeptr = result;
  int numWritten;
  if (num < 0) {
    *writeptr++ = '-';
    num = -num;
  }
  if (num > 0) {
    while (num > 0) {
      *pos++ = (num % 10) + '0';
      num /= 10;
    }
    pos--;
    while (pos > buf) {
      *writeptr++ = *pos--;
    }
    *writeptr++ = *pos;
    *writeptr++ = 10;
    *writeptr++ = 0;
  } else {
    writeptr = result + 3;
  }
  write(1, result, (writeptr - result) - 1);
}


x86 assembly (clang, -O0):
<writeint>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %edi,-0x4(%rbp)
mov    0xede(%rip),%rax
mov    %rax,-0x40(%rbp)
mov    0xedb(%rip),%rax
mov    %rax,-0x38(%rbp)
mov    0xed9(%rip),%eax
mov    %eax,-0x30(%rbp)
lea    -0x20(%rbp),%rax
mov    %rax,-0x48(%rbp)
lea    -0x40(%rbp),%rax
mov    %rax,-0x50(%rbp)
cmpl   $0x0,-0x4(%rbp)
jge    116e <writeint+0x5e>
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x50(%rbp)
movb   $0x2d,(%rax)
xor    %eax,%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x4(%rbp)
cmpl   $0x0,-0x4(%rbp)
jle    123f <writeint+0x12f>
jmp    117d <writeint+0x6d>
cmpl   $0x0,-0x4(%rbp)
jle    11bb <writeint+0xab>
mov    -0x4(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
mov    -0x4(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0x4(%rbp)
jmp    117d <writeint+0x6d>
mov    -0x48(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
lea    -0x20(%rbp),%rcx
cmp    %rcx,%rax
jbe    11ff <writeint+0xef>
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x48(%rbp)
mov    (%rax),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
jmp    11c7 <writeint+0xb7>
mov    -0x48(%rbp),%rax
mov    (%rax),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x50(%rbp)
movb   $0xa,(%rax)
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x50(%rbp)
movb   $0x0,(%rax)
jmp    124b <writeint+0x13b>
lea    -0x40(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x50(%rbp)
lea    -0x40(%rbp),%rsi
mov    -0x50(%rbp),%rax
lea    -0x40(%rbp),%rcx
sub    %rcx,%rax
sub    $0x1,%rax
mov    %eax,%edx
mov    $0x1,%edi
call   1030 <write@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<writeint>:
push   %rbx
sub    $0x40,%rsp
movdqa 0xee3(%rip),%xmm0
movdqa %xmm0,(%rsp)
movl   $0x0,0x10(%rsp)
test   %edi,%edi
js     1139 <writeint+0x29>
je     12aa <writeint+0x19a>
mov    %rsp,%r9
jmp    1144 <writeint+0x34>
lea    0x1(%rsp),%r9
movb   $0x2d,(%rsp)
neg    %edi
mov    $0xffffffffffffffff,%rax
xor    %ecx,%ecx
mov    $0xcccccccd,%r8d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %edi,%esi
imul   %r8,%rsi
shr    $0x23,%rsi
lea    (%rsi,%rsi,1),%ebx
lea    (%rbx,%rbx,4),%ebx
mov    %edi,%edx
sub    %ebx,%edx
or     $0x30,%dl
mov    %dl,0x20(%rsp,%rcx,1)
add    $0x1,%rcx
add    $0x1,%rax
cmp    $0xa,%edi
mov    %esi,%edi
jae    1160 <writeint+0x50>
lea    (%rsp,%rcx,1),%rsi
add    $0x1f,%rsi
lea    0x20(%rsp),%rdx
cmp    %rdx,%rsi
jbe    1297 <writeint+0x187>
lea    -0x1(%rcx),%r8
mov    %r9,%rdx
cmp    $0x20,%r8
jb     126f <writeint+0x15f>
mov    %r8,%r10
and    $0xffffffffffffffe0,%r10
and    $0xffffffffffffffe0,%rax
neg    %rax
add    %rsp,%rax
add    $0x20,%rax
lea    -0x1(%rcx,%rax,1),%rsi
lea    (%r9,%r10,1),%rdx
lea    0x10(%r9),%rax
mov    %r10,%r11
neg    %r11
xor    %edi,%edi
pxor   %xmm0,%xmm0
nop
lea    (%rsp,%rdi,1),%rbx
add    $0x20,%rbx
movdqu -0x20(%rcx,%rbx,1),%xmm1
movdqu -0x10(%rcx,%rbx,1),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,-0x10(%rax)
movdqu %xmm1,(%rax)
add    $0x20,%rax
add    $0xffffffffffffffe0,%rdi
cmp    %rdi,%r11
jne    11e0 <writeint+0xd0>
cmp    %r10,%r8
je     129a <writeint+0x18a>
lea    (%r9,%rcx,1),%rax
add    $0xfffffffffffffffe,%rax
mov    %rdx,%rcx
nopw   0x0(%rax,%rax,1)
movzbl (%rsi),%ebx
lea    0x1(%rcx),%rdx
mov    %bl,(%rcx)
add    $0xffffffffffffffff,%rsi
cmp    %rcx,%rax
mov    %rdx,%rcx
jne    1280 <writeint+0x170>
jmp    129a <writeint+0x18a>
mov    %r9,%rdx
mov    (%rsi),%al
mov    %al,(%rdx)
movw   $0xa,0x1(%rdx)
add    $0x3,%rdx
jmp    12af <writeint+0x19f>
lea    0x3(%rsp),%rdx
mov    %rsp,%rsi
mov    %esi,%eax
not    %eax
add    %eax,%edx
mov    $0x1,%edi
call   1030 <write@plt>
add    $0x40,%rsp
pop    %rbx
ret

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

LLVM IR (-O2):
@__const.writeint.result = [20 x i8] c"0\0A\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00"
define void @writeint(i32 %0) {
%2 = alloca [20 x i8]
%3 = ptrtoint [20 x i8]* %2 to i64
%4 = alloca [20 x i8]
%5 = getelementptr inbounds [20 x i8], [20 x i8]* %2, i64 0, i64 0
%6 = getelementptr inbounds [20 x i8], [20 x i8]* %4, i64 0, i64 0
%7 = icmp slt i32 %0, 0
br i1 %7, label %8, label %11
8: ; preds = %1
%9 = getelementptr inbounds [20 x i8], [20 x i8]* %4, i64 0, i64 1
store i8 45, i8* %6
%10 = sub nsw i32 0, %0
br label %13
11: ; preds = %1
%12 = icmp eq i32 %0, 0
br i1 %12, label %78, label %13
13: ; preds = %11, %8
%14 = phi i32 [ %10, %8 ], [ %0, %11 ]
%15 = phi i8* [ %9, %8 ], [ %6, %11 ]
br label %55
16: ; preds = %55
%17 = icmp ugt i8* %57, %5
br i1 %17, label %18, label %71
18: ; preds = %16
%19 = ptrtoint i8* %61 to i64
%20 = add i64 %19, -2
%21 = sub i64 %20, %3
%22 = getelementptr i8, i8* %15, i64 %21
%23 = xor i64 %3, -1
%24 = add i64 %23, %19
%25 = icmp ult i64 %24, 32
br i1 %25, label %52, label %26
26: ; preds = %18
%27 = and i64 %24, -32
%28 = sub i64 0, %27
%29 = getelementptr i8, i8* %57, i64 %28
%30 = getelementptr i8, i8* %15, i64 %27
br label %31
31: ; preds = %31, %26
%32 = phi i64 [ 0, %26 ], [ %48, %31 ]
%33 = sub i64 0, %32
%34 = getelementptr i8, i8* %57, i64 %33
%35 = getelementptr i8, i8* %15, i64 %32
%36 = getelementptr i8, i8* %34, i64 -15
%37 = bitcast i8* %36 to <16 x i8>*
%38 = load <16 x i8>, <16 x i8>* %37
%39 = shufflevector <16 x i8> %38, <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>
%40 = getelementptr i8, i8* %34, i64 -16
%41 = getelementptr i8, i8* %40, i64 -15
%42 = bitcast i8* %41 to <16 x i8>*
%43 = load <16 x i8>, <16 x i8>* %42
%44 = shufflevector <16 x i8> %43, <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>
%45 = bitcast i8* %35 to <16 x i8>*
store <16 x i8> %39, <16 x i8>* %45
%46 = getelementptr i8, i8* %35, i64 16
%47 = bitcast i8* %46 to <16 x i8>*
store <16 x i8> %44, <16 x i8>* %47
%48 = add nuw i64 %32, 32
%49 = icmp eq i64 %48, %27
br i1 %49, label %50, label %31
50: ; preds = %31
%51 = icmp eq i64 %24, %27
br i1 %51, label %71, label %52
52: ; preds = %18, %50
%53 = phi i8* [ %57, %18 ], [ %29, %50 ]
%54 = phi i8* [ %15, %18 ], [ %30, %50 ]
br label %64
55: ; preds = %13, %55
%56 = phi i32 [ %62, %55 ], [ %14, %13 ]
%57 = phi i8* [ %61, %55 ], [ %5, %13 ]
%58 = urem i32 %56, 10
%59 = trunc i32 %58 to i8
%60 = or i8 %59, 48
%61 = getelementptr inbounds i8, i8* %57, i64 1
store i8 %60, i8* %57
%62 = udiv i32 %56, 10
%63 = icmp ult i32 %56, 10
br i1 %63, label %16, label %55
64: ; preds = %52, %64
%65 = phi i8* [ %69, %64 ], [ %53, %52 ]
%66 = phi i8* [ %68, %64 ], [ %54, %52 ]
%67 = load i8, i8* %65
%68 = getelementptr inbounds i8, i8* %66, i64 1
store i8 %67, i8* %66
%69 = getelementptr inbounds i8, i8* %65, i64 -1
%70 = icmp eq i8* %66, %22
br i1 %70, label %71, label %64
71: ; preds = %64, %50, %16
%72 = phi i8* [ %15, %16 ], [ %30, %50 ], [ %68, %64 ]
%73 = phi i8* [ %57, %16 ], [ %29, %50 ], [ %69, %64 ]
%74 = load i8, i8* %73
%75 = getelementptr inbounds i8, i8* %72, i64 1
store i8 %74, i8* %72
%76 = getelementptr inbounds i8, i8* %72, i64 2
store i8 10, i8* %75
%77 = getelementptr inbounds i8, i8* %72, i64 3
store i8 0, i8* %76
br label %80
78: ; preds = %11
%79 = getelementptr inbounds [20 x i8], [20 x i8]* %4, i64 0, i64 3
br label %80
80: ; preds = %78, %71
%81 = phi i8* [ %77, %71 ], [ %79, %78 ]
%82 = ptrtoint i8* %81 to i64
%83 = ptrtoint [20 x i8]* %4 to i64
%84 = xor i64 %83, -1
%85 = add i64 %82, %84
%86 = trunc i64 %85 to i32
%87 = call i32 @write(i32 1, i8* %6, i32 %86)
ret void
}