#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*/ strcpy(char *, char *);
void sprintdec(int n, char *dest) {
  if (n == 0) {
    dest[0] = '0';
    dest[1] = '\0';
  }
  int acc = n;
  char c[32];
  int i = 0;
  while (acc > 0) {
    c[i] = '0' + acc % 10;
    acc /= 10;
    i++;
  }
  c[i] = 0;
  char c2[32];
  c2[i--] = 0;
  int j = 0;
  while (i >= 0) {
    c2[i--] = c[j++];
  }
  strcpy(dest, c2);
}


x86 assembly (clang, -O0):
<sprintdec>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
cmpl   $0x0,-0x4(%rbp)
jne    113b <sprintdec+0x2b>
mov    -0x10(%rbp),%rax
movb   $0x30,(%rax)
mov    -0x10(%rbp),%rax
movb   $0x0,0x1(%rax)
mov    -0x4(%rbp),%eax
mov    %eax,-0x14(%rbp)
movl   $0x0,-0x44(%rbp)
cmpl   $0x0,-0x14(%rbp)
jle    1186 <sprintdec+0x76>
mov    -0x14(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
movslq -0x44(%rbp),%rax
mov    %cl,-0x40(%rbp,%rax,1)
mov    -0x14(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1148 <sprintdec+0x38>
movslq -0x44(%rbp),%rax
movb   $0x0,-0x40(%rbp,%rax,1)
mov    -0x44(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x44(%rbp)
cltq
movb   $0x0,-0x70(%rbp,%rax,1)
movl   $0x0,-0x74(%rbp)
cmpl   $0x0,-0x44(%rbp)
jl     11d9 <sprintdec+0xc9>
mov    -0x74(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x74(%rbp)
cltq
mov    -0x40(%rbp,%rax,1),%cl
mov    -0x44(%rbp),%eax
mov    %eax,%edx
add    $0xffffffff,%edx
mov    %edx,-0x44(%rbp)
cltq
mov    %cl,-0x70(%rbp,%rax,1)
jmp    11a8 <sprintdec+0x98>
mov    -0x10(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1030 <strcpy@plt>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sprintdec>:
push   %rbx
sub    $0x40,%rsp
mov    %rsi,%r8
test   %edi,%edi
je     120d <sprintdec+0xfd>
jle    1213 <sprintdec+0x103>
xor    %ecx,%ecx
mov    $0xcccccccd,%r9d
xchg   %ax,%ax
mov    %edi,%edx
imul   %r9,%rdx
shr    $0x23,%rdx
lea    (%rdx,%rdx,1),%esi
lea    (%rsi,%rsi,4),%esi
mov    %edi,%eax
sub    %esi,%eax
or     $0x30,%al
mov    %al,0x20(%rsp,%rcx,1)
add    $0x1,%rcx
cmp    $0xa,%edi
mov    %edx,%edi
jae    1130 <sprintdec+0x20>
mov    %ecx,%r9d
movb   $0x0,0x20(%rsp,%r9,1)
movb   $0x0,(%rsp,%r9,1)
test   %ecx,%ecx
jle    121c <sprintdec+0x10c>
cmp    $0x8,%r9d
jae    122d <sprintdec+0x11d>
xor    %ebx,%ebx
mov    %r9,%rdi
mov    %ecx,%eax
sub    %ebx,%eax
mov    %rbx,%rsi
not    %rsi
add    %rsi,%r9
test   $0x3,%al
je     11b8 <sprintdec+0xa8>
mov    %ecx,%eax
sub    %bl,%al
movzbl %al,%eax
and    $0x3,%eax
cs nopw 0x0(%rax,%rax,1)
nop
add    $0xffffffffffffffff,%rdi
movzbl 0x20(%rsp,%rbx,1),%edx
add    $0x1,%rbx
mov    %edi,%esi
mov    %dl,(%rsp,%rsi,1)
add    $0xffffffffffffffff,%rax
jne    11a0 <sprintdec+0x90>
cmp    $0x3,%r9
jb     121c <sprintdec+0x10c>
mov    $0xfffffffe,%r9d
mov    %ecx,%r10d
nopw   0x0(%rax,%rax,1)
lea    (%rdi,%r9,1),%rdx
lea    0x1(%rdx),%esi
movzbl 0x20(%rsp,%rbx,1),%eax
movzbl 0x21(%rsp,%rbx,1),%ecx
mov    %al,(%rsp,%rsi,1)
mov    %edx,%eax
mov    %cl,(%rsp,%rax,1)
add    $0xffffffff,%edx
movzbl 0x22(%rsp,%rbx,1),%eax
mov    %al,(%rsp,%rdx,1)
add    $0xfffffffffffffffc,%rdi
movzbl 0x23(%rsp,%rbx,1),%eax
add    $0x4,%rbx
mov    %edi,%ecx
mov    %al,(%rsp,%rcx,1)
cmp    %rbx,%r10
jne    11d0 <sprintdec+0xc0>
jmp    121c <sprintdec+0x10c>
movw   $0x30,(%r8)
movb   $0x0,0x20(%rsp)
movb   $0x0,(%rsp)
mov    %rsp,%rsi
mov    %r8,%rdi
call   1030 <strcpy@plt>
add    $0x40,%rsp
pop    %rbx
ret
lea    -0x1(%r9),%rax
lea    -0x1(%rcx),%esi
xor    %ebx,%ebx
cmp    %eax,%esi
jb     1177 <sprintdec+0x67>
shr    $0x20,%rax
mov    %r9,%rdi
jne    117a <sprintdec+0x6a>
cmp    $0x20,%r9d
jae    1258 <sprintdec+0x148>
xor    %ebx,%ebx
jmp    131c <sprintdec+0x20c>
lea    -0x1(%rcx),%rax
mov    %ecx,%r10d
mov    %ecx,%edi
and    $0x1f,%edi
mov    %r9,%rbx
sub    %rdi,%rbx
sub    %rdi,%r10
xor    %esi,%esi
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqa 0x20(%rsp,%rsi,1),%xmm1
movdqa 0x30(%rsp,%rsi,1),%xmm2
mov    %eax,%r11d
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 %xmm1,-0xf(%rsp,%r11,1)
movdqa %xmm2,%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm1,%xmm2
movdqu %xmm2,-0x1f(%rsp,%r11,1)
add    $0x20,%rsi
add    $0xffffffffffffffe0,%rax
cmp    %rsi,%r10
jne    1280 <sprintdec+0x170>
test   %rdi,%rdi
je     121c <sprintdec+0x10c>
cmp    $0x8,%edi
jb     117a <sprintdec+0x6a>
mov    %rbx,%rsi
mov    %ecx,%r10d
mov    %ecx,%edi
and    $0x7,%edi
mov    %r9,%rbx
sub    %rdi,%rbx
mov    %rsi,%rax
not    %rax
add    %rcx,%rax
sub    %rdi,%r10
pxor   %xmm0,%xmm0
nopl   (%rax)
movq   0x20(%rsp,%rsi,1),%xmm1
punpcklbw %xmm0,%xmm1
mov    %eax,%r11d
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,-0x7(%rsp,%r11,1)
add    $0x8,%rsi
add    $0xfffffffffffffff8,%rax
cmp    %rsi,%r10
jne    1340 <sprintdec+0x230>
test   %rdi,%rdi
jne    117a <sprintdec+0x6a>
jmp    121c <sprintdec+0x10c>

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

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