#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 int /*<<< orphan*/ value;

/* Variables and functions */
char *_itoa(unsigned long long, char *, unsigned int);
char *__attribute__((unused))
_fitoa(unsigned long long value, char *buf, unsigned int base, int upper_case) {
  char tmpbuf[sizeof(value) * 4];
  char *cp = _itoa(value, tmpbuf + sizeof(value) * 4, base);
  while (cp < tmpbuf + sizeof(value) * 4)
    *buf++ = *cp++;
  return buf;
}


x86 assembly (clang, -O0):
<_fitoa>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x40(%rbp),%rsi
add    $0x20,%rsi
mov    -0x14(%rbp),%edx
call   1030 <_itoa@plt>
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
lea    -0x40(%rbp),%rcx
add    $0x20,%rcx
cmp    %rcx,%rax
jae    117a <_fitoa+0x6a>
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x48(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    113e <_fitoa+0x2e>
mov    -0x10(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_fitoa>:
push   %r14
push   %rbx
sub    $0x28,%rsp
mov    %rsi,%rbx
lea    0x20(%rsp),%r14
mov    %r14,%rsi
call   1030 <_itoa@plt>
cmp    %r14,%rax
jae    12a3 <_fitoa+0x193>
mov    %r14,%r9
sub    %rax,%r9
cmp    $0x20,%r9
jb     122a <_fitoa+0x11a>
cmp    %rbx,%r14
jbe    1152 <_fitoa+0x42>
lea    (%rbx,%r9,1),%rcx
cmp    %rcx,%rax
jb     122a <_fitoa+0x11a>
mov    %r9,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rcx
mov    %rcx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x60,%rcx
jae    1177 <_fitoa+0x67>
xor    %edx,%edx
jmp    11d8 <_fitoa+0xc8>
and    $0xfffffffffffffffc,%rdi
xor    %edx,%edx
nopl   (%rax)
movups (%rax,%rdx,1),%xmm0
movups 0x10(%rax,%rdx,1),%xmm1
movups %xmm0,(%rbx,%rdx,1)
movups %xmm1,0x10(%rbx,%rdx,1)
movups 0x20(%rax,%rdx,1),%xmm0
movups 0x30(%rax,%rdx,1),%xmm1
movups %xmm0,0x20(%rbx,%rdx,1)
movups %xmm1,0x30(%rbx,%rdx,1)
movups 0x40(%rax,%rdx,1),%xmm0
movups 0x50(%rax,%rdx,1),%xmm1
movups %xmm0,0x40(%rbx,%rdx,1)
movups %xmm1,0x50(%rbx,%rdx,1)
movups 0x60(%rax,%rdx,1),%xmm0
movups 0x70(%rax,%rdx,1),%xmm1
movups %xmm0,0x60(%rbx,%rdx,1)
movups %xmm1,0x70(%rbx,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rdi
jne    1180 <_fitoa+0x70>
test   %rsi,%rsi
je     121b <_fitoa+0x10b>
lea    (%rbx,%rdx,1),%rdi
add    $0x10,%rdi
add    %rax,%rdx
add    $0x10,%rdx
shl    $0x5,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rdx,%rcx,1),%xmm0
movups (%rdx,%rcx,1),%xmm1
movups %xmm0,-0x10(%rdi,%rcx,1)
movups %xmm1,(%rdi,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rsi
jne    1200 <_fitoa+0xf0>
add    %r8,%rbx
cmp    %r8,%r9
je     12a3 <_fitoa+0x193>
add    %r8,%rax
mov    %eax,%edx
neg    %edx
mov    %rsp,%rsi
sub    %rax,%rsi
add    $0x1f,%rsi
and    $0x7,%rdx
je     1253 <_fitoa+0x143>
xchg   %ax,%ax
movzbl (%rax),%ecx
add    $0x1,%rax
mov    %cl,(%rbx)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rdx
jne    1240 <_fitoa+0x130>
cmp    $0x7,%rsi
jb     12a3 <_fitoa+0x193>
nopl   0x0(%rax)
movzbl (%rax),%ecx
mov    %cl,(%rbx)
movzbl 0x1(%rax),%ecx
mov    %cl,0x1(%rbx)
movzbl 0x2(%rax),%ecx
mov    %cl,0x2(%rbx)
movzbl 0x3(%rax),%ecx
mov    %cl,0x3(%rbx)
movzbl 0x4(%rax),%ecx
mov    %cl,0x4(%rbx)
movzbl 0x5(%rax),%ecx
mov    %cl,0x5(%rbx)
movzbl 0x6(%rax),%ecx
mov    %cl,0x6(%rbx)
movzbl 0x7(%rax),%ecx
mov    %cl,0x7(%rbx)
add    $0x8,%rbx
add    $0x8,%rax
cmp    %r14,%rax
jne    1260 <_fitoa+0x150>
mov    %rbx,%rax
add    $0x28,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define i8* @_fitoa(i64 %0, i8* %1, i32 %2, i32 %3) {
%5 = alloca i64
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
%9 = alloca [32 x i8]
%10 = alloca i8*
store i64 %0, i64* %5
store i8* %1, i8** %6
store i32 %2, i32* %7
store i32 %3, i32* %8
%11 = load i64, i64* %5
%12 = getelementptr inbounds [32 x i8], [32 x i8]* %9, i64 0, i64 0
%13 = getelementptr inbounds i8, i8* %12, i64 32
%14 = load i32, i32* %7
%15 = call i8* @_itoa(i64 %11, i8* %13, i32 %14)
store i8* %15, i8** %10
br label %16
16: ; preds = %21, %4
%17 = load i8*, i8** %10
%18 = getelementptr inbounds [32 x i8], [32 x i8]* %9, i64 0, i64 0
%19 = getelementptr inbounds i8, i8* %18, i64 32
%20 = icmp ult i8* %17, %19
br i1 %20, label %21, label %27
21: ; preds = %16
%22 = load i8*, i8** %10
%23 = getelementptr inbounds i8, i8* %22, i32 1
store i8* %23, i8** %10
%24 = load i8, i8* %22
%25 = load i8*, i8** %6
%26 = getelementptr inbounds i8, i8* %25, i32 1
store i8* %26, i8** %6
store i8 %24, i8* %25
br label %16
27: ; preds = %16
%28 = load i8*, i8** %6
ret i8* %28
}

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