#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 */
char dec_to_hex(int);
int strlen(char *);
void get_hex(int number, char *hex) {
  int reminder, get_reminder, current, put;
  char hex_container[10];
  for (current = 0; number > 0; current++) {
    reminder = number % 16;
    number = number / 16;
    hex_container[current] = dec_to_hex(reminder);
    if (number < 16) {
      for (get_reminder = current, put = 0; get_reminder >= 0;
           get_reminder--, put++) {
        if (put == 0) {
          hex[put] = dec_to_hex(number);
          get_reminder++;
        } else
          hex[put] = hex_container[get_reminder];
      }
    }
  }
  if (hex[0] == '0') {
    for (current = 0; current < strlen(hex) - 1; current++) {
      hex[current] = hex[current + 1];
    }
    hex[strlen(hex) - 1] = 0;
  }
}


x86 assembly (clang, -O0):
<get_hex>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x0,-0x4(%rbp)
jle    1203 <get_hex+0xe3>
mov    -0x4(%rbp),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    %edx,-0x14(%rbp)
mov    -0x4(%rbp),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    %eax,-0x4(%rbp)
mov    -0x14(%rbp),%edi
call   1040 <dec_to_hex@plt>
mov    %al,%cl
movslq -0x1c(%rbp),%rax
mov    %cl,-0x2a(%rbp,%rax,1)
cmpl   $0x10,-0x4(%rbp)
jge    11f0 <get_hex+0xd0>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
movl   $0x0,-0x20(%rbp)
cmpl   $0x0,-0x18(%rbp)
jl     11eb <get_hex+0xcb>
cmpl   $0x0,-0x20(%rbp)
jne    11bc <get_hex+0x9c>
mov    -0x4(%rbp),%edi
call   1040 <dec_to_hex@plt>
mov    %al,%dl
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11cf <get_hex+0xaf>
movslq -0x18(%rbp),%rax
mov    -0x2a(%rbp,%rax,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    11d4 <get_hex+0xb4>
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1185 <get_hex+0x65>
jmp    11f0 <get_hex+0xd0>
jmp    11f5 <get_hex+0xd5>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1136 <get_hex+0x16>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jne    1283 <get_hex+0x163>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x30(%rbp),%eax
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1262 <get_hex+0x142>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    121a <get_hex+0xfa>
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x38(%rbp),%rax
sub    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_hex>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rsi,%r15
test   %edi,%edi
jle    12da <get_hex+0x1ba>
mov    %edi,%r14d
mov    $0x1,%r13d
xor    %ebp,%ebp
jmp    1162 <get_hex+0x42>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r13
cmp    $0xf,%r12d
mov    (%rsp),%rbp
jbe    12da <get_hex+0x1ba>
mov    %r14d,%r12d
lea    0x1(%rbp),%rax
mov    %rax,(%rsp)
mov    %r14d,%edi
and    $0xf,%edi
shr    $0x4,%r14d
call   1040 <dec_to_hex@plt>
mov    %al,0xe(%rsp,%rbp,1)
cmp    $0xff,%r12d
ja     1150 <get_hex+0x30>
mov    %r14d,%edi
call   1040 <dec_to_hex@plt>
mov    %al,(%r15)
test   %ebp,%ebp
js     1150 <get_hex+0x30>
lea    0x1(%rbp),%r8d
mov    $0x1,%edx
cmp    $0x7,%rbp
jb     12ac <get_hex+0x18c>
cmp    $0xf,%rbp
jae    11c0 <get_hex+0xa0>
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
mov    (%rsp),%rbx
jmp    124c <get_hex+0x12c>
mov    %r13,%rdx
and    $0xfffffffffffffff0,%rdx
mov    (%rsp),%rbx
mov    %rbx,%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rbp,%rsi
xor    %edi,%edi
pxor   %xmm2,%xmm2
nopl   0x0(%rax,%rax,1)
mov    %esi,%eax
movdqu -0x1(%rsp,%rax,1),%xmm0
movdqa %xmm0,%xmm1
punpcklbw %xmm2,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
punpckhbw %xmm2,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm1,%xmm0
movdqu %xmm0,0x1(%r15,%rdi,1)
add    $0x10,%rdi
add    $0xfffffffffffffff0,%rsi
cmp    %rdi,%rdx
jne    11e0 <get_hex+0xc0>
cmp    %rcx,%rbx
je     1150 <get_hex+0x30>
mov    (%rsp),%rbx
test   $0x8,%bl
jne    1248 <get_hex+0x128>
sub    %ecx,%r8d
or     $0x1,%rcx
mov    %rcx,%rdx
jmp    12ac <get_hex+0x18c>
pxor   %xmm1,%xmm1
mov    %r13,%rsi
and    $0xfffffffffffffff8,%rsi
mov    %rbx,%rdi
and    $0xfffffffffffffff8,%rdi
lea    0x1(%rdi),%rdx
sub    %edi,%r8d
sub    %rcx,%rbp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %ebp,%eax
movq   0x7(%rsp,%rax,1),%xmm0
punpcklbw %xmm1,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm0,%xmm0
movq   %xmm0,0x1(%r15,%rcx,1)
add    $0x8,%rcx
add    $0xfffffffffffffff8,%rbp
cmp    %rcx,%rsi
jne    1270 <get_hex+0x150>
cmp    %rdi,%rbx
je     1150 <get_hex+0x30>
add    %r15,%rdx
lea    0x1(%r8),%ecx
add    $0xffffffff,%r8d
lea    (%rsp,%r8,1),%rax
add    $0xe,%rax
nop
movzbl (%rax),%ebx
mov    %bl,(%rdx)
add    $0x1,%rdx
add    $0xffffffff,%ecx
add    $0xffffffffffffffff,%rax
cmp    $0x1,%ecx
ja     12c0 <get_hex+0x1a0>
jmp    1150 <get_hex+0x30>
cmpb   $0x30,(%r15)
jne    1324 <get_hex+0x204>
mov    %r15,%rdi
call   1030 <strlen@plt>
cmp    $0x2,%eax
jl     1314 <get_hex+0x1f4>
xor    %eax,%eax
nop
lea    0x1(%rax),%rbx
movzbl 0x1(%r15,%rax,1),%ecx
mov    %cl,(%r15,%rax,1)
mov    %r15,%rdi
call   1030 <strlen@plt>
add    $0xffffffff,%eax
movslq %eax,%rcx
mov    %rbx,%rax
cmp    %rcx,%rbx
jl     12f0 <get_hex+0x1d0>
mov    %r15,%rdi
call   1030 <strlen@plt>
cltq
movb   $0x0,-0x1(%rax,%r15,1)
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @get_hex(i32 %0, i8* %1) {
%3 = alloca i32
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca [10 x i8]
store i32 %0, i32* %3
store i8* %1, i8** %4
store i32 0, i32* %7
br label %10
10: ; preds = %59, %2
%11 = load i32, i32* %3
%12 = icmp sgt i32 %11, 0
br i1 %12, label %13, label %62
13: ; preds = %10
%14 = load i32, i32* %3
%15 = srem i32 %14, 16
store i32 %15, i32* %5
%16 = load i32, i32* %3
%17 = sdiv i32 %16, 16
store i32 %17, i32* %3
%18 = load i32, i32* %5
%19 = call signext i8 @dec_to_hex(i32 %18)
%20 = load i32, i32* %7
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds [10 x i8], [10 x i8]* %9, i64 0, i64 %21
store i8 %19, i8* %22
%23 = load i32, i32* %3
%24 = icmp slt i32 %23, 16
br i1 %24, label %25, label %58
25: ; preds = %13
%26 = load i32, i32* %7
store i32 %26, i32* %6
store i32 0, i32* %8
br label %27
27: ; preds = %52, %25
%28 = load i32, i32* %6
%29 = icmp sge i32 %28, 0
br i1 %29, label %30, label %57
30: ; preds = %27
%31 = load i32, i32* %8
%32 = icmp eq i32 %31, 0
br i1 %32, label %33, label %42
33: ; preds = %30
%34 = load i32, i32* %3
%35 = call signext i8 @dec_to_hex(i32 %34)
%36 = load i8*, i8** %4
%37 = load i32, i32* %8
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds i8, i8* %36, i64 %38
store i8 %35, i8* %39
%40 = load i32, i32* %6
%41 = add nsw i32 %40, 1
store i32 %41, i32* %6
br label %51
42: ; preds = %30
%43 = load i32, i32* %6
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds [10 x i8], [10 x i8]* %9, i64 0, i64 %44
%46 = load i8, i8* %45
%47 = load i8*, i8** %4
%48 = load i32, i32* %8
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i8, i8* %47, i64 %49
store i8 %46, i8* %50
br label %51
51: ; preds = %42, %33
br label %52
52: ; preds = %51
%53 = load i32, i32* %6
%54 = add nsw i32 %53, -1
store i32 %54, i32* %6
%55 = load i32, i32* %8
%56 = add nsw i32 %55, 1
store i32 %56, i32* %8
br label %27
57: ; preds = %27
br label %58
58: ; preds = %57, %13
br label %59
59: ; preds = %58
%60 = load i32, i32* %7
%61 = add nsw i32 %60, 1
store i32 %61, i32* %7
br label %10
62: ; preds = %10
%63 = load i8*, i8** %4
%64 = getelementptr inbounds i8, i8* %63, i64 0
%65 = load i8, i8* %64
%66 = sext i8 %65 to i32
%67 = icmp eq i32 %66, 48
br i1 %67, label %68, label %96
68: ; preds = %62
store i32 0, i32* %7
br label %69
69: ; preds = %86, %68
%70 = load i32, i32* %7
%71 = load i8*, i8** %4
%72 = call i32 @strlen(i8* %71)
%73 = sub nsw i32 %72, 1
%74 = icmp slt i32 %70, %73
br i1 %74, label %75, label %89
75: ; preds = %69
%76 = load i8*, i8** %4
%77 = load i32, i32* %7
%78 = add nsw i32 %77, 1
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds i8, i8* %76, i64 %79
%81 = load i8, i8* %80
%82 = load i8*, i8** %4
%83 = load i32, i32* %7
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds i8, i8* %82, i64 %84
store i8 %81, i8* %85
br label %86
86: ; preds = %75
%87 = load i32, i32* %7
%88 = add nsw i32 %87, 1
store i32 %88, i32* %7
br label %69
89: ; preds = %69
%90 = load i8*, i8** %4
%91 = load i8*, i8** %4
%92 = call i32 @strlen(i8* %91)
%93 = sub nsw i32 %92, 1
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds i8, i8* %90, i64 %94
store i8 0, i8* %95
br label %96
96: ; preds = %89, %62
ret void
}

LLVM IR (-O2):
define void @get_hex(i32 %0, i8* %1) {
%3 = alloca [10 x i8]
%4 = getelementptr inbounds [10 x i8], [10 x i8]* %3, i64 0, i64 0
%5 = icmp sgt i32 %0, 0
br i1 %5, label %6, label %87
6: ; preds = %2, %84
%7 = phi i64 [ %85, %84 ], [ 0, %2 ]
%8 = phi i32 [ %12, %84 ], [ %0, %2 ]
%9 = add nuw i64 %7, 1
%10 = add nuw i64 %7, 1
%11 = and i32 %8, 15
%12 = lshr i32 %8, 4
%13 = tail call signext i8 @dec_to_hex(i32 %11)
%14 = getelementptr inbounds [10 x i8], [10 x i8]* %3, i64 0, i64 %7
store i8 %13, i8* %14
%15 = icmp ult i32 %8, 256
br i1 %15, label %16, label %84
16: ; preds = %6
%17 = trunc i64 %7 to i32
%18 = tail call signext i8 @dec_to_hex(i32 %12)
store i8 %18, i8* %1
%19 = add nuw nsw i32 %17, 1
%20 = icmp sgt i32 %17, -1
br i1 %20, label %21, label %84
21: ; preds = %16
%22 = icmp ult i64 %7, 7
br i1 %22, label %71, label %23
23: ; preds = %21
%24 = icmp ult i64 %7, 15
br i1 %24, label %49, label %25
25: ; preds = %23
%26 = and i64 %10, -16
br label %27
27: ; preds = %27, %25
%28 = phi i64 [ 0, %25 ], [ %39, %27 ]
%29 = or i64 %28, 1
%30 = sub i64 %7, %28
%31 = and i64 %30, 4294967295
%32 = getelementptr inbounds [10 x i8], [10 x i8]* %3, i64 0, i64 %31
%33 = getelementptr inbounds i8, i8* %32, i64 -15
%34 = bitcast i8* %33 to <16 x i8>*
%35 = load <16 x i8>, <16 x i8>* %34
%36 = shufflevector <16 x i8> %35, <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>
%37 = getelementptr inbounds i8, i8* %1, i64 %29
%38 = bitcast i8* %37 to <16 x i8>*
store <16 x i8> %36, <16 x i8>* %38
%39 = add nuw i64 %28, 16
%40 = icmp eq i64 %39, %26
br i1 %40, label %41, label %27
41: ; preds = %27
%42 = icmp eq i64 %10, %26
br i1 %42, label %84, label %43
43: ; preds = %41
%44 = trunc i64 %26 to i32
%45 = sub i32 %19, %44
%46 = or i64 %26, 1
%47 = and i64 %10, 8
%48 = icmp eq i64 %47, 0
br i1 %48, label %71, label %49
49: ; preds = %23, %43
%50 = phi i64 [ %26, %43 ], [ 0, %23 ]
%51 = and i64 %9, -8
%52 = or i64 %51, 1
%53 = trunc i64 %51 to i32
%54 = sub i32 %19, %53
br label %55
55: ; preds = %55, %49
%56 = phi i64 [ %50, %49 ], [ %67, %55 ]
%57 = or i64 %56, 1
%58 = sub i64 %7, %56
%59 = and i64 %58, 4294967295
%60 = getelementptr inbounds [10 x i8], [10 x i8]* %3, i64 0, i64 %59
%61 = getelementptr inbounds i8, i8* %60, i64 -7
%62 = bitcast i8* %61 to <8 x i8>*
%63 = load <8 x i8>, <8 x i8>* %62
%64 = shufflevector <8 x i8> %63, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%65 = getelementptr inbounds i8, i8* %1, i64 %57
%66 = bitcast i8* %65 to <8 x i8>*
store <8 x i8> %64, <8 x i8>* %66
%67 = add nuw i64 %56, 8
%68 = icmp eq i64 %67, %51
br i1 %68, label %69, label %55
69: ; preds = %55
%70 = icmp eq i64 %9, %51
br i1 %70, label %84, label %71
71: ; preds = %21, %43, %69
%72 = phi i64 [ 1, %21 ], [ %46, %43 ], [ %52, %69 ]
%73 = phi i32 [ %19, %21 ], [ %45, %43 ], [ %54, %69 ]
br label %74
74: ; preds = %71, %74
%75 = phi i64 [ %82, %74 ], [ %72, %71 ]
%76 = phi i32 [ %77, %74 ], [ %73, %71 ]
%77 = add nsw i32 %76, -1
%78 = zext i32 %77 to i64
%79 = getelementptr inbounds [10 x i8], [10 x i8]* %3, i64 0, i64 %78
%80 = load i8, i8* %79
%81 = getelementptr inbounds i8, i8* %1, i64 %75
store i8 %80, i8* %81
%82 = add nuw i64 %75, 1
%83 = icmp ugt i32 %76, 1
br i1 %83, label %74, label %84
84: ; preds = %74, %41, %69, %16, %6
%85 = add nuw nsw i64 %7, 1
%86 = icmp ult i32 %8, 16
br i1 %86, label %87, label %6
87: ; preds = %84, %2
%88 = load i8, i8* %1
%89 = icmp eq i8 %88, 48
br i1 %89, label %90, label %108
90: ; preds = %87
%91 = tail call i32 @strlen(i8* %1)
%92 = icmp sgt i32 %91, 1
br i1 %92, label %93, label %103
93: ; preds = %90, %93
%94 = phi i64 [ %95, %93 ], [ 0, %90 ]
%95 = add nuw nsw i64 %94, 1
%96 = getelementptr inbounds i8, i8* %1, i64 %95
%97 = load i8, i8* %96
%98 = getelementptr inbounds i8, i8* %1, i64 %94
store i8 %97, i8* %98
%99 = tail call i32 @strlen(i8* %1)
%100 = add nsw i32 %99, -1
%101 = sext i32 %100 to i64
%102 = icmp slt i64 %95, %101
br i1 %102, label %93, label %103
103: ; preds = %93, %90
%104 = tail call i32 @strlen(i8* %1)
%105 = add nsw i32 %104, -1
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds i8, i8* %1, i64 %106
store i8 0, i8* %107
br label %108
108: ; preds = %103, %87
ret void
}