#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*/ strcat(char *, char *);
void DecToHex(int dR, int dG, int dB, char *hRGB) {
  int modulo, i, j, rgb[3] = {dR, dG, dB};
  char tempRGB[3][3];
  hRGB[0] = '#';
  hRGB[1] = '\0';
  for (i = 0; i < 3; i++) {
    j = 0;
    while (rgb[i] > 0) {
      modulo = rgb[i] % 16;
      switch (modulo) {
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
      case 6:
      case 7:
      case 8:
      case 9:
      case 0:
        tempRGB[i][1 - j] = modulo + '0';
        break;
      case 10:
        tempRGB[i][1 - j] = 'a';
        break;
      case 11:
        tempRGB[i][1 - j] = 'b';
        break;
      case 12:
        tempRGB[i][1 - j] = 'c';
        break;
      case 13:
        tempRGB[i][1 - j] = 'd';
        break;
      case 14:
        tempRGB[i][1 - j] = 'e';
        break;
      case 15:
        tempRGB[i][1 - j] = 'f';
        break;
      }
      rgb[i] /= 16;
      j++;
    }
    tempRGB[i][j] = '\0';
  }
  for (i = 0; i < 3; i++) {
    strcat(hRGB, tempRGB[i]);
  }
}


x86 assembly (clang, -O0):
<DecToHex>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movb   $0x23,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x0,0x1(%rax)
movl   $0x0,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    12f6 <DecToHex+0x1e6>
movl   $0x0,-0x24(%rbp)
movslq -0x20(%rbp),%rax
cmpl   $0x0,-0x30(%rbp,%rax,4)
jle    12d1 <DecToHex+0x1c1>
movslq -0x20(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%eax
mov    %eax,%edx
add    $0xf,%edx
test   %eax,%eax
mov    %eax,%ecx
cmovs  %edx,%ecx
and    $0xfffffff0,%ecx
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %rax,-0x48(%rbp)
sub    $0xf,%rax
ja     12a5 <DecToHex+0x195>
mov    -0x48(%rbp),%rax
lea    0xe5b(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x1c(%rbp),%eax
add    $0x30,%eax
mov    %al,%dl
movslq -0x20(%rbp),%rcx
lea    -0x39(%rbp),%rax
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
mov    $0x1,%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    12a5 <DecToHex+0x195>
movslq -0x20(%rbp),%rcx
lea    -0x39(%rbp),%rax
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
mov    $0x1,%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x61,(%rax,%rcx,1)
jmp    12a5 <DecToHex+0x195>
movslq -0x20(%rbp),%rcx
lea    -0x39(%rbp),%rax
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
mov    $0x1,%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x62,(%rax,%rcx,1)
jmp    12a5 <DecToHex+0x195>
movslq -0x20(%rbp),%rcx
lea    -0x39(%rbp),%rax
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
mov    $0x1,%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x63,(%rax,%rcx,1)
jmp    12a5 <DecToHex+0x195>
movslq -0x20(%rbp),%rcx
lea    -0x39(%rbp),%rax
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
mov    $0x1,%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x64,(%rax,%rcx,1)
jmp    12a5 <DecToHex+0x195>
movslq -0x20(%rbp),%rcx
lea    -0x39(%rbp),%rax
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
mov    $0x1,%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x65,(%rax,%rcx,1)
jmp    12a5 <DecToHex+0x195>
movslq -0x20(%rbp),%rcx
lea    -0x39(%rbp),%rax
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
mov    $0x1,%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x66,(%rax,%rcx,1)
movslq -0x20(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x30(%rbp,%rax,4),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x50(%rbp),%rax
mov    %ecx,-0x30(%rbp,%rax,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    115e <DecToHex+0x4e>
movslq -0x20(%rbp),%rcx
lea    -0x39(%rbp),%rax
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    114d <DecToHex+0x3d>
movl   $0x0,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    132d <DecToHex+0x21d>
mov    -0x18(%rbp),%rdi
movslq -0x20(%rbp),%rax
lea    -0x39(%rbp),%rsi
imul   $0x3,%rax,%rax
add    %rax,%rsi
call   1030 <strcat@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12fd <DecToHex+0x1ed>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<DecToHex>:
push   %r15
push   %r14
push   %rbx
sub    $0x20,%rsp
mov    %rcx,%r15
mov    %edi,0x14(%rsp)
mov    %esi,0x18(%rsp)
mov    %edx,0x1c(%rsp)
movw   $0x23,(%rcx)
xor    %eax,%eax
test   %edi,%edi
jle    115e <DecToHex+0x4e>
lea    0xec6(%rip),%rcx
nopw   0x0(%rax,%rax,1)
mov    %edi,%edx
mov    %edi,%esi
and    $0xf,%esi
movzbl (%rsi,%rcx,1),%ebx
mov    %bl,0xc(%rsp,%rax,1)
shr    $0x4,%edi
add    $0xffffffffffffffff,%rax
cmp    $0xf,%edx
ja     1140 <DecToHex+0x30>
neg    %rax
mov    %edi,0x14(%rsp)
movb   $0x0,0xb(%rsp,%rax,1)
mov    0x18(%rsp),%ecx
xor    %eax,%eax
test   %ecx,%ecx
jle    119e <DecToHex+0x8e>
lea    0xe88(%rip),%rdx
nopl   0x0(%rax,%rax,1)
mov    %ecx,%esi
and    $0xf,%ecx
movzbl (%rcx,%rdx,1),%ecx
mov    %cl,0xf(%rsp,%rax,1)
mov    %esi,%ecx
shr    $0x4,%ecx
add    $0xffffffffffffffff,%rax
cmp    $0xf,%esi
ja     1180 <DecToHex+0x70>
neg    %rax
mov    %ecx,0x18(%rsp)
movb   $0x0,0xe(%rsp,%rax,1)
mov    0x1c(%rsp),%ecx
xor    %eax,%eax
test   %ecx,%ecx
jle    11de <DecToHex+0xce>
lea    0xe48(%rip),%rdx
nopl   0x0(%rax,%rax,1)
mov    %ecx,%esi
and    $0xf,%ecx
movzbl (%rcx,%rdx,1),%ecx
mov    %cl,0x12(%rsp,%rax,1)
mov    %esi,%ecx
shr    $0x4,%ecx
add    $0xffffffffffffffff,%rax
cmp    $0xf,%esi
ja     11c0 <DecToHex+0xb0>
neg    %rax
mov    %ecx,0x1c(%rsp)
lea    0x11(%rsp),%r14
movb   $0x0,0x11(%rsp,%rax,1)
lea    0xb(%rsp),%rsi
mov    %r15,%rdi
call   1030 <strcat@plt>
lea    0xe(%rsp),%rsi
mov    %r15,%rdi
call   1030 <strcat@plt>
mov    %r15,%rdi
mov    %r14,%rsi
call   1030 <strcat@plt>
add    $0x20,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @DecToHex(i32 %0, i32 %1, i32 %2, i8* %3) {
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca [3 x i32]
%13 = alloca [3 x [3 x i8]]
store i32 %0, i32* %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i8* %3, i8** %8
%14 = getelementptr inbounds [3 x i32], [3 x i32]* %12, i64 0, i64 0
%15 = load i32, i32* %5
store i32 %15, i32* %14
%16 = getelementptr inbounds i32, i32* %14, i64 1
%17 = load i32, i32* %6
store i32 %17, i32* %16
%18 = getelementptr inbounds i32, i32* %16, i64 1
%19 = load i32, i32* %7
store i32 %19, i32* %18
%20 = load i8*, i8** %8
%21 = getelementptr inbounds i8, i8* %20, i64 0
store i8 35, i8* %21
%22 = load i8*, i8** %8
%23 = getelementptr inbounds i8, i8* %22, i64 1
store i8 0, i8* %23
store i32 0, i32* %10
br label %24
24: ; preds = %115, %4
%25 = load i32, i32* %10
%26 = icmp slt i32 %25, 3
br i1 %26, label %27, label %118
27: ; preds = %24
store i32 0, i32* %11
br label %28
28: ; preds = %100, %27
%29 = load i32, i32* %10
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds [3 x i32], [3 x i32]* %12, i64 0, i64 %30
%32 = load i32, i32* %31
%33 = icmp sgt i32 %32, 0
br i1 %33, label %34, label %108
34: ; preds = %28
%35 = load i32, i32* %10
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [3 x i32], [3 x i32]* %12, i64 0, i64 %36
%38 = load i32, i32* %37
%39 = srem i32 %38, 16
store i32 %39, i32* %9
%40 = load i32, i32* %9
switch i32 %40, label %100 [
i32 1, label %41
i32 2, label %41
i32 3, label %41
i32 4, label %41
i32 5, label %41
i32 6, label %41
i32 7, label %41
i32 8, label %41
i32 9, label %41
i32 0, label %41
i32 10, label %52
i32 11, label %60
i32 12, label %68
i32 13, label %76
i32 14, label %84
i32 15, label %92
]
41: ; preds = %34, %34, %34, %34, %34, %34, %34, %34, %34, %34
%42 = load i32, i32* %9
%43 = add nsw i32 %42, 48
%44 = trunc i32 %43 to i8
%45 = load i32, i32* %10
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds [3 x [3 x i8]], [3 x [3 x i8]]* %13, i64 0, i64 %46
%48 = load i32, i32* %11
%49 = sub nsw i32 1, %48
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds [3 x i8], [3 x i8]* %47, i64 0, i64 %50
store i8 %44, i8* %51
br label %100
52: ; preds = %34
%53 = load i32, i32* %10
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds [3 x [3 x i8]], [3 x [3 x i8]]* %13, i64 0, i64 %54
%56 = load i32, i32* %11
%57 = sub nsw i32 1, %56
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds [3 x i8], [3 x i8]* %55, i64 0, i64 %58
store i8 97, i8* %59
br label %100
60: ; preds = %34
%61 = load i32, i32* %10
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [3 x [3 x i8]], [3 x [3 x i8]]* %13, i64 0, i64 %62
%64 = load i32, i32* %11
%65 = sub nsw i32 1, %64
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [3 x i8], [3 x i8]* %63, i64 0, i64 %66
store i8 98, i8* %67
br label %100
68: ; preds = %34
%69 = load i32, i32* %10
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds [3 x [3 x i8]], [3 x [3 x i8]]* %13, i64 0, i64 %70
%72 = load i32, i32* %11
%73 = sub nsw i32 1, %72
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [3 x i8], [3 x i8]* %71, i64 0, i64 %74
store i8 99, i8* %75
br label %100
76: ; preds = %34
%77 = load i32, i32* %10
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [3 x [3 x i8]], [3 x [3 x i8]]* %13, i64 0, i64 %78
%80 = load i32, i32* %11
%81 = sub nsw i32 1, %80
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds [3 x i8], [3 x i8]* %79, i64 0, i64 %82
store i8 100, i8* %83
br label %100
84: ; preds = %34
%85 = load i32, i32* %10
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds [3 x [3 x i8]], [3 x [3 x i8]]* %13, i64 0, i64 %86
%88 = load i32, i32* %11
%89 = sub nsw i32 1, %88
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds [3 x i8], [3 x i8]* %87, i64 0, i64 %90
store i8 101, i8* %91
br label %100
92: ; preds = %34
%93 = load i32, i32* %10
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds [3 x [3 x i8]], [3 x [3 x i8]]* %13, i64 0, i64 %94
%96 = load i32, i32* %11
%97 = sub nsw i32 1, %96
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds [3 x i8], [3 x i8]* %95, i64 0, i64 %98
store i8 102, i8* %99
br label %100
100: ; preds = %34, %92, %84, %76, %68, %60, %52, %41
%101 = load i32, i32* %10
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds [3 x i32], [3 x i32]* %12, i64 0, i64 %102
%104 = load i32, i32* %103
%105 = sdiv i32 %104, 16
store i32 %105, i32* %103
%106 = load i32, i32* %11
%107 = add nsw i32 %106, 1
store i32 %107, i32* %11
br label %28
108: ; preds = %28
%109 = load i32, i32* %10
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds [3 x [3 x i8]], [3 x [3 x i8]]* %13, i64 0, i64 %110
%112 = load i32, i32* %11
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds [3 x i8], [3 x i8]* %111, i64 0, i64 %113
store i8 0, i8* %114
br label %115
115: ; preds = %108
%116 = load i32, i32* %10
%117 = add nsw i32 %116, 1
store i32 %117, i32* %10
br label %24
118: ; preds = %24
store i32 0, i32* %10
br label %119
119: ; preds = %129, %118
%120 = load i32, i32* %10
%121 = icmp slt i32 %120, 3
br i1 %121, label %122, label %132
122: ; preds = %119
%123 = load i8*, i8** %8
%124 = load i32, i32* %10
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds [3 x [3 x i8]], [3 x [3 x i8]]* %13, i64 0, i64 %125
%127 = getelementptr inbounds [3 x i8], [3 x i8]* %126, i64 0, i64 0
%128 = call i32 @strcat(i8* %123, i8* %127)
br label %129
129: ; preds = %122
%130 = load i32, i32* %10
%131 = add nsw i32 %130, 1
store i32 %131, i32* %10
br label %119
132: ; preds = %119
ret void
}

LLVM IR (-O2):
@switch.table.DecToHex = [16 x i8] c"0123456789abcdef"
define void @DecToHex(i32 %0, i32 %1, i32 %2, i8* %3) {
%5 = alloca [3 x i32]
%6 = alloca [3 x [3 x i8]]
%7 = bitcast [3 x i32]* %5 to i8*
%8 = getelementptr inbounds [3 x i32], [3 x i32]* %5, i64 0, i64 0
store i32 %0, i32* %8
%9 = getelementptr inbounds [3 x i32], [3 x i32]* %5, i64 0, i64 1
store i32 %1, i32* %9
%10 = getelementptr inbounds [3 x i32], [3 x i32]* %5, i64 0, i64 2
store i32 %2, i32* %10
%11 = getelementptr inbounds [3 x [3 x i8]], [3 x [3 x i8]]* %6, i64 0, i64 0, i64 0
store i8 35, i8* %3
%12 = getelementptr inbounds i8, i8* %3, i64 1
store i8 0, i8* %12
%13 = getelementptr inbounds [3 x i32], [3 x i32]* %5, i64 0, i64 0
%14 = icmp sgt i32 %0, 0
br i1 %14, label %15, label %29
15: ; preds = %4, %15
%16 = phi i64 [ %25, %15 ], [ 0, %4 ]
%17 = phi i32 [ %24, %15 ], [ %0, %4 ]
%18 = and i32 %17, 15
%19 = zext i32 %18 to i64
%20 = getelementptr inbounds [16 x i8], [16 x i8]* @switch.table.DecToHex, i64 0, i64 %19
%21 = load i8, i8* %20
%22 = sub nsw i64 1, %16
%23 = getelementptr inbounds [3 x [3 x i8]], [3 x [3 x i8]]* %6, i64 0, i64 0, i64 %22
store i8 %21, i8* %23
%24 = lshr i32 %17, 4
%25 = add nuw nsw i64 %16, 1
%26 = icmp ult i32 %17, 16
br i1 %26, label %27, label %15
27: ; preds = %15
%28 = and i64 %25, 4294967295
br label %29
29: ; preds = %27, %4
%30 = phi i32 [ %0, %4 ], [ %24, %27 ]
%31 = phi i64 [ 0, %4 ], [ %28, %27 ]
store i32 %30, i32* %13
%32 = getelementptr inbounds [3 x [3 x i8]], [3 x [3 x i8]]* %6, i64 0, i64 0, i64 %31
store i8 0, i8* %32
%33 = getelementptr inbounds [3 x i32], [3 x i32]* %5, i64 0, i64 1
%34 = load i32, i32* %33
%35 = getelementptr inbounds [3 x i32], [3 x i32]* %5, i64 0, i64 1
%36 = icmp sgt i32 %34, 0
br i1 %36, label %37, label %51
37: ; preds = %29, %37
%38 = phi i64 [ %47, %37 ], [ 0, %29 ]
%39 = phi i32 [ %46, %37 ], [ %34, %29 ]
%40 = and i32 %39, 15
%41 = zext i32 %40 to i64
%42 = getelementptr inbounds [16 x i8], [16 x i8]* @switch.table.DecToHex, i64 0, i64 %41
%43 = load i8, i8* %42
%44 = sub nsw i64 1, %38
%45 = getelementptr inbounds [3 x [3 x i8]], [3 x [3 x i8]]* %6, i64 0, i64 1, i64 %44
store i8 %43, i8* %45
%46 = lshr i32 %39, 4
%47 = add nuw nsw i64 %38, 1
%48 = icmp ult i32 %39, 16
br i1 %48, label %49, label %37
49: ; preds = %37
%50 = and i64 %47, 4294967295
br label %51
51: ; preds = %49, %29
%52 = phi i32 [ %34, %29 ], [ %46, %49 ]
%53 = phi i64 [ 0, %29 ], [ %50, %49 ]
store i32 %52, i32* %35
%54 = getelementptr inbounds [3 x [3 x i8]], [3 x [3 x i8]]* %6, i64 0, i64 1, i64 %53
store i8 0, i8* %54
%55 = getelementptr inbounds [3 x i32], [3 x i32]* %5, i64 0, i64 2
%56 = load i32, i32* %55
%57 = getelementptr inbounds [3 x i32], [3 x i32]* %5, i64 0, i64 2
%58 = icmp sgt i32 %56, 0
br i1 %58, label %59, label %73
59: ; preds = %51, %59
%60 = phi i64 [ %69, %59 ], [ 0, %51 ]
%61 = phi i32 [ %68, %59 ], [ %56, %51 ]
%62 = and i32 %61, 15
%63 = zext i32 %62 to i64
%64 = getelementptr inbounds [16 x i8], [16 x i8]* @switch.table.DecToHex, i64 0, i64 %63
%65 = load i8, i8* %64
%66 = sub nsw i64 1, %60
%67 = getelementptr inbounds [3 x [3 x i8]], [3 x [3 x i8]]* %6, i64 0, i64 2, i64 %66
store i8 %65, i8* %67
%68 = lshr i32 %61, 4
%69 = add nuw nsw i64 %60, 1
%70 = icmp ult i32 %61, 16
br i1 %70, label %71, label %59
71: ; preds = %59
%72 = and i64 %69, 4294967295
br label %73
73: ; preds = %71, %51
%74 = phi i32 [ %56, %51 ], [ %68, %71 ]
%75 = phi i64 [ 0, %51 ], [ %72, %71 ]
store i32 %74, i32* %57
%76 = getelementptr inbounds [3 x [3 x i8]], [3 x [3 x i8]]* %6, i64 0, i64 2, i64 %75
store i8 0, i8* %76
%77 = call i32 @strcat(i8* %3, i8* %11)
%78 = getelementptr inbounds [3 x [3 x i8]], [3 x [3 x i8]]* %6, i64 0, i64 1, i64 0
%79 = call i32 @strcat(i8* %3, i8* %78)
%80 = getelementptr inbounds [3 x [3 x i8]], [3 x [3 x i8]]* %6, i64 0, i64 2, i64 0
%81 = call i32 @strcat(i8* %3, i8* %80)
ret void
}