#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 size_t uint32_t;
typedef size_t int32_t;

/* Variables and functions */
void int_to_string(int32_t number, char *target, size_t size) {
  int32_t i = size - 1;
  uint32_t j;
  target[i] = '\0';
  while (number && i--) {
    target[i] = number % 10 + '0';
    number = number / 10;
  }
  if (i <= 0)
    return;
  for (j = 0; j < (size - i); j++) {
    target[j] = target[j + i];
  }
}


x86 assembly (clang, -O0):
<int_to_string>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x18(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
xor    %eax,%eax
cmpq   $0x0,-0x8(%rbp)
mov    %al,-0x29(%rbp)
je     1151 <int_to_string+0x51>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
cmp    $0x0,%rax
setne  %al
mov    %al,-0x29(%rbp)
mov    -0x29(%rbp),%al
test   $0x1,%al
jne    1161 <int_to_string+0x61>
jmp    1195 <int_to_string+0x95>
mov    -0x8(%rbp),%rax
mov    $0xa,%ecx
xor    %edx,%edx
div    %rcx
add    $0x30,%rdx
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    $0xa,%ecx
xor    %edx,%edx
div    %rcx
mov    %rax,-0x8(%rbp)
jmp    1128 <int_to_string+0x28>
cmpq   $0x0,-0x20(%rbp)
ja     11a5 <int_to_string+0xa5>
jmp    11ed <int_to_string+0xed>
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    -0x20(%rbp),%rcx
cmp    %rcx,%rax
jae    11ed <int_to_string+0xed>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
add    -0x20(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    11ad <int_to_string+0xad>
pop    %rbp
ret

x86 assembly (clang, -O2):
<int_to_string>:
push   %r14
push   %rbx
mov    %rdx,%r8
lea    -0x1(%rdx),%rcx
movb   $0x0,-0x1(%rsi,%rdx,1)
test   %rdi,%rdi
je     1164 <int_to_string+0x64>
movabs $0xcccccccccccccccd,%r9
cc cc cc
mov    %rcx,%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
sub    $0x1,%r14
jb     116e <int_to_string+0x6e>
mov    %rdi,%rax
mul    %r9
shr    $0x3,%rdx
lea    (%rdx,%rdx,1),%eax
lea    (%rax,%rax,4),%eax
mov    %edi,%ebx
sub    %eax,%ebx
or     $0x30,%bl
mov    %bl,-0x1(%rsi,%rcx,1)
mov    %r14,%rcx
cmp    $0x9,%rdi
mov    %rdx,%rdi
ja     1130 <int_to_string+0x30>
test   %r14,%r14
jne    1175 <int_to_string+0x75>
jmp    11c4 <int_to_string+0xc4>
mov    %rcx,%r14
test   %r14,%r14
jne    1175 <int_to_string+0x75>
jmp    11c4 <int_to_string+0xc4>
mov    $0xffffffffffffffff,%r14
mov    %r8,%r10
sub    %r14,%r10
je     11c4 <int_to_string+0xc4>
cmp    $0x8,%r10
jb     1199 <int_to_string+0x99>
lea    (%rsi,%r14,1),%r9
lea    (%rsi,%r8,1),%rax
cmp    %rsi,%rax
jbe    11c8 <int_to_string+0xc8>
lea    (%rsi,%r10,1),%rax
cmp    %rax,%r9
jae    11c8 <int_to_string+0xc8>
xor    %r11d,%r11d
sub    %r11,%r8
add    %r11,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rsi,%r14,1),%eax
mov    %al,(%rsi)
add    $0xffffffffffffffff,%r8
add    $0x1,%rsi
cmp    %r8,%r14
jne    11b0 <int_to_string+0xb0>
pop    %rbx
pop    %r14
ret
cmp    $0x20,%r10
jae    11d6 <int_to_string+0xd6>
xor    %r11d,%r11d
jmp    12af <int_to_string+0x1af>
mov    %r10,%r11
and    $0xffffffffffffffe0,%r11
lea    -0x20(%r11),%rcx
mov    %rcx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%eax
and    $0x3,%eax
cmp    $0x60,%rcx
jae    11fb <int_to_string+0xfb>
xor    %edx,%edx
jmp    1268 <int_to_string+0x168>
and    $0xfffffffffffffffc,%rdi
lea    (%r14,%rsi,1),%rcx
add    $0x70,%rcx
xor    %edx,%edx
nopl   0x0(%rax)
movups -0x70(%rcx,%rdx,1),%xmm0
movups -0x60(%rcx,%rdx,1),%xmm1
movups %xmm0,(%rsi,%rdx,1)
movups %xmm1,0x10(%rsi,%rdx,1)
movups -0x50(%rcx,%rdx,1),%xmm0
movups -0x40(%rcx,%rdx,1),%xmm1
movups %xmm0,0x20(%rsi,%rdx,1)
movups %xmm1,0x30(%rsi,%rdx,1)
movups -0x30(%rcx,%rdx,1),%xmm0
movups -0x20(%rcx,%rdx,1),%xmm1
movups %xmm0,0x40(%rsi,%rdx,1)
movups %xmm1,0x50(%rsi,%rdx,1)
movups -0x10(%rcx,%rdx,1),%xmm0
movups (%rcx,%rdx,1),%xmm1
movups %xmm0,0x60(%rsi,%rdx,1)
movups %xmm1,0x70(%rsi,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rdi
jne    1210 <int_to_string+0x110>
test   %rax,%rax
je     129c <int_to_string+0x19c>
lea    (%rdx,%rsi,1),%rcx
add    $0x10,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rcx,%r14,1),%xmm0
movups (%rcx,%r14,1),%xmm1
movups %xmm0,-0x10(%rcx)
movups %xmm1,(%rcx)
add    $0x20,%rcx
add    $0xffffffffffffffff,%rax
jne    1280 <int_to_string+0x180>
cmp    %r11,%r10
je     11c4 <int_to_string+0xc4>
test   $0x18,%r10b
je     119c <int_to_string+0x9c>
mov    %r11,%rax
mov    %r10,%r11
and    $0xfffffffffffffff8,%r11
nopl   0x0(%rax)
mov    (%r9,%rax,1),%rcx
mov    %rcx,(%rsi,%rax,1)
add    $0x8,%rax
cmp    %rax,%r11
jne    12c0 <int_to_string+0x1c0>
cmp    %r11,%r10
je     11c4 <int_to_string+0xc4>
jmp    119c <int_to_string+0x9c>

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

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